Why doesn't std::swap swap underlying objects of std::reference_wrapper?

Question

Background:

I am trying to implement a function, let's call it mysort, that takes variable number of arguments of same type and sort them. For example the code below should print 1 2 3

template <typename ... Args>
void mysort(Args& ... args);
int main(int, char**)
{
    int x = 3;
    int y = 1;
    int z = 2;
    mysort(x, y, z);
    cout << x << ' ' << y << ' ' << z << endl;
    return 0;
}

What I have tried:

Here is the solution I came up with

#include <array>
#include <algorithm>
#include <functional>

template <typename T, typename ... Args>
void mysort(T& t, Args& ... args)
{
    constexpr size_t n = sizeof...(Args) + 1;
    std::array<std::reference_wrapper<T>, n> temp = { std::ref(t), std::ref(args)... };
    std::sort(temp.begin(), temp.end());
}

But this solution doesn't work because what std::swap does with std::reference_wrapper is not what I expect (I expect any changes to std::reference_wrapper should change the object for which std::reference_wrapper was created).

Everything starts working after adding

namespace std
{
    void swap(std::reference_wrapper<int>& a, std::reference_wrapper<int>& b) noexcept
    {
        std::swap(a.get(), b.get());
    }
}

I'm not sure if the standard requires std::sort to use std::swap, so I think this is not a complete solution and is implementation-dependent.

Summarizing:

My idea of a std::reference_wrapper is that it should behave just like a reference, but that doesn't seem to be the case. Here are my questions:

1. What is the best way to implement mysort?
2. Why doesn't the standard provide a std::swap specification for std::reference_wrapper that would swap underlying objects?

Thank you in advance for your answers!

Answer 1

The point of std::reference_wrapper is that it is copyable and assignable, "assignable" in the sense that a reference wrapper can be rebound to a new value the way that a normal reference cannot.

You're doing the opposite of what it is intended for. In your case when the implementation of std::sort swaps items in the temporary array it is rebinding the references, but this is not what you want. You want it to swap the actual items not the references.

One way to do this would be to let std::sort sort copies of the arguments and then assign them back to your reference arguments in sorted order:

template <typename T, typename ... Args>
void mysort(T& t, Args& ... args)
{
    constexpr size_t n = sizeof...(Args) + 1;
    std::array<T, n> temp = { t, args... };
    std::sort(temp.begin(), temp.end());
    std::tie(t, args...) = std::tuple_cat(temp);
}

Here I wrap them in a tuple so I can assign via std::tie. There may be some way to do this with fewer copies, but this is what came to mind.

Answer 2

Basically, std::reference_wrapper is an old poorly designed class that currently serves certain simple purposes, like in std::bind/bind_front or in construction of std::thread, where it is used to imply that the variables aren't copied but taken by reference. And one creates them via std::ref/cref.

I just don't recommend ever using std::reference_wrapper aside from template cases where it is used to tell the difference whether user wants to forward a copy or a reference to the object.

If you want a reference imitating class that performs an assign/move-through rather than rebind that's up to you to implement. Just you should be aware that it can be problematic in certain situations.

Also don't ever write any kind of

namespace std
{
    void swap(std::reference_wrapper<int>& a, std::reference_wrapper<int>& b) noexcept
    {
        std::swap(a.get(), b.get());
    }
}

It might break a lot of code that you import.