专门用于右值的 std::swap

Question

In the standard (20.2.2 [utility.swap]), std::swap is defined for lvalue references. I understand that this is the common case for when you want to swap two things. However, there are times when it's correct and desirable to swap rvalues (when temporary objects contain references, like here: swap temporary tuples of references ).

Why isn't there an overload for rvalues? Does the risk of doing a meaningless swap on rvalues outweigh the potential benefits?

Is there a legal way to support swapping rvalue std::tuple objects which contain references? For a user defined type, I would specialize swap to accept its arguments by value, but it doesn't seem kosher to do the same for a library type like std::tuple.

Answer 1

How about instead creating an lvalue_cast utility function that casts an rvalue to an lvalue:

#include <tuple>
#include <iostream>

template <class T>
T&
lvalue_cast(T&& t)
{
    return t;
}

int
main()
{
    int i = 1;
    int j = 2;
    swap(lvalue_cast(std::tie(i)), lvalue_cast(std::tie(j)));
    std::cout << i << '\n';
    std::cout << j << '\n';
}

Answer 2

Some STL algorithms would seem to require a swap for r-values if the iterator produced an r-value (for example a temporary).

It is a valid discussion whether swap should work with r-values. I often see this problem because for "special" iterators, *it produces an r-value and sometimes you want to do the right things when "swapping".

The workaround I found to not deal with this question was to specialize std::iter_swap for these special iterators in the first place. I think that solve the problem for all STL algorithms.

namespace std{
void iter_swap(special_iterator it1, special_iterator it2){
   ... special swap of pointed values
}
}

I think this is a fundamental customization point that all permuting STL algorithm miss and lack.

(Of course if we are at the point of hacking the STL we can as well do namespace std{template<class T, ...enable_if T&& is r-value ref just in case...> void swap(T&& t1, T&& t2){swap(t1, t2);} . But it is even more risky.)