In what order are the aggregated classes deleted?

Question

Let's say I have a basic class A that aggregate B and C:

class A  
{  
    B _b;  
    C _c;  
}

in what order are _b and _c going to be deleted?
I've read somewhere that it's the reverse order of their allocation.
So I guess in this little example _c is deleted before _b, right?

Now if I have a A constructor that looks like that:

A::A():  
_c(...),  
_b(...)  
{  
}

In what order are _b and _c's constructors called?
If _b's constructor is indeed called before _c's one (regarding their order in A), then I find it really counter intuitive!

In this case what will be the order of destruction?

Thanks for your help ! :)

(On a side note I seem totally unable to type '}' into Stackoverflow's editor. Had to copy and paste from an external editor !?)

Answer 1

Non-static class members are always destroyed in the reverse order that they were constructed.

The order that members are constructed always matches the order that they are declared in the class definition. The order that members appear in a constructor's initalizer list has no effect on the order of their construction.

In your example _c is destroyed, then _b is destroyed, the reverse order of their declaration in the class.

Answer 2

They are destroyed (not deleted) in the reverse order that they were created. It is this that also requires that regardless of how the constructor is written that all the members must be constructed in a consistent order. If each constructor could define the order that the members were constructed, each class instance would have to carry around information on how it was constructed, in order to be able to destruct in reverse order. By defining the order to always be the order that the members were declared in the class definition, the order of construction does not change from constructor to constructor.

In your example, first, memory is allocated for the full A class. Next _b is constructed, then _c then A. If A were to have a base class, that would be fully constructed before any of the above. On deletion, the reverse occurs. First A's destructor is called, then _c is destructed, then _b (then any base classes are destructed). Finally the memory for 'A' is freed.

Answer 3

class members constructors are always called in the order of their declaration, regardless the call order in the master class constructor.

in your case,

A::A():  
_c(...),  
_b(...)  
{  
}

implies the same construction/destruction order than

A::A():  
_b(...),
_c(...)  
{  
}