Why STL classes do not overload swap() for rvalues?

Question

STL classes define swap() method as void swap(A&), taking an l-value reference. See for example std::vector::swap, or this question "Is `std::move` necessary here?".

Such definition means we cannot swap with r-values, since r-value won't bind to However, I see no harm in swapping with r-values. Construct it, steal from it, place some guts in it, destroy it. Done. We can add another overload void swap(A&&) to make it happen.

I see only one reason why we do not have this overload out of the box. Because instead of writing

v.swap(rvalue);

It is better to write

v = rvalue;

And instead of swapping we will trigger move-assignment, which is even more efficient. Am I right that this reason is valid? Is this the only reason?

Answer 1

One of the original move papers actually specified this for the containers:

http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2005/n1858.html#23.2%20-%20Sequences

And later propagated to shared_ptr and function:

http://cplusplus.github.io/LWG/lwg-defects.html#743

http://cplusplus.github.io/LWG/lwg-defects.html#770

Swapping with rvalue arguments fell out of favor with LWG 884:

http://cplusplus.github.io/LWG/lwg-defects.html#884

And N2844 subsequently removed all rvalue swaps:

http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2844.html

I'm not positive this was a good move. However with the more modern shrink_to_fit() way of reducing memory, I'm not positive it matters, since that was the main use case of swapping with rvalues.

Answer 2

You've more or less answered your own question.

We needed

  v.swap(rvalue);

in the bleak dark-ages leading up to C++11. Since then, we can explicitly grab a hold of rvalues to do as we please.

Allowing swap to take rvalues would be taking a step backwards