Question

I ran across this article on copy ellision in C++ and I’ve seen comments about it in the boost library. This is appealing, as I prefer my functions to look like

verylargereturntype DoSomething(...)

rather than

void DoSomething(..., verylargereturntype& retval)

So, I have two questions about this

1. Google has virtually no documentation on this at all, how real is this?
2. How can I check that this optimization is actually occuring? I assume it involves looking at the assembly, but lets just say that isn’t my strong suit. If anyone can give a very basic example as to what successful ellision looks like, that would be very useful

I won’t be using copy ellision just to prettify things, but if I can be guaranteed that it works, it sounds pretty useful.

Answer 1

I think this is a very commonly applied optimization because:

1. it’s not difficult for the compiler to do
2. it can be a huge gain
3. it’s an area of C++ that was a commonly critiqued before the optimization became common

If you’re just curious, put a debug printf() in your copy constructor:

class foo {
public:
    foo(): x(0) {};

    foo(int x_) : x( x_) {};

    foo( foo const& other) : x( other.x) {
        printf( "copied a foo\n");
    };

    static foo foobar() {
        foo tmp( 2);

        return tmp;
    }


private:
    int x;
};



int main()
{
    foo myFoo;

    myFoo = foo::foobar();

    return 0;
}

Prints out “copied a foo” when I run an unoptimmized build, but nothing when I build optimized.