🚀 go-pugleaf

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"? :-)

-- 
Nicolas Barbier