Diferencia entre boost :: ref y referencias regulares

Question

¿Cuál es la diferencia entre boost::ref(i) y & i? ¿Cuáles son las situaciones en las que no podemos usar referencias regulares y tenemos que ir por boost::ref en su lugar? Por favor incluya ejemplos si es posible.

Answer 1

Desde el Boost.Ref Documentation:

El propósito de impulso :: reference_wrapper es contienen una referencia a un objeto de tipo T. Se utiliza principalmente para "alimentar" referencias para funcionar plantillas (algoritmos) que toman su parámetro por valor.

NB: Una diferencia importante entre boost::reference_wrapper y std::reference_wrapper (al menos de Boost 1.52) es la capacidad de std::reference_wrapper para envolver perfectamente objetos de función.

Esto permite código como este:

// functor that counts how often it was applied 
struct counting_plus { 
    counting_plus() : applications(0) {} 
    int applications; 

    int operator()(const int& x, const int& y) 
    { ++applications; return x + y; } 
}; 

std::vector<int> x = {1, 2, 3}, y = {1, 2, 3}, result; 
counting_plus f; 
std::transform(begin(x), end(x), begin(y), 
       std::back_inserter(result), std::ref(f)); 
std::cout << "counting_plus has been applied " << f.applications 
      << " times." << '\n'; 

Answer 2

En Boost.Thread por ejemplo:

un nuevo hilo es lanzado por pasar un objeto de un tipo exigible que puede ser invoca sin parámetros al constructor . El objeto se copia en el almacenamiento interno, y se invoca en el hilo de ejecución recién creado. Si el objeto no debe (o no puede) ser copiado, entonces boost :: ref puede usarse para pasar en una referencia al objeto de la función . En este caso, el usuario de Boost.Thread debe asegurarse de que el objeto referido supera al subproceso recién creado de ejecución.

Código del documento:

struct callable 
{ 
    void operator()(); 
}; 

boost::thread copies_are_safe() 
{ 
    callable x; 
    return boost::thread(x); 
} // x is destroyed, but the newly-created thread has a copy, so this is OK 

boost::thread oops() 
{ 
    callable x; 
    return boost::thread(boost::ref(x)); 
} // x is destroyed, but the newly-created thread still has a reference 
    // this leads to undefined behaviour