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 des tuples ou des modèles de type de données) sont utilisées uniquement si il est impossible d'expliquer std::ref
sans eux.
J'ai trouvé deux questions sur std::ref
ici et ici . Mais dans le premier il s'agit d'un bug dans un compilateur et dans le second, des exemples d'utilisation de std::ref
ne contient pas std::ref
et ils impliquent des tuples et des modèles de types de données qui rendent la compréhension de ces exemples complexe.
Vous devriez penser à utiliser std::ref
lorsqu'une fonction:
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 utilise de manière démontrable 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;
}
Production:
0
1
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
est principalement utilisé pour encapsuler les références lors de l'utilisation de std::bind
(mais d'autres utilisations sont bien sûr possibles).
Un autre endroit où vous pouvez avoir besoin de std :: ref est lors du passage d'objets à des threads où vous souhaitez que chaque thread opère sur l'objet unique et non sur une copie de l'objet.
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 diverses fonctions s'exécutant dans différents threads partagent un seul objet tampon. Cet exemple a été volé dans cet excellent tutoriel ( Tutoriel de concurrence C++ 11 - Partie 3: Variables avancées de verrouillage et de condition (Baptiste Wicht) ) (j'espère que j'ai fait l'attribution correctement)
// Problème des consommateurs producteurs
#include <iostream>
#include <thread>
#include <mutex>
#include <deque>
#include <condition_variable>
using namespace std;
class Buffer {
std::mutex m;
std::condition_variable cv;
std::deque<int> queue;
const unsigned long size = 1000;
public:
void addNum(int num) {
std::unique_lock<std::mutex> lock(m);
cv.wait(lock, [this]() { return queue.size() <= size; });
queue.Push_back(num);
cout << "Pushed " << num << endl;
lock.unlock();
cv.notify_all();
}
int removeNum() {
std::unique_lock<std::mutex> lock(m);
cv.wait(lock, [this]() { return queue.size()>0; });
int num = queue.back();
queue.pop_back();
cout << "Poped " << num << endl;
lock.unlock();
cv.notify_all();
return num;
}
};
void producer(int val, Buffer& buf) {
for(int i=0; i<val; ++i){
buf.addNum(i);
}
}
void consumer(int val, Buffer& buf){
for(int i=0; i<val; ++i){
buf.removeNum();
}
}
int main() {
Buffer b;
std::thread t1(producer, 1000, std::ref(b));
std::thread t2(consumer, 1000, std::ref(b));
t1.join();
t2.join();
return 0;
}
Juste une autre utilisation de std :: ref dans main en passant l'objet Buffer
comme référence dans le producteur et le consommateur. Si std::ref
non utilisé alors ce code ne sera pas compilé.