C++ naco jsou hlavičkové soubory když budu psát OOP?

[anonym]

Nejsem C++kář a potřebuju si v tom něco napsat OOP.

Naco jsou tam ty hlavičkové souboru *.h a k nim vždycky ještě *.cpp, když to budu psát OOP a už samotná třída definuje svoje rozhraní sama o sobě? Chápu to správně, že hlavičky slouží jen jako interface k binárce? Potom by mi ovšem stačil jen hlavičkový soubor k binárce, nemusím ho dělat ke každé třídě v rámci jedné binárky, ni?

Další věc statická alokace paměti. Veškeré třídy, jejichž instance se nebudou množit za běhu aplikace, můžu alokovat staticky bez operátoru new. Dá se to tak brát? Tzn. řekněme v praxi by mělo být tak cca 90% všech alokací v C++ statických.

Pokud nějakou instanci alokuji dynamicky, ale v rámci té třídy už alokuju staticky, pak předpokládám, že kompilátor není blbý a i ty statické alokace budou na heapu a ne ve stacku. Jako např. budu mít nějaký vector a do toho budu v cyklu přidávat staticky alokované instance, tak potom tyto instance budou ve výsledku alokovány na heapu, je to tak? Doufám že jo.

Díky.

[Reklama]

[Kit]

Naco jsou tam ty hlavičkové souboru *.h a k nim vždycky ještě *.cpp, když to budu psát OOP a už samotná třída definuje svoje rozhraní sama o sobě? Chápu to správně, že hlavičky slouží jen jako interface k binárce? Potom by mi ovšem stačil jen hlavičkový soubor k binárce, nemusím ho dělat ke každé třídě v rámci jedné binárky, ni?

Ty hlavičkové soubory jsou tam pro programátory, kteří chtějí v C++ psát strukturovaně.

Další věc statická alokace paměti. Veškeré třídy, jejichž instance se nebudou množit za běhu aplikace, můžu alokovat staticky bez operátoru new. Dá se to tak brát? Tzn. řekněme v praxi by mělo být tak cca 90% všech alokací v C++ statických.

Statické třídy jsou vlastně jen náhradou za namespace u strukturovaného programování. V OOP je dobré se jim vyhnout.

Další věc statická alokace paměti. Veškeré třídy, jejichž instance se nebudou množit za běhu aplikace, můžu alokovat staticky bez operátoru new. Dá se to tak brát? Tzn. řekněme v praxi by mělo být tak cca 90% všech alokací v C++ statických.

Pokud nějakou instanci alokuji dynamicky, ale v rámci té třídy už alokuju staticky, pak předpokládám, že kompilátor není blbý a i ty statické alokace budou na heapu a ne ve stacku. Jako např. budu mít nějaký vector a do toho budu v cyklu přidávat staticky alokované instance, tak potom tyto instance budou ve výsledku alokovány na heapu, je to tak? Doufám že jo.

Dynamická alokace je na heapu, statická je vlastně jen náhradou globálních proměnných a proto se dělá už v době kompilace.

[Honza]

1) Staticky alokované věci nejsou ani stacku, ani na heapu, jsou jinde (společně) - ale statické třídy jsou něco jiného
2) ad. hlavičkové soubory - to, co není nutné, nemusí být zároveň "best-practice"...

[Frajer odvedle]

Ale ja nemluvim o statickych tridach, ale o staticke alokaci, kde misto:

Trida *t = new Trida();

Napises

Trida t();

Pricemz se ptam, co se stane, kdyz udelam:

For(int i = 0; i<10; i++)
 someVector.push_back( Trida() )

[Honza]

deklarace:

Kód: [Vybrat]

Trida t(); // "t" je uloženo na stackuhádám, že pak má být:

Kód: [Vybrat]

someVector.push_back( t ); // udělá se kopie, a ta se uloží do toho vektoru

[Reklama]

[anonym]

deklarace:

Kód: [Vybrat]

Trida t(); // "t" je uloženo na stackuhádám, že pak má být:

Kód: [Vybrat]

someVector.push_back( t ); // udělá se kopie, a ta se uloží do toho vektoru

kopie se asi neudela protoze push_back( Trida &trida)

[Honza]

kopie se asi neudela protoze push_back( Trida &trida)

