Constructor calling order in C++ - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Constructor calling order in single inheritance

What is the output of this C++ program showing constructor calls in single inheritance?

C++

#include <iostream>
using namespace std;

class Base {
public:
    Base() { cout << "Base constructor\n"; }
};

class Derived : public Base {
public:
    Derived() { cout << "Derived constructor\n"; }
};

int main() {
    Derived d;
    return 0;
}

A

Derived constructor

B

Derived constructor
Base constructor

C

Base constructor

D

Base constructor
Derived constructor

💡 Hint

Remember base class constructors run before derived class constructors.

In C++, when an object of a derived class is created, the base class constructor runs first, then the derived class constructor.

❓ Predict Output

intermediate

Constructor calling order in multiple inheritance

What is the output of this C++ program demonstrating constructor calls in multiple inheritance?

C++

#include <iostream>
using namespace std;

class A {
public:
    A() { cout << "A constructor\n"; }
};

class B {
public:
    B() { cout << "B constructor\n"; }
};

class C : public A, public B {
public:
    C() { cout << "C constructor\n"; }
};

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

A

C constructor
A constructor
B constructor

B

B constructor
A constructor
C constructor

C

A constructor
B constructor
C constructor

D

A constructor
C constructor
B constructor

💡 Hint

Base classes are constructed in the order they are declared in the class header.

In multiple inheritance, base classes are constructed in the order they appear in the derived class declaration, then the derived class constructor runs.

❓ Predict Output

advanced

Constructor calling order with virtual inheritance

What is the output of this C++ program illustrating constructor calls with virtual inheritance?

C++

#include <iostream>
using namespace std;

class Base {
public:
    Base() { cout << "Base constructor\n"; }
};

class A : virtual public Base {
public:
    A() { cout << "A constructor\n"; }
};

class B : virtual public Base {
public:
    B() { cout << "B constructor\n"; }
};

class Derived : public A, public B {
public:
    Derived() { cout << "Derived constructor\n"; }
};

int main() {
    Derived d;
    return 0;
}

A

Base constructor
A constructor
B constructor
Derived constructor

B

A constructor
B constructor
Base constructor
Derived constructor

C

Base constructor
B constructor
A constructor
Derived constructor

D

A constructor
Base constructor
B constructor
Derived constructor

💡 Hint

Virtual base class constructors are called before any derived class constructors.

With virtual inheritance, the virtual base class constructor is called only once before any non-virtual base classes or derived class constructors.

❓ Predict Output

advanced

Constructor calling order with member objects

What is the output of this C++ program showing constructor calls including member objects?

C++

#include <iostream>
using namespace std;

class Member {
public:
    Member() { cout << "Member constructor\n"; }
};

class Container {
    Member m;
public:
    Container() { cout << "Container constructor\n"; }
};

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

A

Member constructor
Container constructor

B

Container constructor
Member constructor

C

Member constructor

D

Container constructor

💡 Hint

Member objects are constructed before the container class constructor body runs.

When an object contains member objects, those members are constructed first, then the container's constructor runs.

🧠 Conceptual

expert

Order of constructor calls in complex inheritance

Given this class hierarchy with virtual and non-virtual inheritance, which sequence correctly shows the constructor call order when creating an object of class D?

C++

class A { public: A() { cout << "A"; } };
class B : virtual public A { public: B() { cout << "B"; } };
class C : virtual public A { public: C() { cout << "C"; } };
class D : public B, public C { public: D() { cout << "D"; } };

A B A C D

B A B C D

C A C B D

D B C A D

💡 Hint

Virtual base class A is constructed once before B and C.

Virtual base A is constructed first, then B and C in declaration order, then D.