sintaks - C++11 thread memanggil fungsi ahli objek

Question

Jika anda menggugurkan fungsi ahli kelas, ia mungkin seperti ini.

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

Tetapi bagaimana jika anda mahu objek khusus kelas ini melaksanakan operasi ini?

Answer 1

std::thread memanggil fungsi ahli kelas dan perlu menghantar objek kelas sebagai parameter:

#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();
}

Jika anda sedang memproses benang dalam fungsi ahli kelas, hanya lulus dalam ini, seperti:

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

Rujukan: stackoverflow

Answer 2

参考C tambah tambah

Parameter
fn
Penuding kepada fungsi, penuding kepada ahli, atau apa-apa jenis objek fungsi yang boleh dibina bergerak (iaitu, objek yang kelasnya
mentakrif operator(), termasuk penutupan dan objek fungsi).
Nilai pulangan (jika ada) diabaikan.
args...
Hujah yang dihantar kepada panggilan ke fn (jika ada). Jenis mereka hendaklah boleh digerakkan. Jika fn ialah penunjuk ahli, hujah pertama hendaklah objek yang ahli itu ditakrifkan atau rujukan, atau penunjuk kepadanya).
x
objek benang yang keadaannya dialihkan ke objek yang dibina.

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