What's the value of rvalues?

Question

That is, how much performance improvement one typically gets in an otherwise well-designed C++03 code when one takes advantage of C++11 typename && features such as move constructors, etc.? How often it's worth the trouble, and in what circumstances?

EDIT:

Imagine an alternative universe where instead of rvalue references C++11 extended C++03 with a keyword "returning" that marks a local variable that would get returned by a function. If a local variable is marked as "returning" it's placed in the portion of the stack where the return value would usually reside. Imagine you could use that keyword like this:

SomeClass foo()
{
    returning SomeClass bar; // Created where return value usually resides.
    // do something with bar
    return bar; // No copy constructor is involved here.
}

I think such mechanism would enable creation of make_unique and such just as well as rvalue references do, and would cause much less confusion and potential pitfalls. Rule of three would remain rule of three instead of becoming rule of five; there would be no confusion of whether && if rvalue ref or universal ref; there would be no need for std::move etc.

What am I missing here?

Answer 1

The value of rvalue references does not not primarily lie in performance. Much rather, it lies in expressiveness. Without rvalue references, you cannot encode ownership in the type system in a useful way. Thanks to transfer of ownership that rvalue references allow, we can now write fully subexpression-wise correct code that has no non-local dependencies.

For example, pre-C++11:

int * p = new int[N];    // may be a bug, who knows?

                         // ... keep paying attention...

delete p;                // ah, no bug... or is it?

With rvalues:

auto p = std::make_unique<int[]>(N);   // fine

Note that no single subexpression of the modern example is itself ever the root cause of a resource bug. The same approach can be applied to a myriad of resource/handle pairs: memory/pointer, file/handle, mutex/lock, task/continuation, etc.

(If you think of resource acquisition and release as two opposite poles, then modern C++ should be written like a magnet: the two are always together as part of one entity.)

Allowing the type system to completely guarantee locality of correctness is a dramatic improvement of the language.