Constructor Overloading in C++

Last Updated on December 8, 2023 by Ankit Kochar

C++ is an Object-Oriented Programming Language that is widely used today in the IT industry all over the world. It is a foundational programming language that supports the OOPs Concepts, it was created in 1979 by Bjarne Stroustrup at AT&T Bell Labs. Constructor overloading in C++ is a powerful feature that allows a class to have multiple constructors, each with a different parameter list. This enables the creation of objects with varied initialization options, enhancing the flexibility and usability of a class. Constructor overloading is a fundamental concept in C++ object-oriented programming, offering developers the ability to define multiple ways to instantiate objects based on the specific requirements of the application. This feature simplifies object creation and initialization, making C++ code more adaptable and versatile. This concept is famously known as Constructor Overloading in C++ and is very much similar to function overloading in C++. We will dive deep into this concept and understand what exactly Constructor Overloading in C++ means. Before that let’s see what is a constructor in brief.

What is a Constructor in C++?

A constructor is a special type of method in a class that is called when an object of that class is created. The main objective of a constructor is to initialize all the data members of a class to default value(set to zero) when an object of that class is created. A constructor must have the same name as the class and it does not have a return type, not even void.

Types of Constructors

There are three types of constructors:-

• Default Constructor
• Parameterized Constructor
• Copy Constructor

What is Operator Overloading in C++?

The concept of defining multiple constructors for a class with different parameters is known as constructor overloading in c++. In simple words, a class can have more than one constructor, each constructor has its own different set of distinct parameters. Constructor overloading allows a class to be initialized in a variety of ways based on the requirements of the user.

Here are some examples of valid and invalid constructor overloading in c++:

1. Multiplication(int x, int y) and Multiplication(double x, double y) – This can be considered a valid example of constructor overloading.

2. Addition(int x, int y) and Addition(int x, double y) – This is a valid example of constructor overloading.

3. Subtraction(float x, float y) and Subtraction(float x, float y) – This is a invalid example of constructor overloading.

4. Addition(int x, int y) and Addition(int x, int y, int z) – This can be considered a valid example of constructor overloading.

How to Declare Constructor Overloading in C++

Here is the Syntax of Constructor Overloading in C++:

class ClassName {
    public:
        ClassName() {
           // Constructor with no parameter.
        }
        ClassName(int x, double y) {
           // Constructor with two parameters.
        }
        ClassName(int x, char y, float z) {
           // Constructor with three parameters.
        }
        ClassName(ClassName & object) {
           // Constructor with the same class object as a parameter.
        }
        // Other member functions.
};

Examples of Constructor Overloading in C++

Let’s see some examples of constructor overloading in c++

Example 1 of Constructor Overloading in C++
Here is a C++ program to overload two constructors.

#include <iostream>
using namespace std;

class Person{
    private:
        string Name;
        int Age;
        
    public:
        // This is a Constructor with no parameters.
        Person() {
            Name = "Anoop";
            Age = 25;
        }
        
        // This is a Constructor with two parameters.
        Person(string str, int x) {
            Name = str;
            Age = x;
        }
        
        // Member functions declaration.
        string get_Name() {
            return Name;
        }
        int get_Age() {
            return Age;
        }
};

int main() {
    Person p1, p2("PrepBuddy", 28);
    cout << "Name: " << p1.get_Name() << " Age: " << p1.get_Age() << endl;
    cout << "Name: " << p2.get_Name() << " Age: " << p2.get_Age() << endl;
    return 0;
}

Output:

Name: Anoop Age: 25
Name: PrepBuddy Age: 28

Explanation: In the above C++ program, we have created a class with the name Person which contains two variables i.e Name and Age. We have also defined two constructors, Person() and Person(string str, int x). The first constructor is called when we create object p1 because we have not passed any parameter. The second constructor is called when we create object p2 because we have passed two parameters(i.e str and x) with it. The get_Name() and get_Age() methods return the Name and Age, which we use to print the name and age of objects p1 and p2.

Example 2 of Constructor Overloading in C++
Here is a C++ program to overload three constructors.

