2026-03-1910 min read

Inheriting constructors (C++)

Learn Inheriting constructors (C++) step by step with clear examples and exercises.

Why This Matters

Understanding how to handle constructors during inheritance is crucial in C++ programming for several reasons:

Efficient Object Initialization: Constructors help create and initialize objects according to their specific requirements, ensuring that the objects are properly set up before they can be used.
Consistent Initialization Across Inherited Classes: By managing constructors correctly during inheritance, you can ensure that both parent and child classes are initialized consistently, reducing the likelihood of errors and bugs.
Customizing Initialization Process: Constructors provide a way to customize the initialization process for each class, allowing you to set up objects in a manner that best suits their intended purpose.
Improving Code Readability and Maintainability: Properly managing constructors can make your code more readable and easier to maintain by clearly defining how objects are created and initialized.
Preparing for Interviews and Real-World Projects: Mastery of constructor inheritance is essential for success in interviews, real-world programming tasks, and debugging complex projects involving object-oriented design.

Prerequisites

Before diving into inheriting constructors, it's essential to have a good understanding of the following concepts:

Basics of Object-Oriented Programming (OOP) in C++
Classes and objects
Constructors and destructors
Inheritance and polymorphism
Access specifiers (public, private, protected)
Function overriding and function overloading
Member functions and member variables
Basic syntax and rules of C++
Understanding the difference between value types (structs, enums, built-in types) and reference types (classes)
Familiarity with C++ standard library features such as initializer lists and exception handling

Core Concept

Default Constructors

A default constructor is a special kind of constructor that has no parameters and is automatically generated by the compiler if we don't define any constructors for a class. When deriving a child class from a parent class, if the parent class has a default constructor, the child class will also have one unless an explicit constructor is provided.

