What is the order of construction and destruction of a derived object?

You can easily verify this:

#include <stdio.h>

class A{
public:
    A(){ puts("A()"); }
    ~A(){ puts("~A()"); }
};

class B: public A{
public:
    B(){ puts("B()"); }
    ~B(){ puts("~B()"); }
};

class C: public B{
public:
    C(){ puts("C()"); }
    ~C(){ puts("~C()"); }
};

class D: public C{
public:
    D(){ puts("D()"); }
    ~D(){ puts("~D()"); }
};

int main(){
/*    puts("\nConstructing A:");
    A myA;

    puts("\nConstructing B:");
    B myB;

    puts("\nConstructing C:");
    C myC;
*/
    puts("\nConstructing D:");
    D myD;

   
    return 0;
}


(I commented out A-C definitions, so the destructor output does not get mixed up. Feel free to uncomment them.)

If you think about the idea behind inheritance as generalization/specialization, the order is only logical.

First, you initialize the "core" functionality, that's the object of the root class A. As B is a specialization or refinement of A, its constructor sees a fully initialized A. It can now add "B specialities" of A, specializing an A object to become a B object.

You should bear in mind that an object of class B is always an A object too, so you can pass a B object to any method/function/operator which expects an A object.

In destruction, the order has to be opposite. First, the B object needs to be stripped of all B specialities, leaving a pure A object. It can then be finally destructed in a call to A's destructor.

Stefan

If this was too abstract, think of a trivial example: Bird and Duck.

A bird has a beak. A duck is a bird which can say "quack". But a duck can't say "quack" without a beak. So obviously, a Duck object first has to be given a beak, then taught how to say "quack".

When destructing your Duck, it will first lose the ability to say "quack", then its beak.

(you can easily verify this with a live duck and a barbecue - errm, better don't...)

Stefan

While constructing an object, first the base is constructed and then the derived object. While destruction, its exactly opposite. If the class is a stand-alone class (not derived from any other classes) and contains other classes objects (as a part of composition), the order of construction is members first. That is the members are constructed first in the order they are declared in the class definition and the the constructor is the class itself is called.

HTH

Stefan, I just put a duck on the barbecue and it went "woof". Maybe I used too much lighter fuel, but it's a bit cold for barbecues.

Watch out if calling virtual functions from a constructor. Isn't it correct (someone confirm or deny!) that they don't get set up correctly until construction is complete, so

class a
{
  virtual x();
}

class b: public a
{
  virtual x();
}

calling x() from a's constructor always calls a::x, even if you're actually constructing a b

(Haven't checked that. Is it correct?)

Yes, Andrew. Here's how you could have checked:
--------8<--------
#include <iostream>

class base {
      virtual void f() {
            std::cout << "base::f()\n";
      }
public:
      base() {
            std::cout << "base::base()...\n";
            f();
            std::cout << "...base::base()\n";
        }
      ~base() {
            std::cout << "base::~base()...\n";
            f();
            std::cout << "...base::~base()\n";
        }
};

class derived : public base {
      virtual void f() {
            std::cout << "derived::f()\n";
      }
public:      
      derived() {
            std::cout << "derived::derived()...\n";
            f();
            std::cout << "...derived::derived()\n";
        }
      ~derived() {
            std::cout << "derived::~derived()...\n";
            f();
            std::cout << "...derived::~derived()\n";
        }
};

int main()
{
      derived d;
}
--------8<--------