syntax - C++11 thread calls member function of object

Question

If you drop a member function of a class, it's probably like this.

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

But if you want a specific object of this class to perform this operation, how to deal with it?

Answer 1

std::thread calls a member function of a class and needs to pass an object of the class as a 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();
}

If you are processing thread in the member function of the class, just pass in this, such as:

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

Reference: stackoverflow

Answer 2

参考C plus plus

Parameters
fn
A pointer to function, pointer to member, or any kind of move-constructible function object (i.e., an object whose class
defines operator(), including closures and function objects). The
return value (if any) is ignored.
args...
Arguments passed to the call to fn (if any). Their types shall be move-constructible. If fn is a member pointer, the first argument shall be an object for which that member is defined or a reference, or a pointer to it).
x
thread object whose state is moved to the constructed object.

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