Anonymní profil vitamin – Programujte.com
 x   TIP: Přetáhni ikonu na hlavní panel pro připnutí webu
Reklama

Anonymní profil vitamin – Programujte.comAnonymní profil vitamin – Programujte.com

 

Příspěvky odeslané z IP adresy 95.105.157.–

C / C++ › Dynamická Struktura
14. 5. 2013   #176204

#8 Petr
Tebe by stacilo toto:


struct VERTEX{
	float x;
	float y;
	float z;
};

#include <vector>

int main(){
	std::vector<VERTEX> data(7);

	data[0].x = 7;
	data[0].y = 8;

	data[1].x = 9;
	data[1].z = 10;
//....

}
C / C++ › Dynamická Struktura
14. 5. 2013   #176201

#6 Petr
Nebolo by lepsie to spravyt ako triedu/strukturu s konstruktorom a destruktorom, pripadne rovno pouzit std::vector?

C / C++ › Vytvorenie dvojrozmerneho po…
14. 5. 2013   #176198

#20 tomino
Takato deklaracia pola je chybna, musis tam mat aj inicializaciu:


int Trasa[][2] = {{1, 2}, {3, 4}};	//velkost bude [2][2]

1. rozmer pola za teba doplni kompilator.

C / C++ › Vytvorenie dvojrozmerneho po…
14. 5. 2013   #176183

#18 Honza
stl je sice dvolezita cast c++, ale treba vediet pracovat aj s poliami.

C / C++ › konkordance
10. 5. 2013   #176039

#5 lukas011
Ten zoznam je asi OK, len mu chyba destruktor ktory zmaze prvky.

C / C++ › konkordance
10. 5. 2013   #176034

#3 lukas011
Ked si zvladol spravyt binarny strom tak zretazeny zoznam by mal byt uplna hracka. Zisti si ci mozes pouzit stl, s kontajnermi je to program na par riadkov.

C / C++ › konkordance
10. 5. 2013   #176030

Ty si si v podstate implementoval binarny strom kde je hodnota uzlu totozna s klucom (mohol si pouzit kontainer std::set). Tebe by sa viac oplatilo pouzit std::map, cize kazdy uzol ma 'kluc' podla ktoreho sa zoraduje a 'hodnotu' ktora obsahuje cisla riadkov. Napr:

struct Node{
	std::string key;	//slovo
	std::vector<size_t> value;	//cislo riadkov na ktorych sa dane slovo nachadza
        Node* l, r;
};

//-----------------------------------------------
//pomocou stl:

std::map<std::string, std::vector<size_t>> words;	

words["slovo"].push_back(3);	
words["slovo"].push_back(6);
words["slovo2"].push_back(7);
//...

C / C++ › třetí nejmenší prvek v dolní…
9. 5. 2013   #176012

#1 Lamidlakov
Na nete je uz tato uloha vypracovana (sice nie uplne dobre, ale mozes sa inspirovat), staci hladat.

C / C++ › ošetření programu na špatné…
9. 5. 2013   #176004

#13 kedlik
Dal som ti sem link na tutorial, preco si ho neprecitas?

break - okamžitě ukončuje provádění cyklu a opouští jej

continue – udělá skok na konec cyklu a vynutí jeho opakování, cyklus se tedy neukončuje

C / C++ › Pokročilejšia literatúra C++
9. 5. 2013   #175999
C / C++ › Převádění čísel v soustavách…
8. 5. 2013   #175970

#2 Lukáš
Na prevod cisel v oct, dec a hex formate mozes pouzit std::stringstream(a manipulatory std::oct, std::dec, std::hex) alebo std::sscanf (%d, %o, %x). Nacitanie a vypis ciesel v binarnom formate si musis naprogramovat sam ale na tomto fore je uz dost vela rieseni, staci hladat.