no ovšem, potom tam tedy je reference na zásobník = špatný nápad

[v]

deklarace:

Kód: [Vybrat]

Trida t(); // "t" je uloženo na stackuhádám, že pak má být:

Kód: [Vybrat]

someVector.push_back( t ); // udělá se kopie, a ta se uloží do toho vektoru

kopie se asi neudela protoze push_back( Trida &trida)

jsem to zkusil a prošlo to (g++)

[v]

kopie se asi neudela protoze push_back( Trida &trida)

špatný nápad

jistě, že není, bude dynamicky alokovat string abyste ho mohl předat << ?

[Honza]

kopie se asi neudela protoze push_back( Trida &trida)

špatný nápad

jistě, že není, bude dynamicky alokovat string abyste ho mohl předat << ?

Rozdíl je v tom, co s tím ten operátor << udělá, když nenechá odkaz na ten string, tak je to v pořádku.

[anonym]

kopie se asi neudela protoze push_back( Trida &trida)

no ovšem, potom tam tedy je reference na zásobník = špatný nápad

cituju cos napsal: "Staticky alokované věci nejsou ani stacku, ani na heapu, jsou jinde (společně) - ale statické třídy jsou něco jiného"

Nechces se radeji zdrzet odpovedi a nechat odpoved nekomu, kdo tomu rozumi?

[Honza]

kopie se asi neudela protoze push_back( Trida &trida)

no ovšem, potom tam tedy je reference na zásobník = špatný nápad

cituju cos napsal: "Staticky alokované věci nejsou ani stacku, ani na heapu, jsou jinde (společně) - ale statické třídy jsou něco jiného"

Nechces se radeji zdrzet odpovedi a nechat odpoved nekomu, kdo tomu rozumi?

A v čempak se pletu?

[anonym]

deklarace:

Kód: [Vybrat]

Trida t(); // "t" je uloženo na stackuhádám, že pak má být:

Kód: [Vybrat]

someVector.push_back( t ); // udělá se kopie, a ta se uloží do toho vektoru

kopie se asi neudela protoze push_back( Trida &trida)

jsem to zkusil a prošlo to (g++)

Jasne ze to proslo, co by to asi jineho melo udelat?

OMG...

[bigben]

Naco jsou tam ty hlavičkové souboru *.h a k nim vždycky ještě *.cpp, když to budu psát OOP a už samotná třída definuje svoje rozhraní sama o sobě? Chápu to správně, že hlavičky slouží jen jako interface k binárce? Potom by mi ovšem stačil jen hlavičkový soubor k binárce, nemusím ho dělat ke každé třídě v rámci jedné binárky, ni?

Ty hlavičkové soubory jsou tam pro programátory, kteří chtějí v C++ psát strukturovaně.

Další věc statická alokace paměti. Veškeré třídy, jejichž instance se nebudou množit za běhu aplikace, můžu alokovat staticky bez operátoru new. Dá se to tak brát? Tzn. řekněme v praxi by mělo být tak cca 90% všech alokací v C++ statických.

Statické třídy jsou vlastně jen náhradou za namespace u strukturovaného programování. V OOP je dobré se jim vyhnout.

Další věc statická alokace paměti. Veškeré třídy, jejichž instance se nebudou množit za běhu aplikace, můžu alokovat staticky bez operátoru new. Dá se to tak brát? Tzn. řekněme v praxi by mělo být tak cca 90% všech alokací v C++ statických.

Pokud nějakou instanci alokuji dynamicky, ale v rámci té třídy už alokuju staticky, pak předpokládám, že kompilátor není blbý a i ty statické alokace budou na heapu a ne ve stacku. Jako např. budu mít nějaký vector a do toho budu v cyklu přidávat staticky alokované instance, tak potom tyto instance budou ve výsledku alokovány na heapu, je to tak? Doufám že jo.

Dynamická alokace je na heapu, statická je vlastně jen náhradou globálních proměnných a proto se dělá už v době kompilace.

Staticke triedy a staticky alokovane objekty su 2 rozdielne veci. Ale verim ze v phpcku a podobných orezaných jazykoch ako java si sa s tym asi nestretol

[whitebull]

OOP se vzdyt dela v Jave. C++ je jen nepovedeny hack. Vzdyt i samotny kernel je psan radeji v cistem C.