Разница между 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_wrappers overload operator(), чтобы их можно было вызывать точно так же, как объекты функций, на которые они ссылаются к:

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

• … (Не) как обычные ссылки, копирование (и присвоение) reference_wrappers просто присваивает указатель.

  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>
  

Копирование ссылочной оболочки практически эквивалентно копированию указателя, которое настолько дешево, насколько это возможно. Все вызовы функций, связанные с его использованием (например, те, которые используются для 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>

Аргумент шаблона определяет тип и cv-квалификацию объекта, на который имеется ссылка; r2 относится к const int и дает только ссылку на const int. Вызовы ссылочных оболочек с const функторами в них будут вызывать только const функцию-член operator()s.

Инициализаторы Rvalue запрещены, поскольку их разрешение принесет больше вреда, чем пользы. Поскольку rvalues ​​все равно будут перемещены (и с гарантированным исключением копии даже этого частично удалось избежать), мы не улучшаем семантику; мы можем ввести висячие указатели, поскольку оболочка ссылок не продлевает время жизни указателя.

Взаимодействие с библиотекой

Как упоминалось ранее, можно указать make_tuple сохранить ссылку в результирующем tuple, передав соответствующий аргумент через reference_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-функтор.

Отличие от обычных указателей

• Дополнительного уровня синтаксической косвенности нет. Указатели должны быть разыменованы, чтобы получить l-значение для объекта, на который они ссылаются; reference_wrappers имеют неявный оператор преобразования и могут вызываться как объект, который они обертывают.

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

• reference_wrappers, в отличие от указателей, не имеют нулевого состояния. Они должны быть инициализированы с помощью ссылки или другого 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