Vypis cisla v binanom formate sa lahko robi pomocou bitovych masiek(algoritmus je medz komentami //A a //B):

#include <iostream>

template <typename Integer>
struct Bin{
	const Integer num;
	operator Integer()const{return num;}
};

template <typename Integer>
Bin<Integer> bin(Integer num){return Bin<Integer>{num};}

template <typename Integer>
std::ostream& operator<<(std::ostream& out, Bin<Integer> bin_num){
	typedef typename std::make_unsigned<Integer>::type UnsignedInteger;

        //A
	UnsignedInteger num = bin_num;
	
	for(UnsignedInteger mask = 1; mask /*&& (mask <= num)*/; mask *= 2){		if(num & mask)out << '1';
		else out << '0';
	}
	//B

	return out;
}


int main(){
	using namespace std;
	
	std::cout
		<< bin<char>(95) << endl	
		<< bin<short>(34395) << endl
		<< bin(9034395) << endl		
		<< bin(47392999034395L) << endl;	

}
C / C++ › ošetření programu na špatné…
8. 5. 2013   #175947

#9 kedlik
return-om sa ukoncuje cela funkcia, na ukoncenie cyklu sluzi nieco ine (podrobnosti mas v tom linku co som ti sem dal vyzsie)

C / C++ › ošetření programu na špatné…
8. 5. 2013   #175942
C / C++ › ošetření programu na špatné…
8. 5. 2013   #175938

#3 kedlik
Pouzi cyklus (for, while, do-while).


cyklus{

    printf("Zadej pocet kotoucu :\n") ;      
    scanf("%i", &n);
    if (n>10){
	//...
    }
    else if (n<0){
        //...
    }
    else{
 	stop_cyklu;
    }

}
cnt=PVez(n,1,2,3);
printf("Pocet volani: %i\n", cnt);
getchar();
return 0;
C / C++ › Více problémů s maticema
5. 5. 2013   #175824

#13 Sefiros
Akonahle funkcia vracia premennu, tak vratena premenna je rvalue. Ak chces vytvorit referenciu na rvalue tak ta referencia musi byt konstantna:

 
Tu mas moznosti kopirovacich konstruktorov (tvoja trieda moze mat aj vsetky 3):

//1.
Matrix(Matrix& m){/*...*/}	//ako parameter moze byt lvalue, co je hociaka premenna s menom alebo ina referencia

//2.
Matrix(const Matrix& m){/*...*/}	//ako parameter sa moze pouzit lvalue aj rvalue (rvalue su docasne premenne ako vysledok dakeho vyrazu, vratena premenna z funkcie, ...)

//3.
Matrix(Matrix&& m){/*...*/}	//ako parameter sa moze pouzit len rvalue

//vysledok tohto vyrazu je rvalue a ten moze byt skopyrovany len konstruktorom 2. a 3.
third+first;

edit:

Tvoj kod sa da o dost sprehladnit:

template <class T>
std::ostream& operator<<(std::ostream& out, Matrix<T>& m){
	for (int i=0;i<m.returnHeight();++i){
		for (int y=0;y<m.returnWidth();++y){
			out << m.at(y,i) << ", ";
		}
		out << std::endl;
	}
	return out;
}

template <class T>
Matrix<T> make_random_matrix(int r, int s){
	Matrix<T> m(r, s);
	
    for (int i=0;i<m.returnHeight();++i)
    {
        for (int y=0;y<m.returnWidth();++y)
        {
            m.fill(y,i,rand()%100);
        }
    }
    
    return m;
}

int main()
{
    using namespace std;
    
    Matrix<int> first = make_random_matrix<int>(3, 3);
    cout << "FIRST: " << endl << first << endl;

    Matrix<int> second = make_random_matrix<int>(3, 3);;	
    cout << "SECOND: " << endl << second << endl;
   
    Matrix<int> third = second;
    cout << "THIRD: " << endl << third << endl;

    third = third+first;
    cout << "THIRD+FIRST: " << endl << third << endl;

    return 0;
}

edit2:

Doporucujem ti vsade kde mozes davat const, napr:

template <class T>
class Matrix
{
	/*
	...
	 */
	
    //matica 'givenMatrix' sa nebude menit, tak ju oznac ako const
    Matrix(const Matrix<T> &givenMatrix);

    //matica 'givenMatrix' sa nebude menit, tak ju oznac ako const
    Matrix<T>& operator=(const Matrix<T> givenMatrix);
    
    //matica 'givenMatrix' sa nebude menit, tak ju oznac ako const
    //matica 'this' sa tiez nebude menit, tak oznac metodu ako const
    Matrix<T> operator+(const Matrix<T> &givenMatrix)const;

    //getery tiez oznac ako const:
    int returnWidth()const{return width;}
    int returnHeight()const{return height;}
    operator bool()const{return fail;}
    
    //verzia at() ktora umoznuje upravovat prvky v matici:
    T& at(int m_width,int m_height);
    
    //verzia at ktora neumoznuje upravovat prvky v matici
    const T& at(int m_width,int m_height)const;
    
};
C / C++ › Více problémů s maticema
5. 5. 2013   #175814

#8 Sefiros
Konstruktor sa vola pri vytvoreni triedy a destruktor sa vola ked objekt zanika.

V podstate pred volanim konstruktora obsahuje trieda nahodne data. Ty si zavolal destruktor na zaciatku construktora. Cize premenna 'dataCore' obsahovala nahodnu adresu a ty si s nou pracoval ako s dynamicky alkovanym polom.

Ty si pouzil na vytvorenie matice 2 rozmerne pole, s nim sa lepsie pracuje, ale dlhsie trva jeho vytvorenie a mazanie.

ingiraxo pouzil 1 rozmerne pole, to sa alokuje jednoduhsie (staci 1 new/delete), ale zas sa s nim horsie pracuje lebo musis vyratavat index podla velkosti matice a taky operator[] sa bude musiet riesit cez medzi triedu...

Obydva sposoby sa daju pouzit, kazdy ma vlastne vyhody/nevyhody. Ak si opravys chyby v tvojom kode tak to nemusis cele prerabat.

C / C++ › Více problémů s maticema
5. 5. 2013   #175808

#5 Sefiros
Pada ti to preto lebo rucne volas destructor tam kde nemas. 

C / C++ › Více problémů s maticema
5. 5. 2013   #175806

#1 Sefiros
 

#include <stdexcept>

template <class T>
matrix<T>	/*<-musis specifikovat aj template parameter navratoveho typu ak je definicia mimo triedy*/ 
matrix<T>::operator+(const /*<- parameter funkcie sa nebude menit*/ matrix<T> &x)const /*<- this funkcie sa nebude menit*/{
	
	//ak chces pouzivat konstruktory a operatory v ktorych moze nastat chyba, ale nemozes ju vratit ako navratovu hodnotu tak sa oplati pouzivat vynimky:
	if(width != x.width || height != x.height)throw std::logic_error("pokus o scitnie 2 matic s roznymi velkostami");
	    
	//this sa kludne moze rovnat parametru x:
	matrix temp(width,height);
	for(int i=0; i < width; ++i)
		for(int y=0;y < height;++y)
			temp.dataCore[i][y] =  dataCore[i][y] + x.dataCore[i][y];
		
	//treba mat copy construtor, idealne aj move constructor (c++11)
	return temp;
}

Ak pouzivas c++11, sprav aj move constructor kvoly tomu aby pri vracani matice nevznikali zbitocne kopie.

Ak nepozivas c++11, pretaz radsej matrix& operator+=(const matrix& ).

operator= mas ties zle.
 

C / C++ › Cout << 3*char
3. 5. 2013   #175752

#14 Kéfas

Co to znamena 1 prikz?

Ak si myslel jeden vyraz (expression statement)  tak sa to stale da   :

#include <iostream> 
int main(){return std::cout << "Zadej znak: " << std::string(3, std::cin.get()), 0;}
C / C++ › Cout << 3*char
3. 5. 2013   #175743

#12 Kéfas
Neni problem, stacia 2  

#include <iostream> 
int main(){std::cout << "Zadej znak: ";char c;std::cin >> c;std::cout << c << c << c;return 0;}
C / C++ › Cout << 3*char
2. 5. 2013   #175688

#9 MachiavelliCz
Ta "tazsia" cast je zle. 

C / C++ › Vraceni dat z objektu bez mo…
1. 5. 2013   #175655

#1 SpatnyProgramator
Kludne pouzi const referenciu/pointer, pouziva sa to.

C / C++ › Orientace grafu
27. 4. 2013   #175508

Kedze sa chces dostat z kazdeho uzla na vsetky ostatne tak predpokladam ze je to cykliky graf. V podstate ti staci vybrat si hociaky uzol a zacat vytvarat nahodne cestu (pridavat orientaciu hranam) dovtedy dokym sa nedostanes do uzlu z ktoreho si prisiel. Potom si vyberes hociaky iny uzol z ktoreho vychadza neoriantovana hrana a spravys to iste ak predtym dokym sa nedostanes do uzlu ktory neobsahuje neorientovane hrany. Opakujes to dokym graf obsahuje neorientovane hrany.

Snad je to dobre :)

C / C++ › Cout << 3*char
27. 4. 2013   #175502

#4 Kéfas
Píšem bez rozmýšlania, ponáhľam sa.

To vecsinou konci zle :)

C / C++ › Cout << 3*char
27. 4. 2013   #175498

Ak nasobis integer s charom tak vysledok je integer:

Znak 'i' ma hodnotu 105, ak ho vynasobis 3 tak mas 315.

Ak si chcel znak vypisat 3x tak si mal spravyt nieco taketo:

std::cout << z[0] << z[0] << z[0]; 

Preco si vlastne pouzil jednoprvkove pole?

C / C++ › Parsing Stringu v C++
22. 4. 2013   #175384

#5 Martin
Treba na to stiahnut kniznicu. 

Pod nepovinnymi medzerami som mal na mysli nieco taketo:

//medzery na spravnych miestach sa ignoruju:
1,3,1000,-2,4,1000
1,3 ,   1000,-2, 4,1000
 1  ,    3,   1000,-2,4,1000
1,  3,1000,  -2,  4,1000

Ak predpokladas ze vstupny retazec je spravne zadany a nemusis ho kontrolovat tak ti bude stacit aj stringstream ako napisal crazy.

Pre trochu zlozitejsie veci daky tokenizer (strtok, boost::tokenizer, alebo si napis vlastny)

Mozno by sli pouzit aj regexy, tie su ale az v c++11(v gcc nefunguju) alebo v booste.

Mozes si spravyt aj stavovy automat, to je asi najpracnejsie, ale mas najviac moznosti.

C / C++ › Parsing Stringu v C++
22. 4. 2013   #175380

#1 Martin
Riesit sa to da vela sposobmi, zalezi od ci tam chces mat volitelne udaje ako nepovinne medzery a pod. 

Najjednoduhsie je asi pouzitie boost::tokenizer

C / C++ › C Funkce jako parametr funkce
21. 4. 2013   #175273
C / C++ › Doplnění zdrojového kodu o n…
20. 4. 2013   #175257

#8 Grungy
To nie je pravda, destructory sa volaju.

Mozes si to skusit:

#include <iostream>
struct C{
	
