Constructors and Inheritance in C++

Object-Oriented Programming (OOP) is built upon several core principles, one of which is inheritance — the ability of one class to derive properties and behavior from another. Inheritance allows developers to build hierarchies of classes where a derived (or child) class can reuse and extend the functionality of a base (or parent) class.

In C++, constructors play an essential role in the lifecycle of these classes. However, constructors are not inherited by derived classes. Instead, constructors of base classes are invoked automatically (or explicitly) by derived classes during object creation. This ensures that each part of the object — the base portion and the derived portion — is properly initialized.

This article provides a comprehensive explanation of how constructors and inheritance work together in C++. It explores how constructors behave in inheritance hierarchies, how base class constructors are invoked, how initialization lists are used, and the order in which constructors execute. It also explains key rules, examples, and best practices for using constructors correctly when inheritance is involved.

Understanding Constructors in Inheritance

A constructor is a special function in a class that initializes its objects. When inheritance is introduced, the construction of a derived class object involves not only the derived class’s constructor but also the constructors of all its base classes.

Every time an object of a derived class is created, the following occurs:

1. The base class constructor is called first to initialize the inherited members.
2. Then the derived class constructor executes to initialize its own members.

This two-step process ensures that the entire object — including its inherited and unique attributes — is correctly set up.

The important point to understand is that constructors themselves are not inherited. However, they can be called from the derived class constructor.

---

Basic Example: Calling a Base Class Constructor

Let us begin with a simple example to understand how base class constructors are called.

#include <iostream>
using namespace std;

class Vehicle {
public:
Vehicle(string m) {
    cout &lt;&lt; "Vehicle: " &lt;&lt; m &lt;&lt; endl;
}
};

class Car : public Vehicle {
public:
Car(string m) : Vehicle(m) {
    cout &lt;&lt; "Car: " &lt;&lt; m &lt;&lt; endl;
}
};

int main() {
Car c1("Toyota");
return 0;
}

Output:

Vehicle: Toyota
Car: Toyota

In this program:

• The Vehicle class defines a constructor that takes a string parameter.
• The Car class inherits from Vehicle.
• The Car constructor explicitly calls the Vehicle constructor in its initialization list using the syntax Car(string m) : Vehicle(m).

This ensures that the base part of the object (Vehicle) is initialized first before the Car part of the object is constructed.

---

Why Constructors Are Not Inherited

C++ does not allow constructors to be inherited directly because constructors are specific to the class that defines them. Each class has its own unique data members, and therefore its constructor must know how to initialize those specific members.

If constructors were inherited, the base class constructor might try to initialize members that do not exist in the derived class, leading to inconsistency and errors.

However, although constructors are not inherited, C++ provides mechanisms for invoking base class constructors, either automatically or manually, during derived class construction.

---

Automatic Invocation of Default Base Class Constructors

If the base class has a default constructor (that is, a constructor that takes no arguments), it is automatically called when an object of a derived class is created — even if you don’t explicitly call it in the derived class constructor.

Example:

class Vehicle {
public:
Vehicle() {
    cout << "Vehicle default constructor" << endl;
}
};

class Car : public Vehicle {
public:
Car() {
    cout << "Car constructor" << endl;
}
};

int main() {
Car c1;
return 0;
}

Output:

Vehicle default constructor
Car constructor

In this example, when a Car object is created, the default constructor of Vehicle is automatically invoked before the Car constructor executes. This happens even though the Car class does not explicitly call the Vehicle constructor.

---

Explicitly Calling Base Class Constructors

If the base class constructor requires arguments, you must explicitly call it from the derived class constructor using the initialization list.

Example:

class Vehicle {
public:
Vehicle(string type) {
    cout << "Vehicle type: " << type << endl;
}
};

class Car : public Vehicle {
public:
Car(string model) : Vehicle("Car") {
    cout << "Car model: " << model << endl;
}
};

int main() {
Car c1("Tesla");
return 0;
}

Output:

Vehicle type: Car
Car model: Tesla

The base class Vehicle constructor is called with the argument "Car" through the derived class initialization list. This approach ensures proper initialization order and clarity in constructor behavior.

---

Constructor Initialization List

An initialization list is a special syntax in C++ that allows you to initialize base class constructors and member variables before the constructor body executes.

Syntax:

DerivedClass(parameters) : BaseClass(arguments) {
// Derived class body
}

The initialization list is the only way to call a base class constructor that requires parameters. You cannot call a base class constructor inside the body of the derived class constructor — it must be done in the initialization list.

Example:

class Vehicle {
public:
Vehicle(string type) {
    cout << "Vehicle type: " << type << endl;
}
};

class Car : public Vehicle {
public:
Car(string model) : Vehicle("Car") {
    cout << "Car model: " << model << endl;
}
};

Here, the base class Vehicle is constructed first via the initialization list, followed by the derived class Car.

---

Order of Constructor Execution in Inheritance

The order of constructor execution is always from base class to derived class. This means the base class constructor is called first, and then the derived class constructor runs. This order ensures that the base part of the object is initialized before the derived part starts its own initialization.

Example:

class Engine {
public:
Engine() {
    cout << "Engine constructed" << endl;
}
};

class Vehicle : public Engine {
public:
Vehicle() {
    cout << "Vehicle constructed" << endl;
}
};

class Car : public Vehicle {
public:
Car() {
    cout << "Car constructed" << endl;
}
};

int main() {
Car c1;
return 0;
}

Output:

Engine constructed
Vehicle constructed
Car constructed

Here, construction starts from the top of the inheritance hierarchy:

1. Engine (base of Vehicle) is constructed first.
2. Vehicle (base of Car) is constructed next.
3. Car (the most derived class) is constructed last.

