Constructor Overloading

Constructor Overloading is same as that of method overloading. The only difference between constructor overloading and method overloading is, In method overloading we'll overload methods, in constructor overloading we'll overload constructors. Having multiple constructor with same name but each constructor having either total number of parameter different or datatype of the parameters different is known as Constructor Overloading.

CODE

EG 1 . Creating Rectangle class with constructor.

#include <iostream>
using namespace std;

class Rectangle {
  public:
    double length, width, height, density;
    //Constructor Overloading
    Rectangle(double l,double w,double h,double d) {
        length = l;
        width = w;
        height = h;
        density = d;
    }
    Rectangle(double l, double w, double h) {
        length = l;
        width = w;
        height = h;
        density = 1;
    }
    Rectangle(double l) {
        length = l;
        width = 1;
        height = 1;
        density = 1;
    }
    //Default Constructor
    Rectangle() {
        length = 1;
        width = 1;
        height = 1;
        density = 1;
    }

    double Area() {
        return length * width;
    }
    double Perimeter() {
        return 2 * (length+width);
    }
    double Volume() {
        return Area() * height;
    }
    double Weight() {
        return Volume() * density;
    }
    void RectangleCalculation() {
        cout << Area() << endl;
        cout << Perimeter() << endl;
        cout << Volume() << endl;
        cout << Weight() << endl;
    }
};

int main() {
        //Invoking constructor with 4 Parameters
        Rectangle wall(5, 6, 7, 2.8);
        wall.RectangleCalculation();
        cout << endl; //Giving empty line

        //Invoking constructor with 3 Parameters
        Rectangle cupboard(7,8,9);
        cupboard.RectangleCalculation();
        cout << endl;

        //Invoking constructor with 1 Parameter
        Rectangle monitor(10);
        monitor.RectangleCalculation();
        cout << endl;

        //Invoking default constructor.
        Rectangle door;
        door.RectangleCalculation();
        cout << endl;
}

OUTPUT
30
22
210
588

56
30
504
504

10
22
10
10

1
4
1
1

CODE EXPLANATION
In the above code inside Rectangle class, we created 4 Rectangle constructor overloads(Even Default constructor will also be taken as a overload). In main method while creating instance of Rectangle class depending on the number of arguments what we going to pass, system will invoke respective constructor overload.


What is the use of Constructor, Constructor overloading and where to use it?
constructors are used to automatically assign the values of fields present inside a class.
In order to explain this let us take the above code example,
If we didn't create Rectangle class constructor then only way to assign the values to fields is manually calling objectName.VariableNames which consumes lot of time. Just because we created Rectangle constructor, we can only pass the values inside () which presents after object name, system will automatically invoke constructor overload and assign the values to its respective fields. Just because this operation is taking place automatically we are saving up lot of time.

Exercises
1. Create a Traingle class with 5 constructor overloads.


(Click Here, For more exercises)