🚀 go-pugleaf

Nicolas Barbier wrote:

> Bert Peers wrote:
> 
>> Nicolas Barbier wrote:
>> 
>>> Bert Peers wrote:
>>> 
>>>>Maar dan nog weet ik niet of dit helpt -- de copy constructor wordt
>>>>aangeroepen op het moment dat de return value van de functie in de
>>>>"recipient" terecht komt.Als die recipient enkel een const& nodig heeft,
>>>>moet er niks gekopieerd worden.  Ik zou zelfs bijna zeker zeggen,
>>>>"..._mag_ er niks gekopieerd worden".
>>> 
>>> Ben je daar zeker van? Je bedoelt dus dan in dit geval de
>>> copy-constructur niet opgeroepen mag worden? Ik dacht altijd (puttende
>>> uit mijn absoluut onbenullige C++ kennis :-) dat hij altijd wordt
>>> aangeroepen als je een volledig object returnt uit een functie.
>>> Trouwens, waar zouden, bij een gemiddelde compiler, anders de bytes van
>>> het object blijven staan?
>> 
>> Wel, de compiler is nu eenmaal verplicht om, als er een
>> const-reference naar een temporary gebruikt wordt als parameter,
>> te zorgen dat die temporary "lang genoeg" blijft hangen.
>> 
>> Denk maar aan het meer vertrouwde
>> 
>> void blabla (const std::string &s);
>> blabla ("yup");
>> 
>> Je kan die gimme zien als een "conversie" die van niks
>> een Blaat maakt...  Trouwens, of de copy c'tor nu aangeroepen
>> wordt of niet, het mysterie van de bytes wordt er niet minder
>> op : gezien het feit dat bliep een const Blaat& als argument
>> heeft, naar waar zou er dan eigenlijk gekopieerd worden ?
>> Antwoord : eveneens naar een onzichtbare Blaat die eventjes snel
>> wordt gealloceerd zodat bliep er een const& van kan krijgen.
>> 
>> De compiler heeft meer opties dan "heap of stack" :^)
>> In die zin klopt het dat er een kopie buiten
>> "de normale ruimte van de functie" (dwz de stack) wordt
>> gemaakt -- waar het om gaat is dat de copy constructor
>> daar niet voor (mag) gebruikt worden, enkel compiler magic.
> 
> Ik leer weer bij over de semantiek van C++ :-).
> 
> /* test.cpp */
> #include <iostream>
> 
> class Blaat {
> public:
>         Blaat(int i) {
>                 std::cout << "constructor" << std::endl;
>         }
>         Blaat(const Blaat &b) {
>                 std::cout << "copy constructor" << std::endl;
>         }
>         static Blaat gimme() {
>                 return Blaat(3);
>         }
> };
> 
> int main()
> {
>         Blaat a(Blaat::gimme());
>         std::cout << "tussen a en b" << std::endl;
>         Blaat b(a);
> }
> 
> /* uitvoer */
> constructor
> tussen a en b
> copy constructor
> 
> De semantiek van een functie die een object returnt is dus blijkbaar niet
> "kopieer het te returnen object (via de copy constructor) naar de
> ontvangende temporary van de aanroepende functie", maar eerder "de
> ontvangende temporary van de aanroepende functie is hetzelfde object als
> hetgeen gereturnd wordt".
> 
> Weet je toevallig ook nog waarom er geen copy constructor-aanroep gebeurt
> tussen "constructor" en "tussen a en b"? :-)
> 
g++ heeft deze al weggeoptimaliseerd, dit moet expliciet afgezet worden:
-fno-elide-constructors
           The C++ standard allows an implementation to omit creating a
tempo-
           rary which is only used to initialize another object of the same
           type.  Specifying this option disables that optimization, and
           forces G++ to call the copy constructor in all cases.
Dan geeft het (zoals verwacht):
constructor
copy constructor
copy constructor
tussen a en b
copy constructor

-- 
Groeten,
Slayerke