🚀 go-pugleaf

Bert Peers wrote:

> Nicolas Barbier wrote:
>  >
>>         static Blaat gimme() {
>>                 return Blaat(5);
>> 
>> extern void bliep(const Blaat &b);
>> int main()
>> {
>>         bliep(Blaat(1));
>> 
>> Hoewel ik had verwacht dat het eerste deel van de functie beter
>> "samengeplakt" zou geworden zijn (de proloog wordt misschien nooit
>> geoptimaliseerd ofzo?), zie je duidelijk dat het object nooit gekopieerd
>> wordt.
> 
> Euh, ik kan niet goed volgen vrees ik.  Was het niet je bedoeling
> om iets te schrijven als bliep(Blaat::gimme()) ?

/me slaps himself *dough* "stupid!"

Inderdaad, ik lijk even verward te zijn geweest ;-)

Hier volgt de correcte versie, die echter eveneens aantoont dat GCC dit kan 
wegoptimalizeren:

/* test.cpp */
class Blaat {
public:
        Blaat(int i) {
                this->i = i;
        }
        static Blaat gimme() {
                return Blaat(5);
        }
private:
        int i;
};

extern void bliep(const Blaat &b);

int main()
{
        bliep(Blaat::gimme());
        /* Hier vergeet ik iets te returnen, merk dat GCC daar zelfs met
           -Wall, -ansi en -pedantic niets op zegt, en dat er in de
           gegenereerde code zelfs voor gezorgd wordt dat er 0 wordt
           gereturnd? */
}

/* gedeelte van test.s */
.globl main
        .type   main,@function
main:
.LFB1:
        pushl   %ebp
.LCFI0:
        movl    %esp, %ebp
.LCFI1:
        subl    $8, %esp
.LCFI2:
        andl    $-16, %esp
        subl    $12, %esp
        leal    -4(%ebp), %edx
        pushl   %edx
        movl    $5, -4(%ebp)
.LCFI3:
        call    _Z5bliepRK5Blaat
        xorl    %eax, %eax
        leave
        ret

> 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? De stack 
gaat meteen weer worden overschreven terwijl er via de referentie nog naar 
het object kan gerefereerd worden.

Die "bliep" functie had ik er eigenlijk alleen maar bijgezet om te 
voorkomen dat alles volledig zou worden weg-geoptimalizeerd :-) (niet 
getest of dat ook werkelijk zo zou zijn anders).

-- 
Nicolas Barbier