Zobrazit předchozí téma :: Zobrazit následující téma |
Autor |
Zpráva |
petr

Založen: 13. 05. 2008 Příspěvky: 19
|
Zaslal: 22. duben 2009, 12:44:57 Předmět: Rovná se nebo závorka |
|
|
Dobrý den,
mám kátký a stručný dotázek - jaký je praktický rozdíl mezi zápisem
int ln_x = 10;
a
int ln_y(10);
kdy je vhodné používat první typ a kdy druhý?
Děkuji za odpověď. |
|
Návrat nahoru |
|
 |
MD

Založen: 29. 07. 2007 Příspěvky: 437 Bydliště: Praha
|
Zaslal: 22. duben 2009, 13:13:50 Předmět: |
|
|
Mam takovy pocit ze zadny, kompilator oboje prelozi stejne a to myslim i v pripade, ze by neslo o int ale o nejakou tridu. (mam na mysli, ze se nevyvola prazdny konstruktor a operator =, ale primo (a jenom) (copy)konstruktor s tim parametrem)
Opravte me zda se pletu. Jak je to v ruznych implementacich a co rika norma nevim. Rad se poucim. _________________ - play with objects - www.krkal.org - |
|
Návrat nahoru |
|
 |
VladR
Založen: 30. 07. 2007 Příspěvky: 1322 Bydliště: Greater New York City Area
|
Zaslal: 22. duben 2009, 13:29:59 Předmět: |
|
|
Pre zabudovane typy je to fuk, ale pri triedach sa pri vyraze CClass C1=C2 zavola najprv Copy Constructor (Shallow Copy ako Default Assignment operator - cize assignment operator per each member).
Je to nieco podobne ako ++i vs i++, kde pre zabudovane typy je vykon identicky, ale pri triedach uz nie. Preto sa doporucuje zvyknut na notaciu ++i cim skor... |
|
Návrat nahoru |
|
 |
VladR
Založen: 30. 07. 2007 Příspěvky: 1322 Bydliště: Greater New York City Area
|
Zaslal: 22. duben 2009, 13:32:12 Předmět: |
|
|
Jo, a samozrejme je notacia var(value) skvela hlavne v tom, ze sa pouziva pri Constructor Initialization List, kde je na nezaplatenie.
Iny priklad pouzitia, ktory by bol tak masivne vyuzivany, ma teraz nenapada. |
|
Návrat nahoru |
|
 |
OndraSej

Založen: 28. 07. 2007 Příspěvky: 767 Bydliště: Brandýs nad Labem
|
Zaslal: 22. duben 2009, 13:46:18 Předmět: |
|
|
VladR - pro zabudovane typu u i++/++i vykon rozhodne identicky neni, lisi se v navratove hodnote, coz muze hrat roli.
Jinak asi bych doporucoval pouzivat zapis s rovnitkem, prijde mi prehlednejsi. _________________ http://trionteam.net |
|
Návrat nahoru |
|
 |
Quiark

Založen: 29. 07. 2007 Příspěvky: 816 Bydliště: Chlívek 401
|
Zaslal: 22. duben 2009, 13:58:51 Předmět: |
|
|
Já jsem spíš pro ten se závorkou, protože zápis s rovnítkem je u tříd opravdu zbytečné plýtvání výkonem (nehledě na to, že musí mít člověk korektně napsaný operator =). _________________ Mám strach |
|
Návrat nahoru |
|
 |
petr

Založen: 13. 05. 2008 Příspěvky: 19
|
Zaslal: 22. duben 2009, 14:00:14 Předmět: |
|
|
VladR: myslíš konstruktory - třeba takhle - viz public: ?
kód: |
class CPlayers
{
public:
CPlayers():mn_pocet(0){};
void add_player(CMoveEntity *m);
void get_player(char *name, CMoveEntity *p);
private:
CMoveEntity *hraci[200];
int mn_pocet;
}; |
|
|
Návrat nahoru |
|
 |
MD

Založen: 29. 07. 2007 Příspěvky: 437 Bydliště: Praha
|
Zaslal: 22. duben 2009, 14:36:15 Předmět: |
|
|
Protoze jsem neveril tomu, co pisete, tak jsem si to zkusil v debuggeru. A vysledek je ten, ze nasledujici radky maji naprosto stejny efekt:
kód: |
string s = "bla";
string yy("bla");
|
Tedy nevola se ani konstruktor bez parametru, ani operator =. V obou pripadech se vola rovnou konstruktor(char*).
Takhle to funguje minimalne ve VS 2008.
Neco jineho je, pokud to rozepisete do dvou radku (string s; s="bla"; ) (pak se operator = zavola). _________________ - play with objects - www.krkal.org - |
|
Návrat nahoru |
|
 |
