- In our previous article of “Function Overloading”, we had discussed how a function can be overloaded.
- In this article, we will focus on Constructor Overloading.
- Similar to other normal function, we can also overload the constructor.
- Consider the following class ‘Rectangle’ in which we are using multiple constructors (Overloading Constructor)
Rectangle( ) ; // default constructor
Rectangle(int, int); // Parameterized constructor
Rectangle(Rectangle &); // Copy constructor
Rectangle :: Rectangle( )
length = 0;
width = 0;
Rectangle :: Rectangle(int l, int w)
length = l;
width = w;
Rectangle :: Rectangle(Rectangle &o)
length = o.length;
width = o.width;
// driver function
void main( )
Rectangle r1; // Calls default constructor
Rectangle r2(20, 30); // Call parameterized constructor
Rectangle r3 = r2; // Calls copy constructor
- In above example we are using three different constructor functions in class Rectangle.
- First constructor is default constructor and has no argument.
- Second constructor is parameterized constructor and has two arguments of integer type.
- Third constructor is the copy constructor and it uses the reference of same class object as argument.
- Also as shown in the main function we can call first constructor by simply creating object.
- We can call second constructor by passing argument during object creation.
Rectangle r2(20, 30);
- We can call third constructor by copy initialization method. Also we can call by passing argument of object of type rectangle.
Rectangle r3 = r2;
- So as we ca see that we can also define multiple constructors for creating objects in different manner based on our requirement.
- When we need empty object to be created, we simply call default constructor.
- Similarly, if we need to create an object populated with some initial data, we can call parameterized constructor for the same.
- This way, constructor overloading allows us to define multiple constructors with initialize objects differently based on our choice.