C++ std::ref(T) 和 T& 之间的区别？

Question

我对此计划有一些疑问：

#include <iostream>
#include <type_traits>
#include <functional>
using namespace std;
template <typename T> void foo ( T x )
{
    auto r=ref(x);
    cout<<boolalpha;
    cout<<is_same<T&,decltype(r)>::value;
}
int main()
{
    int x=5;
    foo (x);
    return 0;
}

输出是：

false

我想知道，如果std::ref 不返回对象的引用，那它有什么作用呢？基本上，两者有什么区别：

T x;
auto r = ref(x);

和

T x;
T &y = x;

另外，我想知道为什么会存在这种差异？当我们有引用（即T&）时，为什么我们需要std::ref 或std::reference_wrapper？

Answer 1

ref 构造了一个适当的reference_wrapper 类型的对象来保存对对象的引用。这意味着当您申请时：

auto r = ref(x);

这会返回一个reference_wrapper 而不是对x 的直接引用（即T&）。这个reference_wrapper（即r）持有T&。

reference_wrapper 在您想模拟可以复制的对象的 reference 时非常有用（它既是 copy-constructible 也是 copy-assignable)。

在 C++ 中，一旦您创建了对对象（例如 x）的引用（例如 y），那么 y 和 x 将共享相同的基地址。此外，y 不能引用任何其他对象。你也不能创建一个引用数组，即这样的代码会抛出一个错误：

#include <iostream>
using namespace std;

int main()
{
    int x=5, y=7, z=8;
    int& arr[] {x,y,z};    // error: declaration of 'arr' as array of references
    return 0;
}

不过这是合法的：

#include <iostream>
#include <functional>  // for reference_wrapper
using namespace std;

int main()
{
    int x=5, y=7, z=8;
    reference_wrapper<int> arr[] {x,y,z};
    for (auto a: arr)
        cout << a << " ";
    return 0;
}
/* OUTPUT:
5 7 8
*/

说说你对cout << is_same<T&,decltype(r)>::value;的问题，解决方法是：

cout << is_same<T&,decltype(r.get())>::value;  // will yield true

让我给你看一个程序：

#include <iostream>
#include <type_traits>
#include <functional>
using namespace std;

int main()
{
    cout << boolalpha;
    int x=5, y=7;
    reference_wrapper<int> r=x;   // or auto r = ref(x);
    cout << is_same<int&, decltype(r.get())>::value << "\n";
    cout << (&x==&r.get()) << "\n";
    r=y;
    cout << (&y==&r.get()) << "\n";
    r.get()=70;
    cout << y;
    return 0;
}
/* Ouput:
true
true
true
70
*/

看这里我们了解三件事：

1. reference_wrapper 对象（此处为 r）可用于创建 引用数组，这在 T& 中是不可能的。

2. r 实际上就像一个真正的引用（查看r.get()=70 如何更改y 的值）。

3. r 与 T& 不同，但 r.get() 不同。这意味着r 拥有T&，即顾名思义是一个引用的包装 T&。

我希望这个答案足以解释你的疑惑。

Answer 2

std::reference_wrapper 被标准设施识别为能够在按值传递的上下文中通过引用传递对象。

例如，std::bind 可以将std::ref() 接收到某物，按值传输它，然后将其解包回引用。

void print(int i) {
    std::cout << i << '\n';
}

int main() {
    int i = 10;

    auto f1 = std::bind(print, i);
    auto f2 = std::bind(print, std::ref(i));

    i = 20;

    f1();
    f2();
}

这个 sn-p 输出：

10
20

i 的值在初始化时已存储（按值获取）到f1，但f2 按值保留了std::reference_wrapper，因此其行为就像接收了@ 987654330@.

Answer 3

引用（T& 或 T&&）是 C++ 语言中的特殊元素。它允许通过引用操作对象，并且在语言中有特殊的用例。例如，您不能创建标准容器来保存引用：vector<T&> 格式错误并生成编译错误。

另一方面，std::reference_wrapper 是一个能够保存引用的 C++ 对象。因此，您可以在标准容器中使用它。

std::ref 是一个标准函数，它在其参数上返回 std::reference_wrapper。同样的想法，std::cref 将 std::reference_wrapper 返回到 const 引用。

std::reference_wrapper 的一个有趣属性是它有一个operator T& () const noexcept;。这意味着即使它是一个真正的对象，它也可以自动转换为它所持有的引用。所以：

• 因为它是一个可复制的可赋值对象，所以它可以在容器中或其他不允许引用的情况下使用
• 感谢它的operator T& () const noexcept;，它可以在任何可以使用引用的地方使用，因为它会自动转换为它。