C ++中的operator（）（）有什么作用？

Question

I'm new to C++11 thread , when reading a tutorial , I see a piece of code like this.

 #include <thread>
 #include <iostream>
 using namespace std;

 class background_task
 {
  public:
     void operator()() const
     {
         cout<<"This is a new thread";
     }
 };

int main()
{
   background_task f;
   std::thread my_thread(f);
   my_thread.join();
}

The output will be "This is new thread", but i don' really understand what does the function "operator()() const" mean?. In this case, it acts really the same with the constructor, is it right?.

And how can C++ have a syntax like that? I have search about related topic by using the search engine but no found no result.

Thanks in advanced.

Answer 1

void operator()() means an instance of the class with that operator can be called with function call syntax, with no return value, and without any parameters. For example:

background_task b;

b(); // prints "This is a new thread"

The operator() part indicates it is a call operator, the second set of empty parentheses () indicate the operator has no parameters. Here is an example with two parameters and a return value:

struct add
{
  int operator()(int a, int b) const { return a + b; }
};

add a;
int c = a(1, 2); // c initialized to 1+2

Note that this syntax pre-dates C++11. You can create callable types (also referred to as functors ) in C++03. The connection with C++11 is that the std::thread constructor expects something that can be called without arguments . This could be a plain function

void foo() {}

a static member function

struct foo {
  static void bar() {}
};

an instance of a type such as background_task , a suitable lambda expression, a suitable invocation of std::bind , in short, anything that can be called without arguments.

Answer 2

It's just operator overloading and has nothing to do with C++11 or multi-threading. An overloaded operator is just a normal function with a funny name (this may be a bit oversimplified, but it's a good rule of thumb for beginners).

Your class has a function named () . That's all. Technically , you could as well have named the function foo or f or TwoParentheses .

Consider a simpler example:

#include <iostream>

class Example
{
public:
    void operator()() { std::cout << "()"; }
    void foo() { std::cout << "foo"; }
    void TwoParentheses() { std::cout << "TwoParentheses"; }
};

int main()
{
    Example e;
    e.operator()();
    e.foo();
    e.TwoParentheses();
}

Now calling an overloaded operator like in this example in main , spelling out the entire .operator() part, is pretty pointless, because an overloaded operator's purpose is to make the calling code simpler. You would instead invoke your function like this:

int main()
{
    Example e;
    e();
}

As you can see, e(); now looks exactly as if you called a function.

This is why operator() is a special name, after all. In a template , you can handle objects with operator() and function pointers with the same syntax .

Consider this:

#include <iostream>

class Example
{
 public:
    void operator()() { std::cout << "Example.operator()\n"; }
};

void function() { std::cout << "Function\n"; }

template <class Operation>
void t(Operation o)
{
    o(); // operator() or "real" function
}

int main()
{
    Example object;
    t(object);
    t(function);
}

This is the reason why operator() is an important function in C++ generic programming, and is often required.

Answer 3

It has nothing to do with C++11, it's the function call overload operator. That means if you have a class like yours, you can create an instance of it and use as a function:

int main()
{
    background_task bt;
    bt();
}

The above main function should give the same result as your simple thread example.

Answer 4

it is operator over loading. the user provide an additional use to () operator. Example for static polymorphism. it is fearture of Object orieted program