	C(){std::cerr << "construct\n";}
	~C(){std::cerr << "destruct\n";}
};
int main(){
	{
		C c;
		goto labelA;
		
	}
	labelA:;

}
C / C++ › Doplnění zdrojového kodu o n…
19. 4. 2013   #175234

#3 Karel Bern
Ak chces zobrazit menu pred kazdou volbou tak ho zobrazuj vo vnutri cyklu.

#4 bak
Suhlasim s tym ze pouzivanie  goto by sa malo obmedzit na minimum, ale toto je jeden z mala prikladov kde je dobre pouzit goto. Akonahle mas vnorene cykly alebo switche tak s break-om vyskocis len z jedneho cyklu/switchu. Pomocou goto mozes vyskocit z viacerych, je to rychlejsie a prehladnejsie ako testovat flagy.

C / C++ › Doplnění zdrojového kodu o n…
19. 4. 2013   #175231

 Mozes skusit nieco taketo:

int volba;

while(1){
	std::cin >> volba;	//alebo scanf ak pouzivas c

	switch(volba){
		case 0:
			//...
			break;
		case 1:
			//...
			break;
		
		//...

		case 8:
			goto stop;	
		

	}
}
stop:;		//goto label

	
C / C++ › Práce s textovým souborem v C
18. 4. 2013   #175203

#4 Tari

Tak tu vyzvu prijmi :)

C / C++ › Paralelní Sort
18. 4. 2013   #175157

#9 hoacin
Sice ti neodpoviem na tvoju otazku (neovladam OpenMP) ale tvoj kod sa da urychlit aj inymi sposobmi. 

Najprv by si sa mal vykaslat na qsort. Radsej pouzi std::sort ktory umoznuje inlinovat porovnavaciu funkciu.

