syntax - Le thread C++11 appelle la fonction membre de l'objet

Question

Si vous supprimez une fonction membre d’une classe, c’est probablement comme ça.

clientThread = std::thread(&Client::sendMessage,“message”);

Mais que se passe-t-il si vous souhaitez qu'un objet spécifique de cette classe effectue cette opération ?

Answer 1

std::thread appelle une fonction membre d'une classe et doit passer un objet de la classe en paramètre :

#include <thread>
#include <iostream>

class bar {
public:
  void foo() {
    std::cout << "hello from member function" << std::endl;
  }
};

int main()
{
  std::thread t(&bar::foo, bar());
  t.join();
}

Si vous traitez un thread dans la fonction membre de la classe, transmettez simplement ceci, par exemple :

std::thread spawn() {
    return std::thread(&blub::test, this);
  }

Référence : stackoverflow

Answer 2

参考C plus plus

Paramètres
fn
Un pointeur vers une fonction, un pointeur vers un membre ou tout type d'objet fonction constructible par déplacement (c'est-à-dire un objet dont la classe
définit l'opérateur(), y compris les fermetures et les objets fonction). La
valeur de retour (le cas échéant) est ignorée.
args...
Arguments transmis à l'appel à fn (le cas échéant). Leurs types doivent être constructibles. Si fn est un pointeur de membre, le premier argument doit être un objet pour lequel ce membre est défini ou une référence, ou un pointeur vers celui-ci).
x
objet thread dont l'état est déplacé vers l'objet construit.

// constructing threads
#include <iostream>       // std::cout
#include <atomic>         // std::atomic
#include <thread>         // std::thread
#include <vector>         // std::vector

std::atomic<int> global_counter (0);

void increase_global (int n) { for (int i=0; i<n; ++i) ++global_counter; }

void increase_reference (std::atomic<int>& variable, int n) { for (int i=0; i<n; ++i) ++variable; }

struct C : std::atomic<int> {
  C() : std::atomic<int>(0) {}
  void increase_member (int n) { for (int i=0; i<n; ++i) fetch_add(1); }
};

int main ()
{
  std::vector<std::thread> threads;

  std::cout << "increase global counter with 10 threads...\n";
  for (int i=1; i<=10; ++i)
    threads.push_back(std::thread(increase_global,1000));

  std::cout << "increase counter (foo) with 10 threads using reference...\n";
  std::atomic<int> foo(0);
  for (int i=1; i<=10; ++i)
    threads.push_back(std::thread(increase_reference,std::ref(foo),1000));

  std::cout << "increase counter (bar) with 10 threads using member...\n";
  C bar;
  for (int i=1; i<=10; ++i)
    threads.push_back(std::thread(&C::increase_member,std::ref(bar),1000));

  std::cout << "synchronizing all threads...\n";
  for (auto& th : threads) th.join();

  std::cout << "global_counter: " << global_counter << '\n';
  std::cout << "foo: " << foo << '\n';
  std::cout << "bar: " << bar << '\n';

  return 0;
}

类似这样 std::thread(&C::increase_member,std::ref(bar),1000)