Question

I wanted to verify the if the following optimizations work as expected:

• RVO
• Named RVO
• Copy elision when passing an argument by value

So I wrote this little program:

#include <algorithm>
#include <cstddef>
#include <iostream>
#include <vector>

struct Foo {
    Foo(std::size_t length, char value) : data(length, value) { }

    Foo(const Foo & rhs) : data(rhs.data) { std::cout << "*** COPY ***" << std::endl; }

    Foo & operator= (Foo rhs) {
        std::cout << "*** ASSIGNMENT ***" << std::endl;
        std::swap(data, rhs.data); // probably expensive, ignore this please
        return *this;
    }

    ~Foo() { }

    std::vector<char> data;
};

Foo TestRVO() { return Foo(512, 'r'); }

Foo TestNamedRVO() { Foo result(512, 'n'); return result; }

void PassByValue(Foo inFoo) {}

int main()
{
    std::cout << "\nTest RVO: " << std::endl;
    Foo rvo = TestRVO();

    std::cout << "\nTest named RVO: " << std::endl;
    Foo named_rvo = TestNamedRVO();

    std::cout << "\nTest PassByValue: " << std::endl;
    Foo foo(512, 'a');
    PassByValue(foo);

    std::cout << "\nTest assignment: " << std::endl;
    Foo f(512, 'f');
    Foo g(512, 'g');
    f = g;
}

And I compiled it with optimizations enabled:

$ g++ -o test -O3 main.cpp ; ./test

This is output:

Test RVO: 

Test named RVO: 

Test PassByValue: 
*** COPY ***

Test assignment: 
*** COPY ***
*** ASSIGNMENT ***

According to the output RVO and named RVO work as expected. However, copy elision is not performed for the assignment operator and when calling PassByValue.

Is copy elision not allowed on user defined copy-constructors? (I know that RVO is explicitly allowed by the standard but I don’t know about copy elision when passing by value.) Is there a way to verify copy elision without defining copy constructors?

Answer 1

The way you use the copy constructor it can not be elided, as the copied object still exists after the call.

If you try it this way, it might work better:

PassByValue(Foo(512, 'a')); 

All optimizations are allowed but not required, so it is up to each compiler to decide what it can and will do.