Aky pouzivas kompilator? (Nemozes pouzit thready z c++11 ?   http://en.cppreference.com/w/cpp/thread)

C / C++ › Paralelní Sort
17. 4. 2013   #175108

Mozes pouzit quick sort a merge sort. Na tych linkoch mas obrazky ako funguju, pole vecsinou delis na viacej casti a tie potom rekruzivne sortujes. Mozes sortovat kazdu cast v inom vlakne. Pouzivas c alebo c++? 

C / C++ › Průtok dat polem
15. 4. 2013   #175020
C / C++ › Kritická sekce pro jednotliv…
14. 4. 2013   #174964

Mozes skusit nieco taketo:

#include <iostream>
#include <vector>
#include <mutex>
#include <future>
#include <chrono>
#include <thread>

//pointer na data ktory uzamkne mutex
template <class T, class M = std::mutex>
class lock_ptr{
		T* ptr;
		M &m;
	public:
		T* operator->(){return ptr;}
		T& operator*(){return *ptr;}
		
		lock_ptr(T* t, M& m):ptr(t), m(m){
			m.lock();
		}
		~lock_ptr(){
			m.unlock();
		}
};

template <class T, class M = std::mutex>
lock_ptr<T, M> make_lock_ptr(T* t, M& m){return lock_ptr<T, M>(t, m);}

class C{
		std::vector<int> a;
		std::mutex	m_a;
		
		std::vector<int> b;
		std::mutex	m_b;
	
	public:
		lock_ptr<std::vector<int>> lock_a(){return make_lock_ptr(&a, m_a);}
		lock_ptr<std::vector<int>> lock_b(){return make_lock_ptr(&b, m_b);}
};


int main(){
	C c;
	
	
	auto a1 = std::async(std::launch::async, [&c](){
		auto x = c.lock_a(); 
		std::this_thread::sleep_for( std::chrono::seconds(2) );
		for(int i = 0; i < 10000; ++i)
			x->push_back(i);
			
		std::cerr << "a1 end\n";
	});
	
	
		
	auto a2 = std::async(std::launch::async, [&c](){
		auto x = c.lock_b();
		for(int i = 10; i > 0; --i)
			x->push_back(i);
			
		std::cerr << "a2 end\n";
		
	});
	
	
	
	auto a3 = std::async(std::launch::async, [&c](){
		auto x = c.lock_a();
			
		std::cerr << "a3 end\n";
		
	});
	
		
}
C / C++ › WIN API WM_PAINT
9. 4. 2013   #174748

#1 unk
Na konci case-u by si mal dat break;

C / C++ › Odebrání lambda funkce z pole
8. 4. 2013   #174684

#7 ingiraxo
lambda funkcia nema ziadny globalny ani lokalny identifikator, takze si musis adresu ulozit do dkej premennej. Mozno by bolo lepsie pouzit obycajnu funkciu.

C / C++ › Odebrání lambda funkce z pole
8. 4. 2013   #174682

#5 ingiraxo
Lamda funkcie bez atributov mozes jednoducho pretypovat na pointer, cize vies adresu. V pripade lamdy s atributom je to trochu zlozitejsie:


	//lambdy bez atributov:
	void (*fnc1)(const std::string&) = [](const std::string& s)->void{};
	void (*fnc2)(const std::string&) = [](const std::string& s)->void{};

	if(fnc1 == fnc2);
	else;

	//s atributmi:
	int i;
	auto a1 = [&i](){return i+1;};
	auto a2 = [&i](){return i+2;};

	//
	if(reinterpret_cast<void*>(&decltype(a1)::operator()) == reinterpret_cast<void*>(&decltype(a2)::operator()));
	else;

        //pripdane mozes porovnavat adresy samotnych objektov, vtedy ale nesmies lambda objekt kopirovat
C / C++ › Odebrání lambda funkce z pole
8. 4. 2013   #174679

#3 ingiraxo
To pole ma fixnu velkost, takze z neho nemozes nic odstranit, maximalne mozes prvky vynulovat:

pole[0] = nullptr;
pole[1] = nullptr;
C / C++ › Odebrání lambda funkce z pole
8. 4. 2013   #174677

#1 ingiraxo
Lamda funkcia je v podstate trieda s pretazenym operatorom (). Ak neprebera lamda ziadne atributy tak sa moze pretypovat na pointer na funkciu (vtedy je perator() staticka metoda).

Z lamdou mozes pracovat ako s akymkolvek inym objektom.

(lamda ma standartne aj kopy konstruktor a operator= ak tomu nebrania atributy lambdy)

C / C++ › Zásobník a pole
7. 4. 2013   #174624
C / C++ › Zásobník a pole
7. 4. 2013   #174621

#11 Luckin
rvalue referencia. Pouziva sa na presuvanie objektov:

#include <iostream>

class C{
	double* data;

	public:
		C(){
			std::cout << "C()\n";
			data = new double[10000];
		}

		~C(){
			std::cout << "!C()\n";
			delete[] data;
		}

		C(const C& c){	//copy constructor (musi prekopyrovat vsetkych 10k prvkov)
		
			std::cout << "C(const C&)\n";
			data = new double[10000];
			for(size_t i = 0; i < 10000; ++i)
				data[i] = c.data[i];
		}
		C(C&& c){	//move constructor (iba presunie prvky, konstruktor vie ze objekt c sa uz nebude pouzivat)
			std::cout << "C(C&&)\n";
			data = c.data;	
			c.data = nullptr;
		}
};

C create_C(){
	C c;
	return c;	//vola sa move constructor
	return C();	//toto zabrani optimalizaciam...
}

int main(){
	C c1;

	C c2(c1);		//vola sa copy constructor

	C c3 = create_C();	
}

http://en.wikipedia.org/wiki/C%2B%2B11#Rvalue_references_and_move_constructors

C / C++ › Zásobník a pole
7. 4. 2013   #174615

#9 Koler

Ucis sa c alebo c++ ?

C / C++ › Zásobník a pole
7. 4. 2013   #174600

#6 Luckin
Da sa to riesit aj ovla efektivnejsie:

#include <iostream>
#include <type_traits>
#include <stdexcept>


template <class T, size_t N>
class stack{
	private:
		char data[sizeof(T)*N];
		size_t pos;
		
		inline T* t_data(size_t i){return reinterpret_cast<T*>(data) + i;}
		inline const T* t_data(size_t i)const{return reinterpret_cast<const T*>(data) + i;}
		
	public:
		inline size_t size()const{return pos;}
		inline constexpr size_t max_size()const{return N;}
		inline bool empty()const{return (pos == 0);}
		inline bool full()const{return (pos == N);}
		
		stack():pos(0){}
		
		~stack(){
			if(!std::is_trivial<T>::value)	//ak nemas c++11 tak tuto podmienku odstran
				for(size_t i = pos; i > 0; --i)
					t_data(i-1)->~T();
		}
		
		void clear(){
			this->~stack();
			pos = 0;
		}
			
		template <class U>
		void push(const U& u){
			if(full())throw std::out_of_range("stack is full");
			new(t_data(pos)) T(u);
			++pos;
		}
		
		void push(T&& t){	//ak nmas c++11 tak tuto metodu odstran
			if(full())throw std::out_of_range("stack is full");
			new(t_data(pos)) T(std::move(t));
			++pos;
		}
		
		template <class... Args>
		void emplace(Args... args){	//ak nmas c++11 tak tuto metodu odstran
			if(full())throw std::out_of_range("stack is full");
			new(t_data(pos)) T(args...);
			++pos;
		}
		
		void pop(){
			if(empty())throw std::out_of_range("stack is empty");
			--pos;
			t_data(pos)->~T();
		}
		
		const T& top()const{
                       if(empty())throw std::out_of_range("stack is empty");			
                       return *t_data(pos-1);
		}

                T& top(){
                        if(empty())throw std::out_of_range("stack is empty");
                        return *t_data(pos-1);                }	
};
C / C++ › Zásobník a pole
7. 4. 2013   #174598

#4 Luckin
Hlavna nevyhoda tvojho stacku je to, ze aj ked v nom nic nie je tak sa vola 'n' krat konstruktor/destructor. Dalsia nevyhoda je ze ak chces do toho stacku vlozit objkt tak musi mat pretazeny operator=. Dalsia nevyhoda je ze v Pop a Push sa vytvaraju zbitocne kopie objektov...

C / C++ › Zásobník a pole
7. 4. 2013   #174595

Zasobnik(stack) moze byt implementovany roznymi sposobmi. Stack nie je ani tak datova struktura ako skor sposob ako sa do takej struktury ukladaju data. Implementovany moze byt pomocou ronych linearnych datovych struktur ako pole, dynamicke pole(vector), rada, zretazeny zoznam(list)...

Viac mas toho tu: http://cs.wikipedia.org/wiki/Z%C3%A1sobn%C3%ADk_(datov%C3%A1_struktura)

Riesenie od Luckin-a je viac menej funkcne ale je nevhodne na ukladanie zlozitejsich typov .

C / C++ › operator + se 2 argumenty
7. 4. 2013   #174578

operator mozes vytvorit ako frienda alebo ako metodu:

struct Matrix{
	
	Matrix operator+(const Matrix& m)const{
		Matrix temp;
		//temp = (*this + m)
		return temp;
	}
	//alebo:
	friend Matrix operator+(const Matrix& a, const Matrix& b){
		Matrix temp;
		//temp = (a + b)
		return temp;
	}
};

Doporucujem ti spravyt aj move constructor (ak mas c++11) alebo mieso operatora+ pretazit operator+= 

C / C++ › Statický zásobník pomocí třídy
6. 4. 2013   #174534

#4 Michal
stdexcept je tam len kvoly vynimke std::logic_error.

Ak sa ti nechce implementovat vlastny stack, tak mozs pouzit adapter std::stack.

#include <stack>
#include <iostream>

int main(){
    std::stack<int> stack;	//alebo std::stack<int, std::vector<int>> stack;

    stack.push(1);
    stack.push(2);
    stack.pop();
    stack.push(3);

    std::cout << stack.top();
}

Ja som si uz raz implementoval stack ktory pouziva polia, kludne ho mozes pouzit ak chces:

#include <iostream>
#include <algorithm>
#include <initializer_list>
#include <type_traits>


template <class T, size_t N>
class stack final{
	template <typename, size_t>
	friend class stack;
	
	public:
		typedef T value_type;
		typedef T& reference;
		typedef const value_type& const_reference;
		typedef T* pointer;
		typedef const T* const_pointer;
		
	private:
		char data[sizeof(value_type)*N];
		size_t pos;
		
		inline pointer t_data(size_t i){return reinterpret_cast<pointer>(data) + i;}
		inline const_pointer t_data(size_t i)const{return reinterpret_cast<const_pointer>(data) + i;}
		
	public:
		stack():pos(0){}
		
		stack(size_t n){
			pos = std::min(N, n);
			for(size_t i = 0; i < pos; ++i)
				new(t_data(i)) value_type();
		}
		
		stack(size_t n, const_reference t){
			pos = std::min(N, n);
			for(size_t i = 0; i < pos; ++i)
				new(t_data(i)) value_type(t);
		}
		
		template <class U, size_t M>
		stack(const stack<U, M>& s){
			pos = std::min(N, s.pos);
			for(size_t i = 0; i < pos; ++i)
				new(t_data(i)) value_type(*s.t_data(i));
		}
		
		template <class U, size_t M>
		stack(stack<U, M>&& s){
			pos = std::min(N, s.pos);
			for(size_t i = 0; i < pos; ++i)
				new(t_data(i)) value_type(std::move(*s.t_data(i)));
		}
		
		template <class I>
		stack(I beg, I end){
			for(pos = 0; (beg != end) && (pos < N); ++beg, ++pos)
				new(t_data(pos)) value_type(*beg);
		}
		
		stack(std::initializer_list<T>&& inic_list){
			auto beg = std::begin(inic_list);
			auto end = std::end(inic_list);
			for(pos = 0; (beg != end) && (pos < N); ++beg, ++pos)
				new(t_data(pos)) value_type(std::move(*beg));
		}

		~stack(){
			if(!std::is_trivial<value_type>::value)
				for(size_t i = pos; i > 0; --i)
					t_data(i-1)->~value_type();
		}
		
		void clear(){
			if(!std::is_trivial<value_type>::value)
				for(; pos > 0; --pos)
					t_data(pos-1)->~value_type();
			pos = 0;
		}
			
		size_t size()const{return pos;}
		constexpr size_t max_size()const{return N;}
		bool empty()const{return (pos == 0);}
		bool full()const{return (pos == N);}
		
		template <class U>
		void push(const U& u){
			new(t_data(pos)) value_type(u);
			++pos;
		}
		
		template <class U>
		void push(U&& u){
			new(t_data(pos)) value_type(std::move(u));
			++pos;
		}
		
		template <class... Args>
		void emplace(Args... args){
			new(t_data(pos)) value_type(args...);
			++pos;
		}
		
		void pop(){
			--pos;
			t_data(pos)->~value_type();
		}
		
		const_reference top(){
			return *t_data(pos-1);
		}	
};
C / C++ › Statický zásobník pomocí třídy
6. 4. 2013   #174513

Ten tvoj zasobnik by mohol vyzerat takto:

#include <stdexcept>
template <class T, size_t N>
class Stack
{
        private:
                T data[N];
                size_t pointer;
 
        public:
                Stack():pointer(0){}
                bool IsEmpty(){return (pointer == 0);}
                bool IsFull(){return (pointer == N);};
                void Push(const T& t){
			if(IsFull())throw std::logic_error("Zasobnik je plny!");
					
			data[pointer++] = t;	
		}
                T Pop(){
			if(IsEmpty())throw std::logic_error("Zasobnik je prazdny!");
					
			return data[--pointer];
		}
 
};
int main(void)
{
	Televize t1;
	Televize t2;
	Televize t3;
	Stack<Televize, 3> s1;
	s1.Push(t1);
	s1.Push(t2);
	s1.Pop();
	s1.Push(t2);

	return 0;
}
C / C++ › Win32, malloc 10GB v 64bitov…
6. 4. 2013   #174512

#1 Štěpán
32bit proces pouziva 32bit pointre ktore nedokazu adresovat 10GB priestor. Mozes aplikaciu rozdelit do viacerych procesov.

C / C++ › Getchar vs Gets
3. 4. 2013   #174401

mozes pouzit fflush(stdin) na vycistenie streamu. Vecsinou to funguje, ale nie je to zarucene. 

Pripadne si mozes spravyt vlastnu funkciu:

void fclear(FILE* f){
	int i;
	while( (i = fgetc(f)), (!feof(f) && !ferror(f) && i != '\n'));	//netestoval som to}

//....

fclear(stdin);
C / C++ › Getchar vs Gets
3. 4. 2013   #174398

#1 labuzník
getchar() nacita zo vstupneho streamu 1 znak. Ak zadas znak(y) a potom stlacis enter( '\n' ) tak ten enter sa nacita az v gets().

C / C++ › spojeni řetězce, který je ná…
3. 4. 2013   #174391

#1 labuzník
Toto nie je mozne v c++.

C / C++ › Ruleta
1. 4. 2013   #174216

#3 MiCizek
Tym som ti len chcel povedat ze staci ked napises toto:

2 && 4 && 6;

//je to iste ako:
((2 && 4) && 6);

//je to iste ako:
(1 && 6);

//je to iste ako:
1;
C / C++ › Jaký je nejvhodnější způsob…
31. 3. 2013   #174194

   

uint32_t	integer;
char*		c = (char*)&integer;

c[0];
c[1];
c[2];
c[3];
C / C++ › Ruleta
31. 3. 2013   #174183

   

const int cervena=1 && 3 && 5;	//cervena == 1
const int cerna=2 && 4 && 6;	//cerna == 1

//....

const int cervena=  ((1 && 3) && 5);
const int cerna= ((2 && 4) && 6);

Ps, netusim ako funguje ruleta   

C / C++ › static_cast
31. 3. 2013   #174182

#3 Martin Kozibrátka
V tom linku od crazy-ho to mas pekne vysvetlene, ale skratene:

  1. const_cast sluzi na odstranenie konstantnosti objektu.
  2. static_cast sluzi na pouzitie znamej konverzie (cize integer -> real a opacne, pripadne zavolanie uzivatelom definovanu funkciu na pretypovanie, akonahle sa pretypovavaju pointre tak kompilator kontroluje ci to dava "zmysel", cize napr pretypovanie nadradenej triedy na jej potomka, pripadne na void* ...)
  3. reinterpret_cast sluzi na pretypovanie pointrov bez kontroly typov, cize kludne mozes pretypovat int* na double*, pripadne mozes pretypovat integer na adresu MojaTriea*
  4. dynamic_cast je najzlozitejsi(a najpomalsi), vyuziva na pretypovanie RTTI. Je mozne pretypovat bazovu triedu na triedu ktora ju dedi. Caste pouzivanie dynamic_cast-u vecsinou znamena ze mas zly navrh programu

C pretpovanie kombinuje prve 3 pretypovania.

C / C++ › Pole pointerů na struktury
30. 3. 2013   #174118

Mozes si spravyt upravene binarne vyhladavanie ktore bude hladat adresu/index najvecsieho prvka pola ktory je mensi ako prvok ktory chces do pola vlozit. Potom vsetky prvky ktore su napravo od najdeneho prvka posunies (napr pomocou memcpy, ak treba tak zvecsis pole). Potom vlozis na uvolnenu poziciu novy prvok.

Dalej ma napada ze mozes prvky vkladat na koniec pola, a pred vyhladavanim spustis daky sort(napr quick sort, marge sort) ktory usporiada pole (v dakej premennej si uchovavaj stav pola: zotridene/nezotriedene).

Dalej mozes miesto pola pouzit binarny strom (nieco na sposob std::set, std::map).

//.....

Vo vsetkych pripadoch mozes urychlit porovnavanie prvkov tym ze budes porovnavat hashe prvkov (na sposob std::unordered_map)

C / C++ › Pole pointerů na struktury
29. 3. 2013   #174116

V akom pomere (priblizne) mas oparecie vkladania prvka do pola a vyhladavanie prvka?

Budes prvky z pola mazat?

Idealne by bolo kebyze pole najprv naplnis a potom budes v nom len vyhldavat.

C / C++ › Program spadne, když se volá…
29. 3. 2013   #174112

#3 MiCizek
Neboj sa, casom ta to prejde :)

C / C++ › Program spadne, když se volá…
29. 3. 2013   #174109

Normalne som sa zlakol ked som zbadal ten kod   

Preco skoro vsade pouzivas dynamicku alokaciu premennych? Dokonca aj pomocnych intov...

signed short int = short

typedef unsigned short int ushort; //nech je to prehladnejsie
C / C++ › pointer ze struktury na stru…
29. 3. 2013   #174053

#6 Dejv

Zoraduj len pointre v poliach list_F a list_V.

C / C++ › Pole pointerů na struktury
29. 3. 2013   #174051

std::string je vlastne pointer ktory ukazuje na dynamicky alokovane pole charov (pripadne aj dalsie data). To znamena ze velkost stringuje je na 64bit systeme vecsinou 8B. Struktura S ma len 2 stringy, takze samotna struktura zabera len 16B co je strasne malo. Takze kludne mozes pouzit pole v ktorom budu priamo ulozene data, nemusis dynamicky alokovat kazdy prvok (co je o dost pomalsie ako alokovanie jedneho bloku naraz). V pripade stringu mozes na kopirovanie pouzit std::memcpy co sposobi ze sa nebude volat zbytocne kopirovaci/presuvaci konstruktor (std::vektor funguje podobne). 

Uchovavanie v poli pointre na prvky miesto samotnych prvkov ma dalsiu nevyhodu. Kedze su jednotlive prvky alkovane dynamicky tak su rostrusene po heape. To sposoby ze program nemoze natiahnut cely blok dat do cache pamete a kvoly kazdemu jednemu prvku ho musi nacitavat z ram, cize dalsie spomalenie. 

Tvoje riesenie ma jednu vyhodu. Ak realokujes pole, tak adresa prvku ostane rovnaka, takze mozes vytvarat pointre na prvky a po realokovani pola su pointre stale OK co pri std::vectore neplati (vecsinov tato vlastnost nie je potrebna)

Takze aj ked si myslis ze pole pointrov na data bude efektivnejsie ako pole dat, tak to bude skor opacne  (Samozrejme implementacia dynamcikeho pola tak aby sa zbytocne nevolali konstruktory nie je uplne trivialna)

----------------------------------

Tvoje riesenie je ok, a tam kde si napisal ze mas memory lake ho naozaj mas, riesenie je jednoduche:

size_t pocetPrvkov = N;	//pocet prvkov v poly
size_t povodnaVelkost = N;	//velkost pola
size_t zvetsenaVelikost = N + X;	//velkost zvecseneho pola, je dobre ak X > 1 neh sa nemusi casto realokovat
S** polePointeru;	

S ** tmp = new S*[zvetsenaVelikost];  // nove vetsie pole
std::memcpy(tmp, polePointeru, sizeof(S*)*povodnaVelkost);	//skopyruje pointre, netreba znovu alokovat kazdy prvok

delete [] polePointeru;	//zmaze povodne pole

polePointeru = tmp; 
//--------------------------------------------------------------
//pridanie prvku do pola:

polePointeru[pocetPrvkov] = new S;
++pocetPrvkov;
C / C++ › Numerická integrácia, jazyk C
28. 3. 2013   #174044

Skus si to skompilovat pomocou c++ kompilatoru, vypise ti mnozstvo chyb a warningov ktore ti pomozu:

error: cannot initialize a parameter of type 'double (*)()' with an lvalue of type 'rfunc' (aka 'double (*)(double)')
         ic = (*f[i])(ivals[2*j], ivals[2*j], approx[j], rf[j]);
                                                         ^~~~~
untitled.cpp:52:18: error: too many arguments to function call, expected 0, have 1
     sum += func(x+h);
            ~~~~ ^~~
untitled.cpp:61:18: error: too many arguments to function call, expected 0, have 1
     sum += func((x+h)/2.0);
            ~~~~ ^~~~~~~~~
C / C++ › pointer ze struktury na stru…
28. 3. 2013   #174042

#3 Dejv
Tak si vektor implmentuj sam, ak ste este nepreberali dynamicku alokaciu pamete tak mozes pouzit len polia:

  

const unsigned MAX = 100;

Firma vsetky_firmy[MAX];
unsigned pocet_firiem = 0;
Vlastnik vsetci_vlastnici[MAX];
unsigned pocet_vlastnikov = 0;
    struct Firmy;

    struct Vlastnici
    {
        string  name1;
        string  adr1;
       	Firmy* list_F[MAX];
	unsignd pocet_firiem = 0;
    };
    struct Firmy
    {
        string  name2;
        string  adr2;
	Vlastnici* list_V[MAX];
	unsignd pocet_vlastnikov = 0;
    };
C / C++ › pointer ze struktury na stru…
28. 3. 2013   #174040

#1 David
Jedna z moznosti je mat centralny zoznam vsetkych firiem a vlastnikov. Napr:

std::list<Firma> vsetky_firmy;
std::list<Vlastnik> vsetci_vlastnici;

Kazda firma bude potom obsahovat pointre na Vlastnikv a Vlastnici zas pointre na Firmy. V podstate to mas dobre, len misto pola by som pouzil vektor nech nemusis rucne alokovat/dealokovat pamet:

    struct Firmy;

    struct Vlastnici
    {
        string  name1;
        string  adr1;
        std::vector<Firmy*> list_F;
    };
    struct Firmy
    {
        string  name2;
        string  adr2;
	std::vector<Vlastnici*> list_V;
    };
C / C++ › Implementacia AST
27. 3. 2013   #173960

Akym sposobom najlepsie reprezentovat uzly v AST?

Momentalne pouzivam nieco taketo:

class Root;
class Node{
	public:
		enum TypeId{/*...*/};	//Dvolezite na implementaciu rychleho dynamic_castu (na sposob llvm::isa a llvm::dyn_cast)
	private:
		const TypeId TyId;

	private:
		Node*	parent;		
		Node*	prev_sibling;	
		Node*	next_sibling;	
		Node*	first_child;	
		Node*	last_child;	
	public:
		Root&	root;	//koren stromu obsahuje rozne globalne data (globalne z hladiska mojho jazyka, nie c++)
		/*
		 ...
		 */
};
class Root : public Node{/*...*/};
//...

Takychto nodov mam v strome stovky/tisice a kazdy uzol zabera minimalne 64B co sa my zda strasne vela. Je daka uspornejsia forma ako reprezentovat uzly stromu?

C / C++ › c++ vector odstranění prvníh…
23. 3. 2013   #173193

#5 crazy
queue je len adaptor, cize moze ppouzit queue a vector sucasne  :

std::queue<int, std::vector<int>> q;
C / C++ › c++ vector odstranění prvníh…
23. 3. 2013   #173190

#3 Petr
V tom linku co je vyzsie mas napisane co vracia.

C / C++ › c++ vector odstranění prvníh…
23. 3. 2013   #173187

Odstranovanie ineho ako posledneho prvka moze byt dost pomale, ale je to mozne. Sluzi na to funkcia erase:

std::vector<int> vec{1, 2, 3, 4};

vec.erase(vec.begin());

C / C++ › Seřazování databází a zapiso…
23. 3. 2013   #173186

Pouzivas memcpy() na triedu s netrivialnym konstruktorom/destructorom. std::string v destruktore uvolnuje pamet, akonahle vytvoris jeho bitovu kopiu pomocou memcpy(), tak budes mat 2 stringy ktore ukazuju do tej istej pamete, takze sa ti uvolni 2x a to je chyba. 

Riesis to strasne zlozito, jednoduhsie by to vyzeralo nasledovne:

#include <iostream>
#include <string>
#include <sstream>
#include <fstream>
#include <map>
#include <iterator>
#include <algorithm>
using namespace std;

struct data_t{
	long a = 0;
	long b = 0;
};

typedef std::map<std::string, data_t> db_t;

struct line_t{
	std::string name;
	long num;
	
	friend std::istream& operator>>(std::istream& in, line_t& line){
		std::string tmp;
		std::getline(in, tmp);
		//tu by sa hodilo kontrolovat spravnost retazca:
		std::stringstream ss(tmp);
		ss >> line.name >> line.num;
		return in;
	}
};

int main (){
	db_t db;
	
	std::ifstream a("a.txt");
	for(std::istream_iterator<line_t> i(a); i != std::istream_iterator<line_t>(); ++i){
		db[i->name].a = i->num;
	}
	
	std::ifstream b("b.txt");
	for(std::istream_iterator<line_t> i(b); i != std::istream_iterator<line_t>(); ++i){
		db[i->name].b = i->num;
	}

	for(db_t::iterator i = db.begin(); i != db.end(); ++i){
		std::cout << i->first << " " << i->second.a << " " << i->second.b << "\n";
	}

    
   return EXIT_SUCCESS;
}
C / C++ › Problém s předáním stringove…
20. 3. 2013   #173075

#4 Martin Kozibrátka
z c++11 tam je len 'constexpr', bez toho to funguje aj v c++03.

Preco si pouzil double miesto template parametra a preco double vracias?

C / C++ › Problém s předáním stringove…
20. 3. 2013   #173067

Na zistenie dlzky pola sa da pouzit nieco taketo:

template <class T, size_t N>
constexpr size_t len_of(const T (&) [N]){return N;}
C / C++ › Cannot open include file: 'a…
19. 3. 2013   #173012

Visual studio express neobsahuje MFC a ATL kniznice. Takze bud si zozen VS profesional alebo nepouzivaj MFC.

C / C++ › Cannot open include file: 'a…
19. 3. 2013   #173010

#3 Peter
Ja som nasiel toto:

VC++ Express doesn't come with MFC or ATL. You'll need to get at least VC++ 2010 Professional.

C / C++ › Dynamický zásobník C++
19. 3. 2013   #173001

 #7 Ilhvm

//subor.hpp	
class C{
	/*
	Tu musia byt vsetky atributy(premenne) a deklaracie metod
	*/

	int i;
	float f;
	double d;
	//...
	
public:		
	C();
	int metoda(int, float);
	void metoda2();
	
	//...
};
//-----------------------------------------------------------------
//subor.cpp	

#include "subor.hpp"

/*
tu nedefinujes ziadne atributy, len metody (pripadne staticke premenne)
*/

C::C(){
	//...
}
int C::metoda(int x, float y){
	//...
}
void C::metoda2(){
	//...
}

	
C / C++ › Nacitanie ciest suborov a pr…
16. 3. 2013   #172903

#1 Tingf11
Mozes pouzit boost filesystem. Ak pouzivas VS2012 tak tam mozes pouzit: ms filesystem. Tieto kniznice su velmi podobne a zrejme budu standardizovane v nasledujucej verzi c++.

C / C++ › Chybové hlášky skrz scanf
16. 3. 2013   #172869

#1 labuzník
 

%Lf  - long double
%lf  - double
%f   - float
%s   - char*     //string ukonceny s '\0'
%c   - char
C / C++ › Špirála čísel v C
14. 3. 2013   #172824

Skus daco taketo, len to musis upravyt tak aby to vypisovalo cisla a nie hviezdicky (zaporne a viac ciferne) a zrejme nebude dobre zacinat priamo od stredu (tam su moc natlacene na sebe), ale to sa da upravyt zmenou konstant vo funkcii fnc().

#include <stdio.h>
#include <math.h>
#include <stdlib.h>


#define MAX_X 30
#define MAX_Y 60


struct point{
	size_t x;
	size_t y;
};

// "rovnica spiraly", cim vecsie cislo, tym dalej od stredu:
point fnc(int n){
	double abs_n = abs(n);
	point p;
	
	//polomer:
	double rx =  ((double)MAX_X) * abs_n/80.;	
	double ry =  ((double)MAX_Y) * abs_n/80.;	
	
	//suradnice:
	p.x = lround(((double)MAX_X)/2. + rx*cos((0.3 * abs_n))); 
	p.y = lround(((double)MAX_Y)/2. + ry*sin((0.3 * abs_n)));
	
	return p;
}

int main(){
	char matrix[MAX_X][MAX_Y];
	
	//vynulovanie matice:
	for(size_t a = 0; a < MAX_X; ++a)
		for(size_t b = 0; b < MAX_Y; ++b)
			matrix[a][b] = ' ';

	//vytvorenie spirali do matice:
	for(int i = 0; i < 50; ++i){
		point p = fnc(i);	//nacita suradnice bodu pre cislo i
		if(p.x < MAX_X && p.y < MAX_Y)	//nesmie byt mimo matice
			matrix[p.x][p.y] = '*';
	}
		
	//vypis matice:
	for(size_t a = 0; a < MAX_X; ++a){
		for(size_t b = 0; b < MAX_Y; ++b){
			printf("%c", matrix[a][b]);
		}
		printf("\n");
	}
}
C / C++ › Objekt parametrem metody
13. 3. 2013   #172770

#22 marpit
 

template <class T> struct List1
{
private:
	struct item
	{
		T value;
		item *next;
		
		item(const T& v):
			value(v), 	//typ T musi mat kopirovaci konstruktor
			next(nullptr){}	
	};

	item *current = nullptr;	//atributy sa daju inicializovat aj takto
	item *head = nullptr;

public:
	List1();
	~List1();

	void insert(const T&);	//referencia
	const T& get();			//referencia
	void erase(const T);	//toto sa riesi inak (vecsinou cez iteratori ktore nemas implementovane)
	//...
};

template <class T> 
void List1<T>::insert(const T& value){
	item *newItem = new item(value);	//tu sa vyuzie ten novy konstruktor z item
	newItem->next = head;
	head = newItem;
}

//---------------------------------------------------
template <class T> struct Stack1{
private:
	T *arr;
	/*
	 * velkost bude zrejme nezaporna, cize radsej pouzi 'unsigned' alebo 'size_t' co je vecsinou 'unsigned long'
	 * nemusis potom kontrolovat ci uzivatel nezadal zaporne cislo
	 */
	size_t size;	
	size_t index;
	size_t sp;

public:
	Stack1(size_t, size_t);
	~Stack1();

	//provizorně

	Stack1(const Stack1 &s):
	//lepsi sposob inicializacie (aj ked pri integeroch je to jedno):
	sp(s.sp), 
	size(s.size), 
	index(s.index){	
		/*
		this->sp = s.sp;
		this->size = s.size;
		this->index = index;
		*/

		//this->arr = s.arr;		//toto nestaci, ty musis spravyt hlbkovu kopiu
		
		this->arr = new T[size];
		/*
		 * 
		 * treba prekopyrovat vsetky prvky z pola 's.arr' do 'arr'
		 */
		for(size_t i = 0; i < size; ++i){
			/*
			 * T musi mat operator=, ak by si to chcel bez neho tak musis pouzit placement new alebo malloc 
			 *   a volat konstruktory a destruktory rucne
			 */
			arr[i] = s.arr[i];			
		 }
	}
	
	

	//...
};
C / C++ › Objekt parametrem metody
13. 3. 2013   #172757

#15 marpit
Postnie sem cely kod, povieme ti kde mas chybu

C / C++ › Objekt parametrem metody
13. 3. 2013   #172748

#10 marpit
Tak nez sa to naucis, tak mozes pouzit std::list:

#include <list>

struct X{
	X(int, long, double){}
	X(const X& x){}
};

int main(){
	std::list<X> list;

	list.push_back(X(1, 2, 3.3));
	list.push_back(X(4, 5, 6.3));
	list.push_back(X(7, 8, 9.3)); 
	list.emplace_back(10, 11, 12.0);	//treba c++11


}
C / C++ › Objekt parametrem metody
13. 3. 2013   #172745

#8 marpit
Riesit sa to da takto:


template<class T>
class List{
		struct Item{
			T data;
			
			Item(const T& data):data(data){}
		
			template <class... P>	
			Item(P... p):data(p...){}	//<-- treba c++11
		};
	
	public:
		void insert(const T& data){
			Item* item = new Item(data);
			
			//...
		}
		
		template <class... P>
		void insert_new(P... p){		//<-- treba c++11
			Item* item = new Item(p...);
			
		}
	//...
	
};

struct X{
	X(int, long, double){}
	X(const X& x){}
};
int main(){
	X x(1, 2, 3.14);
	List<X> list;
	
	list.insert(x);	//zavola sa kopirovaci konstruktor
	
	list.insert_new(4, 5, 6.28);	//zavola sa konstruktor s 3 parametrami  (treba c++11)
	
}
C / C++ › Objekt parametrem metody
13. 3. 2013   #172740

#3 marpit
Aby sa nevytvarala kopia.

C / C++ › Objekt parametrem metody
13. 3. 2013   #172738

#2
Ten zasobnik tam musis prekopirovat, cize potrebujes kopirovaci konstruktor a funkcia insert bude prebereat referenciu:

template <class T> 
void List1<T>::insert(const T& value)	// <-- referencia
{
	item *newItem = new item;

	newItem->value = value;		// <- tu sa zavola kopirovaci konstruktor
       //edit: nezavola, zavola sa operator=, moja chyba
	newItem->next = head;
	head = newItem;
}

struct X{
	X(const X& x){	//kopirovaci konstruktor
		//...
	}
	
};

Ak chces do listu vlozit novy prvok bez volania kopirovacieho konstruktoru tak budes musiet pouzit Variadic templates z c++11:

template <class T>
template <class... Params> 
void List1<T>::insert_new(Params... params){
	item *newItem = new item(params...);	// treba prerobit aj triedu item 
	//...
}

alebo pouzit std::list  :)

