pre return optimization

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;
    //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.
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.C++ lacks such syntax
and IMHO we should be able to mark the result object as referencing
the actual return so that there is no need for the extra copy
construction;this is espesifically beneficall when dealing with
operator definitions .We can declare the return itself as an object.I
suggest the following syntax:

class ret_type funxn (paramlist){
    ret_type return /*optional:*/(initiallizer params);

        //etc...

        if(false)return;//return like void functions

        //return something;//error:named return accepts no param.

        return=something;//ok;
        return=something_else;
        return.member_funxn();
    another_funcxn(return);

};

Provided that 'return' is declared as an object { whenever you use the
'return' keyword inside pharantesis or accompanied via an operator ?
the return object is referenced :otherwise a parameterless 'return'
returns to the caller.
The return object is an lvalue inside the function and can be aliased
for readability:

memory_pig foo(){
    memory_pig return , & result=return;
    result=something;
    //etc...
        result=something_else;
};

and whenever 'foo' is called the output looks like this:

mem pig default

the unnessesary copy/move has vanished and the destruction of
temporary depends on what you do with it.

regards,
FM.

---
[ comp.std.c++ is moderated. To submit articles, try just posting with ]
[ your news-reader. If that fails, use mailto:std-c++@ncar.ucar.edu ]
[ --- Please see the FAQ before posting. --- ]
[ FAQ: http://www.comeaucomputing.com/csc/faq.html ]