Copy elision and return value optimisation

Understanding Copy elision and return value optimisation

Two different mechanisms hide behind the phrase copy elision, and only one of them is a guarantee. Since C++17 a prvalue such as the Widget{3} in `return Widget{3};` is not an object at all but a pending initialization that gets applied to whatever object eventually needs it, so `Widget w = make();` builds exactly one Widget, directly in w. There is nothing for the compiler to optimise away here, because no second object and no constructor call ever entered the picture; that is why a type with a deleted copy and move constructor can still be returned this way.

Returning a named local is a different story. The local is a real object with its own address, and the return statement is specified as initializing the function's result object from it, so overload resolution has to pick a constructor — since C++11 it first treats the local as an rvalue, which is why a move constructor wins when one exists and why you never need to write that cast yourself. The compiler is then permitted, but never obliged, to place the local directly in the caller's storage and skip the constructor call; that is NRVO. Because the call is skipped rather than removed from the rules, the chosen constructor must still be accessible and non-deleted, and because the standard explicitly allows eliding it even when the constructor prints or counts, this is the one optimisation allowed to change your program's observable output.

The practical rule follows from the mechanics: construct the object in the return statement where you can, and where you need a named local, return its bare name. Wrapping that name in std::move turns the return expression into an xvalue rather than the name of a local, which disqualifies NRVO, so you buy a guaranteed move construction plus a hollowed-out local to destroy; GCC and Clang both diagnose this with -Wpessimizing-move. std::move on a return is only useful when the expression is not simply a local's name, for example `return std::move(pair.second);`, where elision was impossible from the start.

#include <iostream>
#include <utility>

struct Noisy {
    int id;
    static int total;
    Noisy() : id(++total) { std::cout << "construct #" << id << '\n'; }
    Noisy(const Noisy& o) : id(++total) { std::cout << "copy #" << o.id << " -> #" << id << '\n'; }
    Noisy(Noisy&& o) noexcept : id(++total) { std::cout << "move #" << o.id << " -> #" << id << '\n'; }
};
int Noisy::total = 0;

Noisy fromPrvalue()    { return Noisy{}; }                       // mandatory: no copy exists
Noisy fromNamedLocal() { Noisy local; return local; }            // NRVO: allowed, not required
Noisy fromMovedLocal() { Noisy local; return std::move(local); } // NRVO disqualified

int main() {
    std::cout << "-- return Noisy{} --\n";
    Noisy a = fromPrvalue();
    std::cout << "-- return local --\n";
    Noisy b = fromNamedLocal();
    std::cout << "-- return std::move(local) --\n";
    Noisy c = fromMovedLocal();
    std::cout << "a=#" << a.id << " b=#" << b.id << " c=#" << c.id << '\n';
    std::cout << "objects constructed: " << Noisy::total << '\n';
}

Worked examples

#include <iostream>

struct Handle {
    int fd;
    explicit Handle(int fd) : fd(fd) { std::cout << "open " << fd << '\n'; }
    Handle(const Handle&) = delete;
    Handle(Handle&&) = delete;
    ~Handle() { std::cout << "close " << fd << '\n'; }
};

Handle open_handle(int fd) { return Handle{fd}; }
void use(Handle h) { std::cout << "use " << h.fd << '\n'; }

int main() {
    Handle h = open_handle(3);
    use(open_handle(7));
    std::cout << "still holding " << h.fd << '\n';
}

#include <iostream>

struct Tag {
    Tag()           { std::cout << "built\n"; }
    Tag(const Tag&) { std::cout << "copied\n"; }
    Tag(Tag&&)      { std::cout << "moved\n"; }
    ~Tag()          { std::cout << "destroyed\n"; }
};

Tag innermost() { return Tag{}; }
Tag middle()    { return innermost(); }
Tag outer()     { return middle(); }

int main() {
    Tag t = outer();
    std::cout << "t is the only Tag\n";
}

#include <iostream>
#include <string>
#include <utility>

const void* seen_inside = nullptr;

struct Buffer { std::string bytes = std::string(64, 'x'); };

Buffer elided() {
    Buffer b;
    seen_inside = &b;
    return b;
}

Buffer pessimised() {
    Buffer b;
    seen_inside = &b;
    return std::move(b);
}

int main() {
    Buffer x = elided();
    std::cout << "return local:            same object? "
              << (seen_inside == static_cast<const void*>(&x)) << '\n';
    Buffer y = pessimised();
    std::cout << "return std::move(local): same object? "
              << (seen_inside == static_cast<const void*>(&y)) << '\n';
}

Important notes

Common mistakes

Try it yourself