C / C++ › silné a slabé reference
9. 3. 2013   #172522

Toto zrejme patri do .Net/Javy. Silna referencie je pointer ktory obsahuje reference counter, akonahle je pocet referencii na dany objekt 0 tak ho GC zmaze. Slaba referencia neinkrementuje reference counter, ale ked chces pristupovat k objektu tak ho docasne inkrementuje(vytvori silnu referenciu). Ak slaba referencia ukazuje na objekt ktory uz bol zmazany referencia vrati null. Slabe referencie sa pouzivaju pri cyklickych referenciach. Napr objekt A obsahuje referenciu na objekt B a objekt B obsahuje referenciu na A. Zaroven vsak ziadna referencia (mimo objekty A a B) neukazuje na objekt A a B, cize GC by ich mal zmazat. Ak by boly pouzite 2 silne referencie, tak by referencia v A aj referencia B mala counter nastaveny na hodnotu 1, tym padom by ich GC nezmazal. Ak bude aspon jedna z tych refereni slaba, tak GC moze mazat.

V c++ sa na to pouziva std::shared_ptr a std::weak_ptr.

C / C++ › C - funkce s proměnlivým poč…
9. 3. 2013   #172519

#3 DeaconCZ
Mne to funuje, na akom systeme to prekladas?

C / C++ › C - funkce s proměnlivým poč…
9. 3. 2013   #172517

