C++ optimization: avoid a copy operation

Question

I have the following:

#include <iostream>
#include <utility>

class T {
public:
    T() {std::cout << "Default constructor called" << std::endl;}
    T(const T&) {std::cout << "Copy constructor called" << std::endl;}
};

static T s_t;

T foo() {
    return s_t;
}

class A {
public:
    A() = delete;
    A(T t) : _t(t) {}
private:
    T _t;
};

int main() {

    std::cout << "Starting main" << std::endl;
    A a(foo());
    return 0;

}

When I compile it with the line: g++ -std=c++17 -O3 test.cpp and run it, I get the following output

Default constructor called
Starting main
Copy constructor called
Copy constructor called

My question is: since the constructor of A is taking an r-value object of type T that is only used to initialize _t, is it possible for the compiler to avoid the second copy operation and just copy s_t directly into _t?

(I understand that I can potentially replace the second copy with a move by implementing a move constructor for T)

@AndyG that's not even NRVO - NRVO refers to return of local variables. — SergeyA, Sep 26 '19 at 15:01
@AndyG ...and what is elided is the copy, not the optimization ;) — Max Langhof, Sep 26 '19 at 15:02
`g++ -std=c++17 test.cpp -o test` -- Please turn on optimizations, rebuild, and then give us the results. — PaulMcKenzie, Sep 26 '19 at 15:02
@PaulMcKenzie That won't change the output. The copy constructor has a side effect and is not used in a context where elision is allowed, so you will observe those side effects. — Max Langhof, Sep 26 '19 at 15:04
@PaulMcKenzie even with highest level of optimizations it's not going to be elided — SergeyA, Sep 26 '19 at 15:04
Notice than compiler elides one copy for `A(T t)` with `t == foo()`. — Jarod42, Sep 26 '19 at 15:18
@Jarod42 Good point for [past C++ versions](https://godbolt.org/z/e6oKgk), but since C++17 there is no copy there, not even conceptually: https://godbolt.org/z/l1Ibdy — Max Langhof, Sep 26 '19 at 15:25

score 1 · Answer 1 · edited Jun 20 '20 at 09:12

Your copy constructor has an observable side effect (output). The (almost) golden rule of C++ optimizations is the as-if rule: Observable side effects must not be changed. But one of the two exceptions from this rule is the elision of some copy operations, specified here:

http://eel.is/c++draft/class.copy.elision

When certain criteria are met, an implementation is allowed to omit the copy/move construction of a class object, even if the constructor selected for the copy/move operation and/or the destructor for the object have side effects.

But this is only allowed in very specific circumstances:

This elision of copy/move operations, called copy elision, is permitted in the following circumstances (which may be combined to eliminate multiple copies):

in a return statement in a function with a class return type, when the expression is the name of a non-volatile automatic object [...]

Your variable does not have automatic storage duration (i.e. it is not a local variable).

in a throw-expression, [...]

We are not a throw-expression.

in a coroutine [...]

We are not in a coroutine.

when the exception-declaration of an exception handler ([except]) declares an object of the same type (except for cv-qualification) as the exception object ([except.throw]) [...]

This is not the case either.

Neither the return of a global variable from a function, nor the use of a constructor parameter to initialize a member variable is covered here, so it would be illegal for any compiler to elide these copies in the code you show.

That said, if the compiler can prove that there are no side effects (which, in the case of most compilers, include system calls and memory allocations), it is of course free to elide the copy under the as-if rule, just like for all other optimizations.

Thanks @MaxLanghof. I wonder why this case is not allowed by the specification. — jmoxoby, Sep 26 '19 at 15:21
@jmoxoby - It's not allowed because in the scope of the c'tor you have two declared objects (the member and the parameter). Since you declared an object there, it must exist, meaning it must be initialized. The compiler can't just make it disappear as easily as one may want. — StoryTeller - Unslander Monica, Sep 26 '19 at 15:41

C++ optimization: avoid a copy operation

1 Answers1