Start thread with member function

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

EDIT:
Accounting your edit, you have to do it like this:

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

UPDATE: I want to explain some more points, some of them have also been discussed in the comments.

The syntax described above is defined in terms of the INVOKE definition (ยง20.8.2.1):

Define INVOKE (f, t1, t2, …, tN) as follows:

  • (t1.*f)(t2, …, tN) when f is a pointer to a member function of a class T and t1 is an object of type T or a reference to an object of
    type T or a reference to an object of a type derived from T;
  • ((*t1).*f)(t2, …, tN) when f is a pointer to a member function of a class T and t1 is not one of the types described in the previous
    item;
  • t1.*f when N == 1 and f is a pointer to member data of a class T and t 1 is an object of type T or a
    reference to an object of type T or a reference to an object of a
    type derived from T;
  • (*t1).*f when N == 1 and f is a pointer to member data of a class T and t 1 is not one of the types described in the previous item;
  • f(t1, t2, …, tN) in all other cases.

Another general fact which I want to point out is that by default the thread constructor will copy all arguments passed to it. The reason for this is that the arguments may need to outlive the calling thread, copying the arguments guarantees that. Instead, if you want to really pass a reference, you can use a std::reference_wrapper created by std::ref.

std::thread (foo, std::ref(arg1));

By doing this, you are promising that you will take care of guaranteeing that the arguments will still exist when the thread operates on them.

Note that all the things mentioned above can also be applied to std::async and std::bind.

More Related Contents:

  1. C++11 introduced a standardized memory model. What does it mean? And how is it going to affect C++ programming?
  2. Concurrency: Atomic and volatile in C++11 memory model
  3. What happens to a detached thread when main() exits?
  4. Passing object by reference to std::thread in C++11
  5. What are the correct link options to use std::thread in GCC under linux?
  6. Why is the destructor of a future returned from `std::async` blocking?
  7. Does MinGW-w64 support std::thread out of the box when using the Win32 threading model?
  8. C++11 thread-safe queue
  9. How to implement multithread safe singleton in C++11 without using
  10. Difference between pointer and reference as thread parameter
  11. How to use std::async on a member function?
  12. Which std::async implementations use thread pools?
  13. C++0x thread interruption
  14. How can I use something like std::vector?
  15. What is the difference between packaged_task and async
  16. Get the status of a std::future
  17. Delayed start of a thread in C++ 11
  18. Is it smart to replace boost::thread and boost::mutex with c++11 equivalents?
  19. C++11 STL containers and thread safety
  20. Can I use std::async without waiting for the future limitation?
  21. C++ terminate called without an active exception
  22. What is different between join() and detach() for multi threading in C++?
  23. std::thread error (thread not member of std)
  24. C++11 std::threads vs posix threads
  25. Understanding std::atomic::compare_exchange_weak() in C++11
  26. Double-Checked Lock Singleton in C++11
  27. C++11 Implementation of Spinlock using header “
  28. std::thread calling method of class [duplicate]
  29. Write concurrently vector
  30. About thread-safety of weak_ptr

Leave a Comment