Różnica między boost :: ref i regularnymi referencjami

Question

Jaka jest różnica między boost::ref(i) i & i? W jakich sytuacjach nie możemy używać zwykłych referencji i zamiast tego musimy przejść na numer boost::ref? Podaj przykłady, jeśli to możliwe.

Answer 1

Z Boost.Ref Documentation:

Celem boost :: reference_wrapper jest zawierają odniesienie do obiektu typu T. Jest wykorzystywany przede wszystkim do „karmić” referencje funkcjonować szablony (algorytmy), które przyjmują swój parametr według wartości.

Uwaga: Istotna różnica między boost::reference_wrapper i std::reference_wrapper (przynajmniej uwypuklenia 1,52) jest zdolność std::reference_wrapper doskonale owinąć obiektów funkcyjnych.

Umożliwia kodu:

// 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

W Boost.Thread na przykład:

nowy gwint jest uruchamiany przez przekazanie obiektu z żądanie w rodzaju, który może być wywoływane bez parametrów do konstruktora . Obiekt jest następnie kopiowany do pamięci wewnętrznej i wywoływany na nowo utworzony wątek wykonania. Jeśli obiekt nie może być (lub nie może) być skopiowany, to , następnie doładowanie :: ref może być użyte do przekazania obiektu referencyjnego do obiektu . W takim przypadku użytkownik obiektu Boost.Thread musi upewnić się, że określony obiekt o numerze przeżyje nowo utworzony wątek wykonania.

Kod z doc:

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