c++ - ¿Qué sería un ejemplo de "Hello, World!" Para "std:: ref"?

c++11

Question

¿Alguien puede dar un ejemplo simple que demuestre la funcionalidad de std::ref ? Me refiero a un ejemplo en el que algunas otras construcciones (como tuplas o plantillas de tipos de datos) se usan solo si es imposible explicar std::ref sin ellas.

Encontré dos preguntas sobre std::ref here y here . Pero en el primero se trata de un error en un compilador y en el segundo, los ejemplos de uso de std::ref no contienen std::ref e implican tuplas y plantillas de tipos de datos que hacen que la comprensión de estos ejemplos sea compleja.

Answer 1

Deberías pensar en usar en.cppreference.com/w/cpp/utility/functional/ref cuando una función:

• toma un parámetro de plantilla por valor
• o copia / mueve un parámetro de referencia de reenvío , como std::bind o el constructor para std::thread .

std::ref es un tipo de valor que se comporta como una referencia.

Este ejemplo hace uso demostrable de std::ref .

#include <iostream>
#include <functional>

void increment( int &x )
{
  ++x;
}

int main()
{
  int i = 0;

  // Here, we bind increment to (a copy of) i...
  std::bind( increment, i ) ();
  //                        ^^ (...and invoke the resulting function object)

  // i is still 0, because the copy was incremented.
  std::cout << i << std::endl;

  // Now, we bind increment to std::ref(i)
  std::bind( increment, std::ref(i) ) ();

  // i has now been incremented.
  std::cout << i << std::endl;
}

Salida:

0
1

Answer 2

Otro lugar donde puede necesitar std :: ref es cuando pasa objetos a hilos en los que desea que cada hilo funcione en el objeto individual y no una copia del objeto.

int main(){
BoundedBuffer buffer(200);

std::thread c1(consumer, 0, std::ref(buffer));
std::thread c2(consumer, 1, std::ref(buffer));
std::thread c3(consumer, 2, std::ref(buffer));
std::thread p1(producer, 0, std::ref(buffer));
std::thread p2(producer, 1, std::ref(buffer));

c1.join();
c2.join();
c3.join();
p1.join();
p2.join();

return 0; }

donde desea que varias funciones se ejecuten en varios subprocesos para compartir un solo objeto de búfer. Este ejemplo fue robado de este excelente tutorial ( Tutorial de Concurrencia en C ++ 11 - Parte 3: variables de condición y bloqueo avanzado (Baptiste Wicht) ) (espero haber hecho la atribución correctamente)

Answer 3

void PrintNumber(int i) {...}

int n = 4;
std::function<void()> print1 = std::bind(&PrintNumber, n);
std::function<void()> print2 = std::bind(&PrintNumber, std::ref(n));

n = 5;

print1(); //prints 4
print2(); //prints 5

std::ref se usa principalmente para encapsular referencias cuando se usa std::bind (pero otros usos son posibles, por supuesto).