我不明白什么时候我应该使用std::move，什么时候我应该让编译器优化…例如:
using SerialBuffer = vector< unsigned char >;
// let compiler optimize it
SerialBuffer read( size_t size ) const
{
SerialBuffer buffer( size );
read( begin( buffer ), end( buffer ) );
// Return Value Optimization
return buffer;
}
// explicit move
SerialBuffer read( size_t size ) const
{
SerialBuffer buffer( size );
read( begin( buffer ), end( buffer ) );
return move( buffer );
}
我应该用哪一种?
所有返回值要么已经移动，要么已经优化，所以不需要显式地移动返回值。
编译器允许自动移动返回值(以优化出副本)，甚至优化出移动!
n3337标准草案(c++ 11)第12.8节:
When certain criteria are met, an implementation is allowed to omit the copy/move construction of a class object, even if the copy/move constructor and/or destructor for the object have side effects. In such cases, the implementation treats the source and target of the omitted copy/move operation as simply two different ways of referring to the same object, and the destruction of that object occurs at the later of the times when the two objects would have been destroyed without the optimization.This elision of copy/move operations, called copy elision, is permitted in the following circumstances (which may be combined to eliminate multiple copies): [...] Example: class Thing { public: Thing(); ~Thing(); Thing(const Thing&); }; Thing f() { Thing t; return t; } Thing t2 = f(); Here the criteria for elision can be combined to eliminate two calls to the copy constructor of class Thing: the copying of the local automatic object t into the temporary object for the return value of function f() and the copying of that temporary object into object t2. Effectively, the construction of the local object t can be viewed as directly initializing the global object t2, and that object’s destruction will occur at program exit. Adding a move constructor to Thing has the same effect, but it is the move construction from the temporary object to t2 that is elided. — end example ] When the criteria for elision of a copy operation are met or would be met save for the fact that the source object is a function parameter, and the object to be copied is designated by an lvalue, overload resolution to select the constructor for the copy is first performed as if the object were designated by an rvalue. If overload resolution fails, or if the type of the first parameter of the selected constructor is not an rvalue reference to the object’s type (possibly cv-qualified), overload resolution is performed again, considering the object as an lvalue.
If you're returning a local variable, don't use move(). This will allow the compiler to use NRVO, and failing that, the compiler will still be allowed to perform a move (local variables become R-values within a return statement). Using move() in that context would simply inhibit NRVO and force the compiler to use a move (or a copy if move is unavailable). If you're returning something other than a local variable, NRVO isn't an option anyway and you should use move() if (and only if) you intend to pilfer the object.
只使用第一种方法:
Foo f()
{
Foo result;
mangle(result);
return result;
}
这将允许使用move构造函数(如果有的话)。事实上，当允许复制省略时，局部变量可以精确地绑定到return语句中的右值引用。
第二个版本会主动禁止复制省略。第一个版本普遍更好。
这很简单。
返回缓冲区;
如果你这么做，要么发生NRVO，要么不会。如果它没有发生，那么缓冲区将从。
返回std::move(buffer);
如果你这样做，那么NVRO将不会发生，缓冲区将从。
因此，使用std::移动到这里没有任何好处，反而会失去很多。
上述规则有一个例外:
读取缓冲区(Buffer&& Buffer) { / /…… 返回std::move(buffer); ｝ 如果buffer是一个右值引用，那么应该使用std::move。 这是因为引用不符合NRVO的条件，所以没有 Std::move将导致从左值进行复制。 这只是规则“总是移动右值引用”的一个实例 和前向通用引用”，它优先于 规则“永不移动返回值”。
从c++ 20开始，这个异常可以被遗忘。现在，return语句中的右值引用将隐式移动。