Co ti na tom nefunguje?

C / C++ › Implementace operator[][]
9. 3. 2013   #172514

#3 cibule



class A{
	struct B{
		double operator[](int){return 3.14;}
	};
        B b;
    public:
	B& operator[](int){return b;}

};

int main(){
	A a;

	double d = a[2][3];

}
C / C++ › statická inicializace třídy…
2. 3. 2013   #172264
C / C++ › čtení z internetových stránek
26. 2. 2013   #172124
C / C++ › čtení z internetových stránek
26. 2. 2013   #172122

#6 petr143
Ved crazy ti poradil...

C / C++ › otevření souboru
23. 2. 2013   #171851

funkcia fopen vrati pointer na subor a tento pointer sa porovna s NULL. Vysledok tohto porovnania ( 0 alebo 1) sa zapise do f_in. Kedze f_in je pointer a nie integer tak ti to vyhodi warining.

spravne by to malo byt takto: 

if( (f_in = fopen("/home/honza/input_file.txt", "r")) == NULL)//...
C / C++ › hledání nejvyšší
23. 2. 2013   #171836

   


/*
 * Najde maximum v neprazdnom poly
 * Velkost pola musy byt znama pri preklade
 * Vracia referenciu na maximum
 */
template <typename T, size_t S>
T& max_element(T (&pole)[S]){
	static_assert(S>0, "chyba: pole ma 0 velkost");
	//....
}


