Quel serait un “Bonjour, Monde!” Exemple pour “std :: ref”?

Quelqu’un peut-il donner un exemple simple qui démontre la fonctionnalité de std::ref ? Je veux dire un exemple dans lequel d’autres constructions (comme les tuples ou les modèles de type de données) ne sont utilisées que s’il est impossible d’expliquer std::ref sans elles.

J’ai trouvé deux questions sur std::ref ici et ici . Mais dans le premier, il s’agit d’un bogue dans un compilateur et dans le second, les exemples d’utilisation de std::ref ne contiennent pas std::ref et impliquent des modèles de type tuples et de données qui rendent complexe la compréhension de ces exemples.

Vous devriez penser à utiliser std::ref quand une fonction:

  • prend un paramètre de modèle par valeur
  • ou copie / déplace un paramètre de référence de transfert , tel que std::bind ou le constructeur de std::thread .

std::ref est un type de valeur qui se comporte comme une référence.

Cet exemple fait usage de std::ref .

 #include  #include  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; } 

Sortie:

 0 1 
 void PrintNumber(int i) {...} int n = 4; std::function print1 = std::bind(&PrintNumber, n); std::function print2 = std::bind(&PrintNumber, std::ref(n)); n = 5; print1(); //prints 4 print2(); //prints 5 

std::ref est principalement utilisé pour encapsuler des références lors de l’utilisation de std::bind (mais d’autres utilisations sont possibles bien sûr).

Un autre endroit où vous pouvez avoir besoin de std :: ref est de passer des objects aux threads où vous voulez que chaque thread opère sur un seul object et non sur une copie de l’object.

 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; } 

où vous souhaitez que différentes fonctions s’exécutent dans différents threads pour partager un seul object tampon. Cet exemple a été volé dans cet excellent didacticiel ( Didacticiel sur la concurrence C ++ 11 – Partie 3: Variables de locking et de condition avancées (Baptiste Wicht) ) (espérons que l’atsortingbution est correcte)