Re: Threads and copy constructors...
Am 20.02.2012 20:33, schrieb Peter Remmers:
Am 18.02.2012 01:21, schrieb oneflewover:
In the code snippet below, I have one functor that I pass to one
thread. As expected, the constructor is called once, but the copy
constructor is called four times! As a result, the destructor is
called five times.
Can someone please explain to me why the copy constructor is called
four times? Thanks.
===================================================
class c1
{
public:
c1() { }
c1(const c1& c) { }
void operator()() { }
~c1() { }
};
int main()
{
c1 c; // constructor called once here
//
// copy constructor called four times here; why?
//
boost::thread t1( c1 );
boost::thread t1( boost::cref(c1) );
I was too quick. After a second reading, I noticed that you use c1 as a
thread functor. boost::cref is good for passing const references as
arguments to the thread function, but I don't think this is a good idea
for the thread functor itself.
I would write a member function that is the thread function:
class c1
{
[...]
void run() {}
[...]
};
and then start it by:
boost::thread(&c1::run, &c);
A possibility is to start the thread in c1::c1() and join it in
c1::~c1(). You would have to come up with a way to tell the run function
to exit if it is supposed to run as long as the c1 instance lives. If
run() is just meant to do one lengthy operation with a finite duration,
it may be ok to just join the thread.
I think what I initially wrote would actually work if operator()() were
const. Else using boost::ref(c1) to pass a non-const reference may also
work.
But if you're going to use a functor, then I'd prefer
boost::thread t1( c1() );
and live with it being copied a couple of times.
Otherwise you would have to make sure to join the thread before c goes
out of scope;
Peter