std :: reference_wrapper和简单指针之间的区别？

为什么需要有std::reference_wrapper？应该在哪里使用？它与简单指针有何不同？与简单指针相比，它的性能如何？

std::reference_wrapper与模板结合使用非常有用。它通过存储指向对象的指针来包装对象，从而在模仿其通常语义的同时允许重新分配和复制。它还指示某些库模板存储引用而不是对象。

考虑STL中复制函子的算法：您可以通过简单地传递引用函子而不是函子本身的引用包装器来避免该复制：

unsigned arr[10];
std::mt19937 myEngine;
std::generate_n( arr, 10, std::ref(myEngine) ); // Modifies myEngine's state

之所以有效，是因为...

• … reference_wrapper的重载，operator()因此可以像它们所引用的函数对象一样调用它们：

  std::ref(myEngine)() // Valid expression, modifies myEngines state

• …（与普通引用不同），复制（和分配）reference_wrappers只是分配pointee。

  int i, j;
  auto r = std::ref(i); // r refers to i
  r = std::ref(j); // Okay; r refers to j
  r = std::cref(j); // Error: Cannot bind reference_wrapper<int> to <const int>

复制一个引用包装实际上等同于复制一个指针，因为它便宜。使用它时固有的所有函数调用（例如to的函数operator()）都应该内联，因为它们是一线的。

reference_wrapper通过std::ref和std::cref创建：

int i;
auto r = std::ref(i); // r is of type std::reference_wrapper<int>
auto r2 = std::cref(i); // r is of type std::reference_wrapper<const int>

template参数指定所引用对象的类型和cv-qualification；r2引用，const int并且只会引用const int。调用包含const函子的引用包装器将仅调用const成员函数operator()s。

Rvalue初始化程序是不允许的，因为允许它们做弊大于利。由于右值将始终被移动（并且即使有部分避免，也可以保证复制省略），因此我们不会改善语义。不过，我们可以引入悬空指针，因为引用包装器不会延长指针的寿命。

图书馆互动

如前所述，可以通过将相应的参数传递make_tuple给a 来指示在结果中存储引用：tuplereference_wrapper

int i;
auto t1 = std::make_tuple(i); // Copies i. Type of t1 is tuple<int>
auto t2 = std::make_tuple(std::ref(i)); // Saves a reference to i.
                                        // Type of t2 is tuple<int&>

请注意，这与forward_as_tuple：略有不同。此处，不允许将rvalues作为参数。

std::bind显示相同的行为：如果是，它不会复制参数，但会存储引用reference_wrapper。如果不需要复制该参数（或函子！），但在bind使用-functor时仍在作用域内，则很有用。

与普通指针的区别

• 没有附加的语法间接级别。必须取消引用指针才能获得指向它们所引用对象的左值；reference_wrapper具有隐式转换运算符，可以像它们包装的对象一样调用。

  int i;
  int& ref = std::ref(i); // Okay

• reference_wrapper与指针不同，s不具有空状态。必须使用引用或另一个reference_wrapper来初始化它们。

  std::reference_wrapper<int> r; // Invalid

• 浅表复制语义是相似的：指针和reference_wrappers可以重新分配。

至少有两个激励目的std::reference_wrapper<T>：

1. 它是为作为值参数传递给功能模板的对象提供参考语义。例如，您可能要传递一个大型函数对象std::for_each()，该函数对象按值获取其函数对象参数。为避免复制对象，可以使用

   std::for_each(begin, end, std::ref(fun));

   将参数传递std::reference_wrapper<T>给std::bind()表达式是很普遍的做法，即通过引用而不是通过值来绑定参数。

2. 当std::reference_wrapper<T>与std::make_tuple()对应的元组元素一起使用时，T&而不是T：

   T object;
   f(std::make_tuple(1, std::ref(object)));

就自文档代码而言，另一个不同之处是，使用reference_wrapper本质上不赞成该对象的所有权。相比之下，unique_ptr断言是所有权，而裸指针可能或可能不拥有（不查看大量相关代码就无法知道）：

vector<int*> a;                    // the int values might or might not be owned
vector<unique_ptr<int>> b;         // the int values are definitely owned
vector<reference_wrapper<int>> c;  // the int values are definitely not owned

您可以将其视为引用周围的便利包装，以便可以在容器中使用它们。

std::vector<std::reference_wrapper<T>> vec; // OK - does what you want
std::vector<T&> vec2; // Nope! Will not compile

基本上是的CopyAssignable版本T&。任何时候您都需要引用，但它必须是可分配的，请使用std::reference_wrapper<T>或其辅助功能std::ref()。或使用指针。

其他怪癖sizeof：

sizeof(std::reference_wrapper<T>) == sizeof(T*) // so 8 on a 64-bit box
sizeof(T&) == sizeof(T) // so, e.g., sizeof(vector<int>&) == 24

并比较：

int i = 42;
assert(std::ref(i) == std::ref(i)); // ok

std::string s = "hello";
assert(std::ref(s) == std::ref(s)); // compile error