class A
{
public:
A();
~A();
A(int, int);
void operator()(int a,int b) {
cout <<"called by operator()(int a,int b):" <<a * 10<<"\t" << b * 10 << endl;
}
private:
};
A::A()
{
}
A::~A()
{
}
A::A(int a, int b) {
cout << "called by A::A(int a, int b):" << a << "\t" << b<<endl;
}
int main()
{
A t(1, 2);
t(4, 5);
system("pause");
return 0;
}
測試時雖然構造函數和重載操作符()形似,但調用時機不同 不產生衝突
Stackoverflow裏面有個回答
Functionality of void operator()()
http://stackoverflow.com/questions/11857150/functionality-of-void-operator/11857220
I am confused about the functionality of void
operator()()
.
Could you tell me about that, for instance:
class background_task
{
public:
void operator()() const
{
do_something();
do_something_else();
}
};
background_task f;
std::thread my_thread(f);
Here, why we need operator()()
?
What is the meaning of the first and second ()
?
Actually, I know the operation of normal operator, but this operator is confusing.
14
|
The first Here's an example of how you would use it:
|
||
18
|
You can overload the
So the first parentheses are always empty: this is the name of the function:
So to call this operator in your particular case you would do something like |
||||||||||||||||
|
5
|
The first part With a return value and arguments this might make a bit more sense:
In this context, the |
14
|
The first Here's an example of how you would use it:
|
||||||||||||
|
18
|
You can overload the
So the first parentheses are always empty: this is the name of the function:
So to call this operator in your particular case you would do something like |
||||||||||||||||
|
5
|
The first part With a return value and arguments this might make a bit more sense:
In this context, the |
All the hints that were contributed above are correct to sequential programs, I mean, programs without threads. Using threads things change. First of all, by default parameters to std::thread are functions and functions parameters. Probably you were studying the book "C++ concurrency in action", and the author shows an interesting example:
void do_some_work();
thread my_thread(do_some_work); //thread receives the function address
Suppose this function:
void do_other_job(int k); In the body of the code, you should do:
k=3;
thread my_thread2(do_other_job, k);
in order to spawn another thread.
So, using threads the compiler interprets f ( in std::thread my_thread(f);) by default as a function instead of a class. To change that you have to initiate an operator() to warn the compiler you are working with a class. An alternative code could be:
class background_task{
public:
background_task(){
do_sth();
do_sth_else();
}
void operator()(){}
};
background_task f;
thread mythread10(f);
Eventually, it's not correct, using threads, feeding the operator, so this code doesn't work:
void operator()(int x){
do_sth();
cout<<"x = "<<x<<endl;
}
It happens because all the code inside the brackets are read-only, and cannot be changed during the run-time. If you aim to insert a variable in the constructor, it must be put in the thread initialization. So:
class backg{
public:
backg(int i){
do_sth(i);
}
void operator()(){}
};
int main(){
thread mythread{ backg(12) }; //using c++11
return 0;
}
Will run without mistakes, and will perform the function do_sth(12) in the thread spawned.
I hope I have helped.
14
|
The first Here's an example of how you would use it:
|
||||||||||||
|
18
|
You can overload the
So the first parentheses are always empty: this is the name of the function:
So to call this operator in your particular case you would do something like |
||||||||||||||||
|
5
|
The first part With a return value and arguments this might make a bit more sense:
In this context, the |
task.operator()()
syntax as well. There are many standard algorithms that will call this operator internally. – Mark Ransom Aug 8 '12 at 13:10