Re: pre return optimization

From:

=?UTF-8?B?RXJpayBXaWtzdHLDtm0=?= <Erik-wikstrom@telia.com>

Newsgroups:

comp.lang.c++

Date:

Tue, 09 Oct 2007 16:08:48 GMT

Message-ID:

<kINOi.10773$ZA.7056@newsb.telia.net>

On 2007-10-09 17:56, terminator(jam) wrote:

consider:

struct memory_pig{//a really large type:

    memory_pig(){
        std::cout<<"mem pig default\n";
        //etc...
    };

    memory_pig(memory_pig const&){
        std::cout<<"mem pig copy\n";
        //etc...
    };

    ~memory_pig(){
        std::cout<<"mem pig finish\n";
        //etc...
    };

    //etc...

};///struct memory_pig

memory_pig foo(){
    memory_pig result;
    result=something;

This should be

memory_pig result = something;

or

memory_pig result(something);

     //etc...
        result=something_else;
    return result;
};

any time 'foo' is called the output will contain the following
sequence:

mem pig default
mem pig copy
mem pig finish

the last line of output may repeat based on how the result is
stored(rvo) or not.

With some smart coding you can transform the above to:

memory_pig foo(){
// ...
return memory_pig(something, something_else);
}

And with RVO you should only have one constructor call.

So,two objects of a large type will be constructed and at least one is
destructed on every call to 'foo' in PASCAL you can write:

function foo:memory_pig
begin
    foo:=something;
    {etc...}
    foo:=somthing_else;
end

that is you can refrence the returned object inside the function and
decrease the overhead for copying large objects.

I am not familiar with what that exactly means in Pascal, is it
something similar to

void foo(memory_pig& ret) {
  // ...
  ret = something;
  // ...
  ret = something_else;
}

Another thing that you seem to forget is that for large objects the
assignment is not cheap either, sometimes even more costly than a
constructor call.

--
Erik Wikstr??m