/*
 * Najde maximum v neprazdnom poly
 * Velkost pola nemusy byt znama pri preklade
 * Vracia referenciu na maximum
 */
template <typename T>
T& max_element(T* pole, size_t s){
	assert(s>0 && "chyba: pole ma 0 velkost");
	//....
}

/*
 * Najde maximum z intervalu <begin, end)	//end sa nebere ako prvok pola
 * Velkost pola nemusi byt znama pri preklade a pole moze byt prazdne. 
 * Kedze su ako parameter pointre na prvky pola, tak sa da velkost vypocitat ako ((end-begin)/sizeof(T)))
 * Vracia pointer na maximum, ak sa nenajde maximum(pole je prazdne) tak vrati end
 */
template <typename T>
T* max_element(T* begin, T* end){
	//....
}


/*
 * Skoro to iste ako 3. priklad, ale pracuje pre vecsinu kontainerov.
 * Kludne to moze byt list(zretzeny zoznam), mapa, stack, ...
 */
template <typename Iterator>
Iterator max_element(Iterator begin, Iterator end){
	//....
}
C / C++ › hledání nejvyšší
22. 2. 2013   #171826

   

int pole[20];
//...
std::cout << "max: " << *std::max_element(pole, pole+20);
//alebo://...
std::cout << "max: " << *std::max_element(std::begin(pole), std::end(pole));