VladR
Založen: 30. 07. 2007 Příspěvky: 1322 Bydliště: Greater New York City Area
|
Zaslal: 22. duben 2009, 15:16:11 Předmět: |
|
|
Oprav ma ak sa mylim, ale to nie je takto zadefinovane v standarde.
Tipol by som, ze pokial vypnes vsetky optimalizacie a buildnes release, tak to tak nebude.
No, uz som zmateny teraz, pozrem este raz za akych podmienok sa vola copy constructor,ale mal by sa volat vzdy, ak inicializujes novu premennu/predavas hodnotou/ak je navratovou hodnotou funkcie - cize u nas je to ten prvy pripad. |
|
Návrat nahoru |
|
 |
Tringi

Založen: 28. 07. 2007 Příspěvky: 290
|
Zaslal: 22. duben 2009, 15:59:05 Předmět: |
|
|
VladR: Mýlíš se. Standard říká celkem jasně, že oba způsoby zavolají konstruktor. Tečka. Kopírovací konstruktor ani operátor přiřazení se nevolá. _________________ WWW | GitHub | TW |
|
Návrat nahoru |
|
 |
VladR
Založen: 30. 07. 2007 Příspěvky: 1322 Bydliště: Greater New York City Area
|
Zaslal: 22. duben 2009, 16:57:41 Předmět: |
|
|
Das mi link, ktory pouzivas na referenciou voci standardu ? Chcem si to tam pozriet, je mi to divne, ze na tolkych miestach na nete som to nasiel ako ten prvy bod (z tych troch moznosti). Svoj teraz po ruke nemam (a nie google na to nepouzijem). |
|
Návrat nahoru |
|
 |
Tringi

Založen: 28. 07. 2007 Příspěvky: 290
|
Zaslal: 23. duben 2009, 00:10:21 Předmět: |
|
|
Odkaz na ISO/IEC 14882:2003 Programming Language C++ ti nedám, protože plné revidované znění textu standardu je nutné si koupit. Přesto, draft tohoto i aktuálně rozpracované revize standardu (pod přezdívkou C++0x) lze získaz z webu pracovní skupiny WG21 zde: http://www.open-std.org/jtc1/sc22/wg21/
Původní po ruce nemám tak snad nevadí že vyjdu z draftu N2857 (ke stažení na uvedené adrese). Koukl jsem do toho jen tak zběžně, mám standard sice celkem dobře nastudovaný, ale opravdu z hlavy nevím kde co přesně je, takže v následujícím můžu opomenout podstatné věci:
§8.5.13 napsal: |
The form of initialization (using parentheses or =) is generally insignificant, but does matter when the initializer or the entity being initialized has a class type; see below. A parenthesized initializer can be a list of expressions only when the entity being initialized has a class type. |
§8.5.14 napsal: |
The initialization that occurs in the form
T x = a;
as well as in argument passing, function return, throwing an exception (15.1), handling an exception (15.3), and aggregate member initialization (8.5.1) is called copy-initialization. |
§8.5.15 napsal: |
The initialization that occurs in the form
T x(a);
as well as in new expressions (5.3.4), static_cast expressions (5.2.9), functional notation type conversions (5.2.3), and base and member initializers (12.6.2) is called direct-initialization. |
...a tak dále, nebudu vypisovat vše.
Dále problém s inicializací objektu popisují odstavce §12.3.
Dokonce i zápisy:
kód: |
C c = C(1,2,3);
C c = (C) 1// tzv. cast notation |
jsou prostou inicializací objektu a zavolá se jen jeden konstruktor pro objekt c
§12.1.11 napsal: |
11. A functional notation type conversion (5.2.3) can be used to create new objects of its type. [Note: The
syntax looks like an explicit call of the constructor. ?end note] [Example:
complex zz = complex(1,2.3);
cprint( complex(7.8,1.2) );
?end example] |
Také je zajímavé že zápis:
je zero-initialization, tedy vynulování před použitím. Sice je kratší napsat int a = 0; ale jen pro úplnost  _________________ WWW | GitHub | TW |
|
Návrat nahoru |
|
 |
ladik-BigBoss

Založen: 28. 07. 2007 Příspěvky: 162
|
Zaslal: 23. duben 2009, 02:19:29 Předmět: |
|
|
hlavní důvod proč jsou v C++ oba zápisy jsou šablony. tam použiješ třeba T a(100) a je ti jedno jestli si uživatel šablony dosadí za T int, double nebo MyClassX. prostě jenom musí mí konstruktor, který umí vzít 100. zatímco kdybys tam měl T a=100; tak int a double budou fungovat v pohodě, ale těžko předpokládat že třeba std::vector umí do sebe dát přes operátor = číslo 100. zatímco std::vector(100) vytvoří 100 prvků vektoru... |
|
Návrat nahoru |
|
 |
Tringi

Založen: 28. 07. 2007 Příspěvky: 290
|
Zaslal: 23. duben 2009, 17:02:15 Předmět: |
|
|
Oba zápisy jsou ekvivalentní, tedy:
kód: |
std::vector v = 100; |
je to samé jako
kód: |
std::vector v (100); |
Žádné ale. Žádný operátor přiřazení.
Ale ano, podpora obou syntaxí pro všechny typy je kvůli šablonám. Aby se nemusela psát specializace pro zabudované typy (int, char, ...). _________________ WWW | GitHub | TW |
|
Návrat nahoru |
|
 |
|