Constructor calling order in C++ - Mini Project: Build & Apply

Constructor calling order

📖 Scenario: Imagine you are building a simple program to understand how constructors are called in a class inheritance setup in C++. This helps you see the order in which parts of an object are created.

🎯 Goal: You will create two classes: Base and Derived. You will write constructors for both that print messages when called. Then you will create an object of Derived and observe the order of constructor calls.

📋 What You'll Learn

Create a class called Base with a constructor that prints "Base constructor called".

Create a class called Derived that inherits from Base with a constructor that prints "Derived constructor called".

Create an object of type Derived in the main function.

Print the messages exactly as specified to observe the constructor calling order.

💡 Why This Matters

🌍 Real World

Understanding constructor calling order helps when designing classes that inherit from others, ensuring proper initialization.

💼 Career

Many software jobs require knowledge of object-oriented programming and class inheritance, especially in C++ development.

1

Create the Base class with a constructor

Create a class called Base with a constructor that prints "Base constructor called".

C++

# Create class Base with a constructor that prints "Base constructor called"
// Your code here

Hint

Use class Base { public: Base() { ... } }; and std::cout to print the message.

2

Create the Derived class inheriting from Base

Create a class called Derived that inherits from Base. Add a constructor to Derived that prints "Derived constructor called".

C++

#include 

class Base {
public:
    Base() {
        std::cout << "Base constructor called" << std::endl;
    }
};

// Create class Derived inheriting from Base with a constructor that prints "Derived constructor called"
// Your code here

Hint

Use class Derived : public Base and add a constructor that prints the message.

3

Create a Derived object in main

In the main function, create an object called obj of type Derived.

C++

#include 

class Base {
public:
    Base() {
        std::cout << "Base constructor called" << std::endl;
    }
};

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

int main() {
    // Create an object obj of type Derived
    // Your code here
}

Hint

Inside main(), write Derived obj; to create the object.

4

Run the program and observe output

Run the program and print the output. The output should show the order in which constructors are called.

C++

#include 

class Base {
public:
    Base() {
        std::cout << "Base constructor called" << std::endl;
    }
};

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

int main() {
    Derived obj;
    // Output will be shown when program runs
    // Your code here
}

Hint

When you run the program, you should see the message from the Base constructor first, then the Derived constructor.

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