#include <iostream>
using namespace std;

class Area {
    private:
      // Member Variable Declaration.
        int area;
        
    public:
        // This is a Constructor with no parameters.
        Area() {
            area = 0;
        }
        // This is a Constructor with one parameters.
        Area(int side) {
            area = side * side;
        }
        // This is a Constructor with two parameters.
        Area(int length, int width) {
            area = length * width;
        }
        // Member function declaration.
        int disp() {
            return area;
        }
};

int main() {
    Area point;
    Area square(5);
    Area rectangle(6, 9);
    cout << "Area of point: " << point.disp() << endl;
    cout << "Area of square: " << square.disp() << endl;
    cout << "Area of rectangle: " << rectangle.disp() << endl;
    return 0;
}

Output:

Area of point: 0
Area of square: 25
Area of rectangle: 54

Explanation: In the above C++ program, we have created a class with the name Area which contains only one variable i.e, area. Inside our class we have defined three constructors, Area(), Area(int side), and Area(int length, int width). The first constructor, Area(), is called when we create object point because we have not passed any parameter. The second constructor, Area(int side), is called when we create object square because we have passed one parameter(i.e, side). The third constructor, Area(int length, int width), is called when we create object rectangle because we have passed two parameters(i.e, length and width) with it.

Advantages of Using Constructor Overloading in C++

Listed Below are some advantages of using constructor overloading in C++:

1. Because of constructor overloading, inside a class we can declare multiple constructors with different parameters, this helps in providing flexibility in terms of how objects of that class can be created.

2. Constructor overloading helps us reuse the code by invoking one constructor from another constructor of the same class, this results in the reduction of code duplication and makes the maintenance of code very easier for us.

3. We can optimize the efficiency of our program by avoiding unnecessary initialization and by minimizing the chances of errors by implementing constructor overloading.

Disadvantages of using Constructor Overloading in C++

While constructor overloading provides several advantages, there are also some potential disadvantages that we must consider before overloading a constructor:

1. Has a Confusing and complex syntax which makes it more difficult to understand and maintain the code.

2. Each overloaded constructor adds more code to the class which can increase the size of the executable file and makes the program run slower.

3. It makes the debugging process difficult because multiple constructors are used. So, it is kinda hard to identify the source of the error.

Conclusion
Constructor overloading in C++ is a valuable technique that contributes to the design and implementation of flexible and user-friendly classes. By providing multiple constructors with different parameter lists, developers can tailor object creation to specific scenarios, making their code more adaptable and expressive. This feature is integral to the principles of polymorphism and encapsulation in C++, allowing for the creation of classes that are both versatile and maintainable.
In conclusion, constructor overloading is a crucial aspect of C++ programming, empowering developers to create classes that can be instantiated in various ways, depending on the context and requirements of the application.

FAQs related to constructor overloading in C++

Here are some frequently asked questions on constructor overloading in c++.

Q1: Is it possible for a constructor to be private?
Ans: Yes, it is possible for a constructor to be private in C++. A private constructor is useful for implementing the Singleton design pattern which states that a class should only have one instance. By making the constructor private, it is not possible to instantiate the class from outside and the Singleton instance can be controlled.

Q2: How does the compiler differentiate between overloaded constructors?
A2: The compiler differentiates between overloaded constructors based on the number and types of parameters. When creating an object, the appropriate constructor is selected based on the arguments provided in the object instantiation.

Q3: Can a class have both default and parameterized constructors through overloading?
A3: Yes, a class can have both default and parameterized constructors through overloading. This allows objects to be created with default values or with specific initialization parameters.

Q4: What is the benefit of constructor overloading in C++?
A4: Constructor overloading enhances the flexibility of a class by providing multiple ways to create objects. This improves code adaptability, allowing developers to instantiate objects based on different scenarios and requirements.

*Q5: Is constructor overloading specific to C++ or applicable in other programming languages?–
A5:** Constructor overloading is a concept found in various object-oriented programming languages, including C++. While the syntax and rules may vary, the fundamental idea of defining multiple constructors with different parameter lists is common across languages like Java and C#.