Constructor calling order in C++

Introduction

Constructors set up objects when they are created. Knowing the order helps you understand how parts of a program start working together.

When you have a class that inherits from another class and want to know which constructor runs first.

When your class has member objects and you want to understand the order they get initialized.

When debugging object creation to find out why some parts are not ready yet.

When designing classes with multiple layers and you want to control setup steps.

Syntax

C++

class Base {
public:
    Base() { /* base constructor code */ }
};

class Derived : public Base {
public:
    Derived() { /* derived constructor code */ }
};

The base class constructor runs before the derived class constructor.

Member objects are constructed before the body of the constructor runs, in the order they are declared.

Examples

This shows the base constructor runs first, then the derived constructor.

C++

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

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

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

Member objects m1 and m2 are constructed before the Container constructor runs, in the order they are declared.

C++

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

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

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

Sample Program

This program shows the order of constructor calls: first the base class, then member objects in order, then the derived class.

C++

#include <iostream>

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

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

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

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

Important Notes

Base class constructors always run before derived class constructors.

Member objects are constructed in the order they are declared, not the order in the constructor initializer list.

Destructor calls happen in the reverse order of constructors.

Summary

Base class constructor runs first.

Member objects are constructed next, in declaration order.

Derived class constructor runs last.

Practice

1. In C++, when creating an object of a derived class, which constructor is called first?

easy

A. Member objects' constructors

B. Derived class constructor

C. Base class constructor

D. Destructor of the base class

Solution

1. Step 1: Understand constructor order in inheritance

   When an object of a derived class is created, the base class constructor runs first to initialize the base part.

2. Step 2: Identify the first constructor called

   After the base class constructor, member objects and then the derived class constructor run.

3. Final Answer:

   Base class constructor -> Option C

4. Quick Check:

   Base constructor runs first [OK]

Hint: Base constructor always runs before derived [OK]

Common Mistakes:

• Thinking derived constructor runs first
• Confusing member object construction order
• Assuming destructors run during construction

2. Which of the following is the correct syntax to call a base class constructor from a derived class constructor in C++?

easy

A. Derived() { Base(); }

B. Derived() : Base {}

C. Derived() -> Base() {}

D. Derived() : Base() {}

Solution

1. Step 1: Recall base constructor call syntax

   In C++, the base class constructor is called in the initializer list of the derived constructor using a colon and parentheses.

2. Step 2: Match correct syntax

   Derived() : Base() {} uses the correct syntax: Derived() : Base() {}. Others are invalid or incorrect.

3. Final Answer:

   Derived() : Base() {} -> Option D

4. Quick Check:

   Use colon and parentheses for base constructor call [OK]

Hint: Use colon and parentheses to call base constructor [OK]

Common Mistakes:

• Calling base constructor inside derived constructor body
• Using arrow (->) instead of colon
• Omitting parentheses after base class name

3. Consider the following code:

class A {
public:
  A() { std::cout << "A "; }
};
class B {
public:
  B() { std::cout << "B "; }
};
class C : public A {
  B b;
public:
  C() { std::cout << "C "; }
};

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

What is the output when this program runs?

medium

A. A B C

B. B A C

C. C A B

D. A C B

Solution

1. Step 1: Determine constructor call order

   First, base class A constructor runs printing "A ". Then member object b of class B is constructed printing "B ". Finally, derived class C constructor runs printing "C ".

2. Step 2: Combine outputs in order

   The output is "A B C " exactly in that sequence.

3. Final Answer:

   A B C -> Option A

4. Quick Check:

   Base, members, derived = A B C [OK]

Hint: Base then members then derived constructor order [OK]

Common Mistakes:

• Assuming members construct before base
• Mixing order of output strings
• Ignoring member object construction

4. Given this code snippet:

class Base {
public:
  Base() { std::cout << "Base "; }
};
class Derived : public Base {
public:
  Derived() { std::cout << "Derived "; }
};

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

What is the output when this program runs?

medium

A. No output

B. Derived Base

C. Base Derived

D. Compilation error

Solution

1. Step 1: Analyze object declaration

   The line 'Derived d();' is a function declaration, not an object instantiation, so no constructor runs.

2. Step 2: Understand program output

   Since no object is created, no constructors run and no output is printed.

3. Final Answer:

   No output -> Option A

4. Quick Check:

   Function declaration, no object created [OK]

Hint: Watch out for most vexing parse: 'Derived d();' is a function [OK]

Common Mistakes:

• Thinking 'Derived d();' creates an object
• Expecting constructor output
• Ignoring C++ parsing rules

5. You have a class hierarchy:

class X {
public:
  X() { std::cout << "X "; }
};
class Y {
public:
  Y() { std::cout << "Y "; }
};
class Z : public X {
  Y y1, y2;
public:
  Z() { std::cout << "Z "; }
};

int main() {
  Z obj;
  return 0;
}

What is the exact output when this program runs?

hard

A. Y Y X Z

B. X Y Y Z

C. X Z Y Y

D. Y X Y Z

Solution

1. Step 1: Identify constructor call order

   First, base class X constructor runs printing "X ". Then member objects y1 and y2 of class Y are constructed in declaration order, printing "Y " twice.

2. Step 2: Derived class constructor runs last

   Finally, derived class Z constructor runs printing "Z ".

3. Final Answer:

   X Y Y Z -> Option B

4. Quick Check:

   Base, members in order, derived = X Y Y Z [OK]

Hint: Members construct in declaration order after base [OK]

Common Mistakes:

• Mixing member construction order
• Assuming derived runs before members
• Ignoring multiple member objects