---

Constructors in Multilevel Inheritance

When you have multilevel inheritance (i.e., a class derived from another derived class), constructors execute in the order of inheritance — from the base class at the top to the most derived class at the bottom.

Example:

class Engine {
public:
Engine() {
    cout << "Engine constructed" << endl;
}
};

class Vehicle : public Engine {
public:
Vehicle() {
    cout << "Vehicle constructed" << endl;
}
};

class Car : public Vehicle {
public:
Car() {
    cout << "Car constructed" << endl;
}
};

int main() {
Car c1;
return 0;
}

Output:

Engine constructed
Vehicle constructed
Car constructed

This clearly demonstrates that constructors execute in the sequence of inheritance, from the base class to the most derived class.

---

Multiple Inheritance and Constructor Calls

In multiple inheritance, where a derived class inherits from more than one base class, constructors for each base class are executed in the order of their appearance in the inheritance list, not the order in which they appear in the initialization list.

Example:

class Engine {
public:
Engine() {
    cout << "Engine constructed" << endl;
}
};

class Wheels {
public:
Wheels() {
    cout << "Wheels constructed" << endl;
}
};

class Car : public Engine, public Wheels {
public:
Car() {
    cout << "Car constructed" << endl;
}
};

int main() {
Car c1;
return 0;
}

Output:

Engine constructed
Wheels constructed
Car constructed

Even if you attempt to change the order of initialization in the initialization list, C++ will still follow the order declared in the class inheritance.

---

Constructors in Virtual Inheritance

When virtual inheritance is used, only one copy of the virtual base class is constructed, regardless of how many times it appears in the inheritance hierarchy.

Example:

class Vehicle {
public:
Vehicle() {
    cout << "Vehicle constructed" << endl;
}
};

class Engine : virtual public Vehicle {
public:
Engine() {
    cout << "Engine constructed" << endl;
}
};

class Wheels : virtual public Vehicle {
public:
Wheels() {
    cout << "Wheels constructed" << endl;
}
};

class Car : public Engine, public Wheels {
public:
Car() {
    cout << "Car constructed" << endl;
}
};

int main() {
Car c1;
return 0;
}

Output:

Vehicle constructed
Engine constructed
Wheels constructed
Car constructed

Notice that the Vehicle constructor is called only once, even though both Engine and Wheels inherit from it. This behavior is due to virtual inheritance, which ensures that there is only a single instance of the virtual base class.

---

Passing Parameters to Base Class Constructors

You can pass parameters from a derived class constructor to the base class constructor through the initialization list. This is crucial when the base class constructor requires specific arguments.

Example:

class Vehicle {
public:
Vehicle(string brand, int year) {
    cout << "Brand: " << brand << ", Year: " << year << endl;
}
};

class Car : public Vehicle {
public:
Car(string brand, int year, string model) : Vehicle(brand, year) {
    cout << "Model: " << model << endl;
}
};

int main() {
Car c1("Toyota", 2024, "Corolla");
return 0;
}

Output:

Brand: Toyota, Year: 2024
Model: Corolla

This example shows that arguments can be passed from derived class constructors to base class constructors through the initialization list, maintaining a clean and structured way of constructing complex objects.

---

Destructors and Inheritance

Just as constructors build objects in order from the base to the derived class, destructors destroy them in the reverse order. The derived class destructor runs first, followed by the base class destructor.

Example:

class Vehicle {
public:
Vehicle() {
    cout << "Vehicle constructed" << endl;
}
~Vehicle() {
    cout << "Vehicle destroyed" << endl;
}
};

class Car : public Vehicle {
public:
Car() {
    cout << "Car constructed" << endl;
}
~Car() {
    cout << "Car destroyed" << endl;
}
};

int main() {
Car c1;
return 0;
}

Output:

Vehicle constructed
Car constructed
Car destroyed
Vehicle destroyed

This ensures that destruction happens in the reverse order of construction, allowing derived classes to clean up their resources before the base class destructor runs.

---

Constructor Overloading with Inheritance

Constructors in derived classes can be overloaded, just like regular functions. This allows multiple ways of initializing derived class objects, each potentially calling different base class constructors.

Example:

class Vehicle {
public:
Vehicle() {
    cout << "Default Vehicle constructor" << endl;
}
Vehicle(string type) {
    cout << "Vehicle type: " << type << endl;
}
};

class Car : public Vehicle {
public:
Car() : Vehicle() {
    cout << "Default Car constructor" << endl;
}
Car(string type, string model) : Vehicle(type) {
    cout << "Car model: " << model << endl;
}
};

int main() {
Car c1;
Car c2("Electric", "Tesla");
return 0;
}

Output:

Default Vehicle constructor
Default Car constructor
Vehicle type: Electric
Car model: Tesla

Here, both constructors demonstrate overloading and explicit calls to different base class constructors.

---

Key Principles for Constructors and Inheritance

1. Constructors are not inherited by derived classes.
2. Base class constructors are always called before derived class constructors.
3. Default base constructors are called automatically if no explicit call is made.
4. If the base class constructor requires parameters, it must be called explicitly in the initialization list.
5. Constructors execute from the base to the derived class, while destructors execute in the reverse order.
6. Virtual inheritance ensures that only one instance of the virtual base class is constructed.

---

Best Practices for Using Constructors with Inheritance

1. Always use initialization lists for base class constructors requiring parameters.
2. Keep constructor logic simple; avoid performing heavy operations inside constructors.
3. Prefer explicit constructor calls for clarity, especially in complex hierarchies.
4. When designing base classes, include a default constructor to simplify inheritance.
5. In polymorphic base classes, make destructors virtual to ensure proper cleanup.