What is the order in which the destructors and the constructors are called in C++

Also, keep in mind that while array elements are constructed first -> last, they are destructed in the reverse order: last -> first.

I must add to the previous answers because everyone seems to be ignoring it

When you have a derived class instance being created, it is true that the code inside the constructor of the base will be called before the code inside the constructor of the derived, but keep in mind that the derived is still technically "created" before the base.

And when you have the derived class destructor being called, it is true that the code inside the derived destructor is called before the code inside the base destructor, but also keep in mind that the base is destroyed before the derived.

When I am saying created/destroyed I am actually referring to allocated/deallocated.

If you look at the memory layout of these instances, you will see that the derived instance composes the base instance. For example:

Memory of derived: 0x00001110 to 0x00001120

Memory of base : 0x00001114 to 0x00001118

Therefore, the derived class must be allocated BEFORE the base in the construction. And the derived class must be deallocated AFTER the base in the destruction.

If you have the following code:

class Base 
{
public:
    Base()
    {
        std::cout << "\n  Base created";
    }
    virtual ~Base()
    {
        std::cout << "\n  Base destroyed";
    }
}

class Derived : public Base 
{
public:
    Derived()
    // Derived is allocated here 
    // then Base constructor is called to allocate base and prepare it
    {
        std::cout << "\n  Derived created";
    }
    ~Derived()
    {
        std::cout << "\n  Derived destroyed";
    }   
    // Base destructor is called here
    // then Derived is deallocated
}

So if you created Derived d; and had it go out of scope, then you will get the output in @Brian's answer. But the object behavior in memory is not really the in same order, it is more like this:

Construction:

1. Derived allocated

2. Base allocated

3. Base constructor called

4. Derived constructor called

Destruction:

1. Derived destructor called

2. Base destructor called

3. Base deallocated

4. Derived deallocated

The order is:

1. Base constructor
2. Derived constructor
3. Derived destructor
4. Base destructor

Example:

class B
{
public:
  B()
  {  
    cout<<"Construct B"<<endl;
  }

  virtual ~B()
  {
    cout<<"Destruct B"<<endl;
  }
};

class D : public B
{
public:
  D()
  {  
    cout<<"Construct D"<<endl;
  }

  virtual ~D()
  {
    cout<<"Destruct D"<<endl;
  }
};



int main(int argc, char **argv)
{
  D d; 
  return 0;
}

Output of example:

Construct B

Construct D

Destruct D

Destruct B

Multiple levels of inheritance works like a stack:

If you consider pushing an item onto the stack as construction, and taking it off as destruction, then you can look at multiple levels of inheritance like a stack.

This works for any number of levels.

Example D2 derives from D derives from B.

Push B on the stack, push D on the stack, push D2 on the stack. So the construction order is B, D, D2. Then to find out destruction order start popping. D2, D, B

More complicated examples:

For more complicated examples, please see the link provided by @JaredPar

A detailed description of these events, including virtual and multiple inheritance is available at the C++ FAQ Lite. Section 25.14 and 25.15

https://isocpp.org/wiki/faq/multiple-inheritance#mi-vi-ctor-order