C ++在技术上如何在没有副本的情况下移动函数返回值？

Question

When a function returns a value, this is put on the stack (the function stack frames are deleted, but the return value remains there until the caller gets it).

If the return value is on the stack how can the move get that value without copying it in the variable memory location?

For example in this code:

A a = getA();

Answer 1

The storage (Heap, stack, registers, etc) used to store the temporary used to return values from a function is implementation defined. You could see it as:

+-----------------------------+-------------------------+-----------------------------------------+
| target (caller stack frame) | temporary (unspecified) | return statement (function stack frame) | 
+-----------------------------+-------------------------+-----------------------------------------+ 

The value is passed from the right to the left. Also note that the standard specifies that any compiler could elide the temporary and the assigments/copies/moves and directly initialize the target.

Writting a class such as:

class trace
{
public:
    trace()
    { 
        std::cout << "Init" << std::endl;
    }

    ~trace()
    { 
        std::cout << "Destroy" << std::endl;
    }

    trace( const trace& )
    { 
        std::cout << "Copy init" << std::endl;
    }

    trace( trace&& )
    { 
        std::cout << "Move init" << std::endl;
   }

    trace& operator=( const trace& )
    { 
        std::cout << "Copy assign" << std::endl;
    }

    trace& operator=( trace&& )
    { 
        std::cout << "Move assign" << std::endl;
    }
};

And trying it with different compiler optimizations enabled is very ilustrative.

Answer 2

In many implementations of C++, a function returning a "complex" data type is passed a hidden parameter that is a pointer to the space where the returned instance is to reside. Essentially, the compiler turns Foo r = fun(); into

char alignas(Foo) r[sizeof Foo]; // Foo-sized buffer, unitialized!
fun(&r);

As you can see, Foo is allocated on the stack in the caller's frame. Now, within the implementation of fun there could be a copy. The construction

Foo fun() {
  Foo rv;
  ...
  return rv;
}

is generally implemented as

void fun(Foo * $ret) {
  Foo rv;
  ..
  new ($ret) Foo(rv); // copy construction
}

When the return value optimizations are applied, this gets changed to

void fun(Foo * $ret) {
  Foo & rv = *(new ($ret) Foo);
  ...
  return;
}

Now there's no copying involved. That's a mile-high overview of how an implementation might do it.

Answer 3

You're assuming that A is an aggregate or primitive. If this is true then yes move and copy semantics are equivalent. If however A is a complex type like vector then it will contain pointers to resources. When moving the object the pointers are copied without copying the value they point to.

Answer 4

When you say "move", I assuming you're referring to C++11 move constructors and the std::move function.

Moving an object doesn't actually move the entire object. It constructs a new one using its move constructor, which is allowed to take ownership of resources held by the original object instead of copying them. For example, if you write:

std::vector<int> foo = function_that_returns_a_vector();

the compiler may implement this by calling foo 's move constructor and passing it the temporary vector returned by the function. The move constructor will take ownership of the temporary vector's internal pointer to its heap-allocated contents, leaving the temporary vector empty. Prior to C++11 and move support, foo 's copy constructor would've been called, which would've allocated new space on the heap to copy the returned vector's contents even though that returned vector is about to be destroyed and won't need its own copy any longer.

Note that the compiler won't necessarily implement that line by constructing foo from a returned temporary at all, though. Depending on the compiler's platform-specific calling convention, the address of the (uninitialized) foo variable may be passed into the function in such a way that the function's return value is constructed directly into foo , avoiding the need for a copy after the function returns. This is called copy elision .

Answer 5

The easiest is to modify your method like this:

void getA(A& out);

A a;
getA(a);

However, your compiler does it's best to avoid such superfluity: Copy Elision