Avoiding copy of objects with the “return” statement

by

There seems to be some confusion as to how the RVO (Return Value Optimization) works.

A simple example:

#include <iostream>

struct A {
    int a;
    int b;
    int c;
    int d;
};

A create(int i) {
    A a = {i, i+1, i+2, i+3 };
    std::cout << &a << "\n";
    return a;
}

int main(int argc, char*[]) {
    A a = create(argc);
    std::cout << &a << "\n";
}

And its output at ideone:

0xbf928684
0xbf928684

Surprising ?

Actually, that is the effect of RVO: the object to be returned is constructed directly in place in the caller.

How ?

Traditionally, the caller (main here) will reserve some space on the stack for the return value: the return slot; the callee (create here) is passed (somehow) the address of the return slot to copy its return value into. The callee then allocate its own space for the local variable in which it builds the result, like for any other local variable, and then copies it into the return slot upon the return statement.

RVO is triggered when the compiler deduces from the code that the variable can be constructed directly into the return slot with equivalent semantics (the as-if rule).

Note that this is such a common optimization that it is explicitly white-listed by the Standard and the compiler does not have to worry about possible side-effects of the copy (or move) constructor.

When ?

The compiler is most likely to use simple rules, such as:

// 1. works
A unnamed() { return {1, 2, 3, 4}; }

// 2. works
A unique_named() {
    A a = {1, 2, 3, 4};
    return a;
}

// 3. works
A mixed_unnamed_named(bool b) {
    if (b) { return {1, 2, 3, 4}; }

    A a = {1, 2, 3, 4};
    return a;
}

// 4. does not work
A mixed_named_unnamed(bool b) {
    A a = {1, 2, 3, 4};

    if (b) { return {4, 3, 2, 1}; }

    return a;
}

In the latter case (4), the optimization cannot be applied when A is returned because the compiler cannot build a in the return slot, as it may need it for something else (depending on the boolean condition b).

A simple rule of thumb is thus that:

RVO should be applied if no other candidate for the return slot has been declared prior to the return statement.

More Related Contents:

  1. What happens when a function that returns an object ends without a return statement
  2. How do C++ progs get their return value, when a return is not specified in the function?
  3. Calling function in string.h file without object
  4. Return array in a function
  5. C++: What is the size of an object of an empty class?
  6. return statement vs exit() in main()
  7. If a function returns no value, with a valid return type, is it okay to for the compiler to return garbage?
  8. C++ return array from function [duplicate]
  9. How to return a std::string.c_str()
  10. How to copy/create derived class instance from a pointer to a polymorphic base class?
  11. Create a directory if it doesn’t exist
  12. Proper way to copy C strings
  13. exit() call inside a function which should return a reference
  14. Create new C++ object at specific memory address?
  15. C++ return value without return statement
  16. How do I return a char array from a function?
  17. How do you copy the contents of an array to a std::vector in C++ without looping?
  18. Function in C++ returns by value or by reference?
  19. Why do we need to use `int main` and not `void main` in C++? [duplicate]
  20. At what point does dereferencing the null pointer become undefined behavior?
  21. Does std::cout have a return value?
  22. Copying std::vector: prefer assignment or std::copy?
  23. Returning a void?
  24. Function returning array but main showing garbage [duplicate]
  25. passing object by reference in C++
  26. Scope and return values in C++
  27. Insert into an STL queue using std::copy
  28. How to write an object to file in C++
  29. What is the proper way to return an object from a C++ function?
  30. Why Doesn’t reinterpret_cast Force copy_n for Casts between Same-Sized Types?

Leave a Comment