Na tej stanke mas priklad ako moze vyzerat ta implementacia. Tu mas trochu upavenu verziu:

template<class T>
T* max_element(T* first, T* last)
{
    if (first == last) {
        return last;
    }
    T* largest = first;
    ++first;
    for (; first != last; ++first) {
        if (*largest < *first) {
            largest = first;
        }
    }
    return largest;
}
C / C++ › hledání nejvyšší
22. 2. 2013   #171824
C / C++ › funkce vracející pointer na…
21. 2. 2013   #171771

pole == pointer;   //su tam dake rozdieli, ale pre tvoj pripad to vyzera takto:

int pole[8];
int* pointer;

pointer = pole;	//pointer ukazuje na 1. prvok pola 'pole'

return pointer;	//vratis pointer

Problem je ale inde, ty vracias pointer(pole je tiez pointer) na lokalnu premennu. Po opusteni funckie sa zmaze pole a vrat sa  pointer na prvy prvok pola (samozrejme ten prvok tam uz oficialne nie je    )

C / C++ › Nefunguje přetypování (Qt)
21. 2. 2013   #171766

spravnejsie by si si mal spravyt vlastny iterator, hlavne do buducna ak zmenis mapu za nieco ine tak sa to neotkne zvysku kodu:

#include <QCoreApplication>
#include <QSharedPointer>
#include <QMap>
#include <QDebug>

class IUser
{
public:
    virtual void show() = 0;
};

class User : public IUser
{
public:
    User()         {}
    void show()    {}
    void destroy() {}
};

class MainClass
{
public:
    MainClass()
    {
        m_users["a"] = QSharedPointer<User>(new User);
        m_users["b"] = QSharedPointer<User>(new User);
    }
    class iterator :  public std::iterator<std::input_iterator_tag, User>{
        typedef QMap<QString, QSharedPointer<User> >::const_iterator map_iter_type;
        map_iter_type it;
    public:
        iterator(map_iter_type it):it(it){}
        iterator(const iterator&)=default;

        User* operator->(){return it->data();}
        User& operator*(){return *it->data();}

        bool operator==(const iterator& i)const{return it == i.it;}
        bool operator!=(const iterator& i)const{return it != i.it;}
        void operator++(){++it;}
        void operator++(int){it++;}
        void operator--(){--it;}
        void operator--(int){it--;}

    };
    inline iterator begin(){return iterator(m_users.begin());}
    inline iterator end(){return iterator(m_users.end());}

private:
    QMap<QString, QSharedPointer<User> > m_users;
};


int main()
{
    MainClass mc;
    //v c++11:   for(auto& u : mc)u.show();
    for(MainClass::iterator i = mc.begin(); i != mc.end(); ++i){
       i->show();
    }
    return EXIT_SUCCESS;
}
C / C++ › Nefunguje přetypování (Qt)
21. 2. 2013   #171760

 

 

Hostujeme u Českého hostingu       ISSN 1801-1586       ⇡ Nahoru Webtea.cz logo © 20032018 Programujte.com
Zasadilo a pěstuje Webtea.cz, šéfredaktor Lukáš Churý