// Parent class with a default constructor
class Parent {
public:
Parent() { // Default constructor implementation }
};

// Child class inheriting from the parent class
class Child : public Parent {};

In this example, since the Parent class has a default constructor, the Child class will also have one.

Parameterized Constructors

When we define our own constructors with parameters, these constructors are not inherited by child classes. Instead, each child class must provide its own implementation of the constructor or call the parent class's constructor using the base() keyword.

// Parent class with a parameterized constructor
class Parent {
public:
Parent(int param) { // Parameterized constructor implementation }
};

// Child class inheriting from the parent class and providing its own constructor
class Child : public Parent {
public:
Child(int childParam) : Parent(childParam * 2) { // Calling parent's constructor with an adjusted parameter }
};

In this example, the Parent class has a parameterized constructor. The Child class inherits from the Parent class and provides its own constructor that calls the parent's constructor using the base() keyword. In this case, the child's constructor multiplies the input parameter by 2 before passing it to the parent's constructor.

Initializer Lists

C++11 introduced initializer lists, which provide a more flexible and safer way to initialize objects. When using initializer lists, you can easily call base class constructors with a specific order of initialization.

// Parent class with a parameterized constructor
class Parent {
public:
Parent(int param) : m_param(param) {} // Initializing member variable
private:
int m_param;
};

// Child class inheriting from the parent class and using initializer lists
class Child : public Parent {
public:
Child(int childParam, int parentParam) : Parent(parentParam), m_childParam(childParam) {} // Initializing member variables in a specific order
private:
int m_childParam;
};

In this example, the Parent class has a parameterized constructor that initializes a private member variable (m_param). The Child class uses an initializer list to call the parent's constructor first (with the parentParam argument) and then initializes its own member variable (m_childParam) using the childParam argument.

Worked Example

Let's consider a simple example of inheritance with constructors:

// Base class
class Shape {
public:
Shape(double side) : m_side(side) {} // Parameterized constructor initializing member variable
double getSide() const { return m_side; }
private:
double m_side;
};

// Derived class
class Square : public Shape {
public:
Square(double side) : Shape(side), m_isSquare(true) {} // Calling base class constructor and initializing member variable
bool isSquare() const { return m_isSquare; }
private:
bool m_isSquare;
};

In this example, we have a Shape base class with a parameterized constructor that initializes a private member variable (m_side). The Square derived class inherits from the Shape class and provides its own constructor that calls the base class's constructor using the base() keyword. Additionally, it initializes a boolean member variable (m_isSquare) to indicate whether the shape is indeed a square.

Common Mistakes

Not calling the parent class constructor: When deriving a child class with parameterized constructors, remember to call the parent's constructor using the base() keyword or initializer lists.
Incorrect order of initialization: Inherited member variables should be initialized before derived member variables when using initializer lists.
Forgetting to provide a constructor for the child class: If the parent class has parameterized constructors, the child class must also have at least one constructor that calls the parent's constructor using the base() keyword or initializer lists.
Not defining default constructors when necessary: If a derived class does not provide any constructors and inherits only from a class with no default constructor, a compilation error will occur.
Confusing function overloading with constructor overloading: Constructors cannot be overloaded like regular functions; they can only differ in the number and types of their parameters.
Not initializing member variables: If a member variable is not initialized explicitly in a constructor, it will have an undefined value by default. This can lead to runtime errors if the variable's value is used before being properly initialized.
Using deleted constructors improperly: Deleted constructors are used to prevent implicit conversions or copying of objects. However, they should not be used without a clear understanding of their purpose and potential consequences.
Ignoring the rule of three (or five): The rule of three (or five) states that if you define a custom constructor, assignment operator, destructor, copy constructor, move constructor, or move assignment operator for your class, it's essential to implement all of them correctly to avoid memory leaks and other issues.
Not understanding the difference between copy construction and shallow/deep copying: Copy construction is the process of creating a new object as a copy of an existing one, while copy assignment is the process of assigning the value of one object to another. Shallow copying creates a new object with the same pointer values as the original, while deep copying creates a new object with separate memory allocations for each member variable.
Not handling exceptions properly in constructors: Constructors can throw exceptions if an error occurs during initialization. It's essential to ensure that any exception thrown by a constructor is properly handled and propagated up the call stack to prevent unhandled exceptions.

Practice Questions

Write a Rectangle class that inherits from the Shape class and provides its own constructor to initialize both the base class's member variable (side) and an additional member variable (height).
Modify the previous example so that the Square class also checks whether the provided side is a square number before initializing the boolean member variable (m_isSquare).
Write a Circle class that inherits from the Shape class and provides its own constructor to initialize both the base class's member variable (radius) and an additional member variable (color).
Modify the Circle class so that it calculates the area of the circle using the formula πr² in its constructor.
Write a ComplexNumber class that inherits from the Shape class (for the sake of this exercise, assume that complex numbers can be represented as shapes with imaginary sides). Provide a constructor that initializes both the real and imaginary parts of the complex number.
Modify the ComplexNumber class so that it calculates the magnitude (sqrt(real² + imaginary²)) in its constructor.
Write a Student class that inherits from the Shape class (for the sake of this exercise, assume that students can be represented as shapes with their grades as sides). Provide a constructor that initializes both an array of grades and the total grade (average of all grades) for the student.
Modify the Student class so that it calculates the total grade in its constructor by summing up the grades and dividing by the number of grades.
Write a Person class that inherits from the Shape class (for the sake of this exercise, assume that people can be represented as shapes with their ages as sides). Provide a constructor that initializes both an array of ages for family members and the total age (sum of all ages) for the family.
Modify the Person class so that it calculates the total age in its constructor by summing up the ages of all family members.

FAQ

Why can't we overload constructors like regular functions?

Constructors cannot be overloaded like regular functions because their names are implicitly identical to the class name. Overloading constructors would create ambiguity, as there would be multiple constructors with the same name but different parameter lists.

What happens when we don't provide any constructor for a derived class?

If a derived class does not provide any constructors and inherits only from a class with no default constructor, a compilation error will occur because there is no way to create an object of the derived class without calling its constructor.

Can we inherit from multiple classes in C++?

Yes, C++ supports multiple inheritance, allowing a class to inherit properties and methods from more than one parent class. However, care must be taken to avoid ambiguities and conflicts between inherited members.

What is the difference between copy construction and shallow/deep copying?

Copy construction is the process of creating a new object as a copy of an existing one, while copy assignment is the process of assigning the value of one object to another. Shallow copying creates a new object with the same pointer values as the original, while deep copying creates a new object with separate memory allocations for each member variable.

Can we call a derived class's member function from the base class constructor?

No, it is not possible to call a derived class's member function directly from the base class constructor. However, you can call the base class constructor and then access derived member functions through a pointer or reference to the derived object.

What is the purpose of initializer lists in constructors?

Initializer lists provide a safer and more flexible way to initialize objects by ensuring the order of initialization is correct, reducing the chance of errors, and making it easier to call base class constructors with specific arguments.

Can we delete constructors?

Yes, deleted constructors can be used to prevent implicit conversions or copying of objects. However, they should not be used without a clear understanding of their purpose and potential consequences.

What is the rule of three (or five)?

The rule of three (or five) states that if you define a custom constructor, assignment operator, destructor, copy constructor, move constructor, or move assignment operator for your class, it's essential to implement all of them correctly to avoid memory leaks and other issues.

Why is it important to handle exceptions properly in constructors?

Constructors can throw exceptions if an error occurs during initialization. It's essential to ensure that any exception thrown by a constructor is properly handled and propagated up the call stack to prevent unhandled exceptions, which could lead to program crashes or other unexpected behavior.

What are some common mistakes when managing constructors in inheritance?

Common mistakes include not calling the parent class constructor, incorrect order of initialization, forgetting to provide a constructor for the child class, not defining default constructors when necessary, confusing function overloading with constructor overloading, not initializing member variables, using deleted constructors improperly, ignoring the rule of three (or five), and not handling exceptions properly in constructors.