Constructor calling order in C++ - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is the order of constructor calls in C++ when using inheritance?

Constructors are called starting from the base class first, then moving to derived classes in order of inheritance.

intermediate

In multiple inheritance, which constructors are called first?

Constructors of base classes are called in the order they appear in the derived class's inheritance list, from left to right.

intermediate

What happens if a derived class constructor calls a base class constructor explicitly?

The specified base class constructor is called before the derived class constructor body executes, overriding the default base constructor call.

intermediate

How are member objects' constructors called in relation to the class constructor?

Member objects are constructed after base class constructors but before the body of the derived class constructor runs.

beginner

Why is constructor calling order important in C++?

It ensures that base parts of an object are ready before derived parts use them, preventing errors and undefined behavior.

When creating an object of a derived class, which constructor is called first?

A Member object constructor

B Base class constructor

C Derived class constructor

D Destructor

The base class constructor is called first to initialize the base part of the object.

In multiple inheritance, constructors are called in what order?

A Left to right as listed in inheritance

B Derived class first

C Random order

D Right to left as listed in inheritance

Constructors of base classes are called left to right as they appear in the derived class's inheritance list.

When are member objects constructed relative to the class constructor body?

A Before the constructor body

B After the constructor body

C At the same time as the constructor body

D Only if explicitly called

Member objects are constructed before the constructor body runs.

If a derived class constructor explicitly calls a base class constructor, what happens?

A The default base constructor is called instead

B No base constructor is called

C The specified base constructor is called

D The derived constructor is skipped

The explicitly specified base constructor is called before the derived constructor body.

Why must base class constructors be called before derived class constructors?

A To call destructors later

B To initialize derived class members first

C To save memory

D To ensure base parts are ready for use

Base parts must be initialized first so derived parts can safely use them.

Explain the order in which constructors are called when creating an object of a class with inheritance.

Think about building a house: foundation first, then walls, then furniture.

Describe how constructor calling order works in multiple inheritance in C++.

Imagine assembling parts in the order they are listed on a checklist.

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