Constructor overloading in C++

Constructor is a member function of a class that is used to initialize the objects of the class. Constructors do not have any return type and are automatically called when the object is created.

Characteristics of constructors

The name of the constructor is the same as the class name
No return type is there for constructors
Called automatically when the object is created
Always placed in the public scope of the class
If a constructor is not created, the default constructor is created automatically and initializes the data member as zero
Declaration of constructor name is case-sensitive
A constructor is not implicitly inherited

Types of constructors

There are three types of constructors -

Default constructor - A default constructor is one that does not have function parameters. It is used to initialize data members with a value. The default constructor is called when the object is created.

Code

#include <iostream>
using namespace std;
class construct // create a class construct
{
public:
	int a, b; // initialise two data members 
	construct() // this is how default constructor is created 
	{
	    // We can also assign both values to zero 
		a = 10; // intialise a with some value 
		b = 20; // initialise b with some value
	}
};
int main()
{	
	construct c; // creating an object of construct calls defualt constructor
	cout<< "a:" <<c.a<<endl
		<< "b:" <<c.b; // print a and b 
	return 1;
}

Output

a:10
b:20

Parameterized constructor - A non-parameterized constructor does have the constructor arguments and the value passed in the argument is initialized to its data members. Parameterized constructors are used in constructor overloading.

Code

#include <iostream>
using namespace std;
class Point // create point class
    {
private:
int x, y; // the two data members of class Point
public:
Point(int x1, int y1) // create paramterised Constructor and initialise data member
    {
        x = x1; // x1 is now intialised to x
        y = y1; // y1 is now intialised to y
    }
intgetX()
    {
return x; // to get the value of x
    }
intgetY()
    {
return y; // to get the value of y
    }
};
int main()
{
    Point p1(10, 15); // created object for paramterised constructor

cout<< "p1.x = " << p1.getX() << ", p1.y = " << p1.getY(); // print x and y

return 0;
}

Output

p1.x = 10, p1.y = 15

Explanation

Create a class point with two data members x and y. A parameterized constructor is created with the points x1 and y1 as parameters and the value of x and y are assigned using x1 and y1. In the main function, we create a parameterized constructor with the values (10, 15). Using the getter functions, we get the values of the data members.

Copy constructor - Copy constructor initializes an object using another object of the same class.

Syntax

class_name(constclassname&old_object).

Code

#include <iostream>
using namespace std;
class Point // create point class
    {
private:
int x, y; // data members of the class
public:
Point(int x1, int y1)
    {
        x = x1;
        y = y1;
    } // parameterised constructor

    // Copy constructor
Point(const Point& p1) // initialisation according to syntax
    {
        x = p1.x;
        y = p1.y;
    }
intgetX() { return x; } // return value of x
intgetY() { return y; } // return valur of y
};
int main()
{
    Point p1(10, 15); // call parameterised constructor
    Point p2 = p1; // call Copy constructor
    //  use getter and setter to print x and y
cout<< "p1.x = " << p1.getX() << ", p1.y = " << p1.getY();
cout<< "\np2.x = " << p2.getX() << ", p2.y = " << p2.getY();
return 0;
}

Output

p1.x = 10, p1.y = 15
p2.x = 10, p2.y = 15

Constructor overloading in C++

As there is a concept of function overloading, similarly constructor overloading is applied. When we overload a constructor more than a purpose it is called constructor overloading.

The declaration is the same as the class name but as they are constructors, there is no return type.

The criteria to overload a constructor is to differ the number of arguments or the type of arguments.

Code

// C++ program to demonstrate constructor overloading
#include <iostream>
using namespace std;
class Person { // create person class
private:
int age; // data member
public:
    // 1. Constructor with no arguments
Person()
    {
age = 20; // when object is created the age will be 20
    }
    // 2. Constructor with an argument
Person(int a)
{ // when parameterised Constructor is called with a value the
        // age passed will be initialised
age = a;
    }
intgetAge()
{ // getter to return the age
return age;
    }
};
int main()
{
    Person person1, person2(45); // called the object of person class in differnt way

cout<< "Person1 Age = " << person1.getAge() <<endl;
cout<< "Person2 Age = " << person2.getAge() <<endl;
return 0;
}

Output

Person1 Age = 20
Person2 Age = 45

Explanation

In the above program, we have created a class Person with one data member(age). There are two constructors in the class that are overloaded. We have overloaded the second constructor by providing one argument and making it parameterized.

So, in the main function when the object person1 is created, it calls the non-parameterized constructor and when person2 is created, it calls the parameterized constructor and performs the required operation of initializing the age. Hence, when object person1 age is printed it gives 20 that was set by default and person2 age gives 45 as it was passed by the object to the parameterized constructor.

Next TopicDefault arguments in C++

← prev next →