Understanding the construction, lifetime and destruction of objects - c++

Question

My question is actually two-part. A quick foreword: I am learning C++ and come from a C#/.NET background. Currently, I'm trying to understand object lifetimes and the results posted below don't make sense to me. I think it could have something to do with the creation of anonymous instances?
Question 1: Is it a good idea to dispose of all members in the destructor since it is possible that it is an "empty object" ?
Question 2: How do I prevent this? / How do I design my objects to work with this feature?
Question 3: Is this the "right" / "correct" way to do this?
Question 4: See comments in the very last bit of code
#include <stdio.h>
class A
{
public:
A()
{
printf("Constructor A\n");
}
~A()
{
printf("Destructor A\n");
}
};
class B
{
public:
B()
{
a = A();
printf("Constructor B\n");
}
~B()
{
printf("Destructor B\n");
}
private:
A a;
};
int main(int argc, char* argv[])
{
B b;
b = B();
printf("Done");
// Breakpoint
/*
Output:
Constructor A
Constructor A
Destructor A
Constructor B
Constructor A
Constructor A
Destructor A
Constructor B
Destructor B
Destructor A
*/
}
And another example that comes from a project I am currently working on.
#include <stdio.h>
class Mesh
{
public:
Mesh()
{
printf("Constructing Mesh with data %d\n", data);
}
Mesh(int d)
{
data = d;
printf("Constructing Mesh with data %d\n", data);
}
~Mesh()
{
printf("Destructing Mesh with data %d\n", data);
}
private:
int data = 0;
};
class Game
{
public:
Game()
{
printf("Game constructor\n");
}
~Game()
{
printf("Game destructor\n");
}
void init()
{
int cool_data = 3;
mesh = Mesh(cool_data);
}
private:
Mesh mesh;
};
int main(int argc, char* argv[])
{
Game game = Game();
game.init();
printf("");
// Breakpoint
/*
Output:
Constructing Mesh with data 0 <-- I assume this comes from the private member declaration in the Mesh class? So declaration means initialization?
Game constructor
Constructing Mesh with data 3 <-- Okay that's what I expected since I'm creating a new instance of the Mesh class with "3" passed in
Destructing Mesh with data 3 <-- Why is the instance we JUST created immediately being destructed?
*/
}

Answer 1

In your first example, we see a lot of construction and destruction of "A" objects that seems mysterious if you are not familiar with C++. Your B class has a private A variable "a". This object is default constructed when you first call the constructor to your B class. This is the very first "constructor A" print out that you see. The next print out is from the call to the A constructor here:
B()
{
a = A(); //A() calls the A constructor and returns an r-value
printf("Constructor B\n");
}
Assigning "a", an already instantiated object of class A, to the r-value returned by the call of the default constructor of class A causes you to print "Constructor A" when the r-value is created, and "Destructor A" when the r-value itself is destroyed. These behaviors can be changed by creating copy and move constructors/operators which will allow you to specify how these semantics operate. Check out this page: http://www.cprogramming.com/c++11/rvalue-references-and-move-semantics-in-c++11.html or a book (C++ 11 primer is a good one) for more info on these operations.
Following the above logic, when you assign your created B object "b" to the B class default constructor's returned rvalue in the line:
b = B();
You construct a new B object, which must
1) construct an A object
2) create an A r-value
3) destruct the A r-value
4) construct a B object
The last two print statements are simply your B object being destructed as the main exits. The B object is destructed and so is it's member, the A object. Your first question seems to be about this behavior. It looks like you're asking whether you should destruct class members manually. This is only done in C++ if your class allocates memory for its members. If, for instance, instead of creating a local A object, your constructor in B did this:
B()
{
a = new A();
printf("Constructor B\n");
}
...
private:
A* a;
Then you would have to deallocate this A* in your destructor. As long as you are not allocating new memory using the new operator or otherwise, C++ will handle all other deallocation for you.
Your questions 2 and 3 are about how to prevent/work with object construction and whether or not a given way of constructing/destructing objects is right or wrong. I would like to point you to the rule of 0/3/5. This basically deals with how many constructors you should create for a given class. This is a pretty simple explanation of the rule http://en.cppreference.com/w/cpp/language/rule_of_three, but there are many others online.
Your last question has to do with the mesh class you have and why one of your variables is being destructed. Again, this has to do with the r-value returned by the call to the constructor. Basically, when you call your mesh constructor and assign its returned value to your variable "mesh" here:
void init()
{
int cool_data = 3;
mesh = Mesh(cool_data);
}
The mesh constructor returns an r-value which is an object of class Mesh with a data value of 3; The r-value is copied into your "mesh" variable and is promptly destroyed, leaving your "mesh" variable as an exact copy of it. Again, all of these behaviors can be changed by creating appropriate constructors and operators.