构造线程时调用的运算符重载函数

Question

Lately, I came across with this code as part of studying threading , and there is a part which I can't understand.
here is the code:

#include <iostream>
#include <thread>

void foo() { std::cout << "foo()\n"; }
void bar() { std::cout << "bar()\n"; }

class task
{
 public:
     task() { cout << "task constructor\n"; }

     void operator()() const
     {
        cout << "operator()\n";
        foo();
        bar();
     }
};

int main()
{
   task tsk;
   std::thread t(tsk);
   t.join();
   return 0;
}

the part I didn't understand was after creating "tsk" object. when constructing the "t" thread std::thread t(tsk);
the operator overload function was called .
I didn't understand why the operator overloading "()" was called and when this happened.
I will be really greatful if anyone can explain me this stuff.

Answer 1

std::thread takes a callable object to execute. When you overload operator()() , you are making your task object callable.

Example:

tsk();
// Output
task constructor
operator()
foo()
bar()

Remove your definition of operator()() ...

tsk();
// Output
error: type 'task' does not provide a call operator

std::thread t(tsk); won't even compile unless task is a callable object.

If you're asking why it behaves this way, we take a look to n3376 (C++11 draft standard) [thread.thread.constr]. The constructor std::thread t(tsk); is calling is:

template< class Function, class... Args >
explicit thread( Function&& f, Args&&... args );

This constructor executes INVOKE(DECAY_COPY( std::forward<F>(f)), DECAY_COPY(std::forward<Args>(args))...) . In other words, it calls f(arg1, arg2, arg3...) .

If you want unofficial documentation that says it better than I do, try cppreference .