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

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

• ...(un)как обычные ссылки, копирование (и назначение) 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_wrappers создаются через 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 будет перемещен в любом случае (и с гарантированная копия elision даже этого частично избегают), мы не улучшаем семантику; мы можем ввести висячие указатели, хотя, поскольку ссылочная оболочка не продлевает срок службы указателя.

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

Как упоминалось ранее, можно поручить 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-используется функтор.

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

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

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

• reference_wrappers, в отличие от указателей, не имеют нулевого состояния. Они должны быть инициализированы с помощью либо ссылку или еще reference_wrapper.

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

• сходство-это мелкая семантика копирования: указатели и reference_wrappers можно переназначить.