thread and deconstruction of functors - c++

Question

I'm trying to understand when the deconstructor of a functor (i.e. a class with () operator) is called when that functor is passed to a thread. But in the following example, the constructor is called for once but the deconstructor is called for three times?
According to
What are the missing (two) calls to the constructor? Is it copy or move?
If the move constructor is called, how can write the deconstructor so that it won't destroy the resources being moved? Imagine I open a file run() and close it in the ~run(), calling it three times causes a problem of course.
Example:
#include <iostream>
#include <thread>
using namespace std;
class run {
public:
run() { cout << "in run()" << endl; }
~run() { cout << "in ~run()" << endl; }
void operator()() {};
};
int main() {
run thread_r;
thread t(thread_r);
t.join();
}
Gives output:
in run()
in ~run()
in ~run()
in ~run()

Answer 1

Rule of 5, 3 and zero.
If you define a destructor, the compiler will still generate a default copy constructor and assignment operator.
Unfortunately, if you've defined a destructor it implies that you have some special handling around resource deallocation, so the default copy and assignment code will be plain wrong.
It is good practice, by which I mean "always do it, no excuses", to provide at least copy constructor and assignment operator, even if you delete them.
If you're going to supply these, you may as well go ahead and write correct move operators too.
#include <iostream>
#include <thread>
using namespace std;
class run {
public:
run() { cout << "in run()" << endl; }
run(const run&) { cout << "copied()" << endl; }
run(run&&) { cout << "moved()" << endl; }
run& operator=(const run&) { cout << "copy-assigned()" << endl; return *this; }
run& operator=(run &&) { cout << "move-assigned()" << endl; return *this; }
~run() { cout << "in ~run()" << endl; }
void operator()() {};
};
int main() {
run thread_r;
thread t(thread_r);
t.join();
}
example output:
in run()
copied()
moved()
in ~run()
in ~run()
in ~run()
Here's an updated version to help explain what's happening in the constructors and destructors:
#include <iostream>
#include <thread>
#include <vector>
using namespace std;
class run {
public:
run()
: lifetime("constructed")
{
cout << lifetime << endl;
}
run(const run& other)
: lifetime("copied from " + other.lifetime)
{
cout << lifetime << endl;
}
run(run&& other)
: lifetime("move-constructed from " + other.lifetime)
{
other.lifetime = "[zombie] - " + other.lifetime;
cout << lifetime << endl;
}
run& operator=(const run& other)
{
lifetime = "copy assigned from " + other.lifetime + ", was once " + lifetime;
cout << lifetime << endl;
return *this;
}
run& operator=(run &&other)
{
lifetime = "move-assigned from " + other.lifetime + ", was once " + lifetime;
other.lifetime = "[zombie] - " + other.lifetime;
cout << lifetime << endl;
return *this;
}
~run()
{
lifetime = "lifetime ending: " + lifetime;
cout << lifetime << endl;
}
void operator()() {};
std::string lifetime;
};
int main() {
run thread_r;
thread t(thread_r);
t.join();
}
sample output:
constructed
copied from constructed
move-constructed from copied from constructed
lifetime ending: [zombie] - copied from constructed
lifetime ending: move-constructed from copied from constructed
lifetime ending: constructed
For anyone not sure about the exact behaviour of copy constructors and move-constructors, it would be a good idea to play with this code in a debugger until it becomes clear.