Constructors calling in c++ (inherited classes)

Question

#include <iostream>

class A
{
public:
  A()  { std::cout << "A's constructor called\n"; }
};

class B
{
public:
  B()  { std::cout << "B's constructor called\n"; }
};

class C: public B, public A  // Note the order
{
public:
  C()  { std::cout << "C's constructor called\n"; }
};

int main()
{
    C c;
    return 0;
}

Why is the constructor of class A and B called, when a new instance of C is created?

Output is

B's constructor called
A's constructor called
C's constructor called

You declared `C` to inherit from `B` and `A`: `class C: public B, public A` — Micha Wiedenmann, Mar 23 '18 at 09:07
In C++, the no-argument constructors for all superclasses and member variables are called for you, before entering your constructor. — PPL, Mar 23 '18 at 09:11
`class A { public: void foo() {} }` could be written as `struct A { void foo() }` to make the example simpler/smaller. — Micha Wiedenmann, Mar 23 '18 at 09:11
May I suggest to read a good [C++ Book](https://stackoverflow.com/questions/388242/the-definitive-c-book-guide-and-list). Will save you a ton of time. — rustyx, Mar 23 '18 at 09:11
Possible duplicate of [What are the rules for calling the superclass constructor?](https://stackoverflow.com/questions/120876/what-are-the-rules-for-calling-the-superclass-constructor) — xskxzr, Mar 23 '18 at 09:18

score 2 · Accepted Answer · edited Mar 23 '18 at 09:12

C is derived from both A and B - so before the constructor for C can be executed, the constructors for A and B must both be completed. If that wasn't the case, then the C constructor could not rely on anything that its base classes provided.

For example, suppose A contained a list of items which is created and filed from a database in its constructor. All instances of A can rely on the list being complete because the constructor has to be finished before the instance is available to the rest of the code. But C is also an A - it derives from it in the same way that "a Ford" is also "A Car" - so it may well want to access that list. When you construct an instance, the base class constructors are automatically called before the derived classes to ensure that everything is ready for action when the derived constructor starts.

For example, change your code slightly:

class A
{
public:
A() { cout << "A's constructor called" << endl; }
};

class B: public A
{
public:
B() { cout << "B's constructor called" << endl; }
};

class C: public B
{
public:
C() { cout << "C's constructor called" << endl; }
};

int main()
{
C c;
return 0;
}

and you will get:

A's constructor called
B's constructor called
C's constructor called

Because the base class constructors are all completed before the derived ones are executed.

score 1 · Answer 2 · answered Mar 23 '18 at 09:48

1

Why wouldn't it be? A C contains parts that are a B and an A respectively, and those parts need to be constructed as well. The constructor is the feature that performs this role.

answered Mar 23 '18 at 09:48

Lightness Races in Orbit

378,754
76
643
1,055

score 0 · Answer 3 · answered Mar 23 '18 at 09:14

kanishk tanwar's answer has more detail, but I was writing this anyway, so here's a very whistle stop tour of why it's happening to answer your question:

In order to ensure an instance of a class is properly initialised, a constructor for the base types are always called. If you don't specify which constructor you want to call (syntax: C() : B(), A() for C's constructor), the default constructor is used. As a derived class builds on a base class, the base classes have to be constructed first.

In your case you have specified contents to your default constructor, so that is the code that is run when you instantiate C.

Constructors calling in c++ (inherited classes)

3 Answers3