C++ Program for Constructor Overloading | C++ Programming

Constructor Overloading

When more than one constructor function is defined in a class, then it is called constructor overloading or the use of multiple constructors in a class. It is used to increase the flexibility of a class by having a greater number of constructors for a single class. Overloading constructors in C++ programming gives us more than one way to initialize objects in a class.

The Class Constructor

A class constructor is a special member function of a class that is executed whenever we create new objects of that class.

A constructor will have the exact same name as the class and it does not have any return type at all, not even void. Constructors can be very useful for setting initial values for certain member variables.

Following example explains the concept of constructor −

#include 
using namespace std; 
class Line { public: 
void setLength( double len ); 
double getLength( void ); 
Line(); // This is the constructor 
private: 
double length;}; // Member functions definitions including constructorLine::Line(void) 
{ 
 cout << "Object is being created" << 
endl;
}
void Line::setLength( double len ) 
{ 
 length = len;}double Line::getLength( void ) 
{ 
return length;
}// Main function for the program
int main() 
{ 
Line line; // set line length 
line.setLength(6.0); 
cout << "Length of line : " << 
line.getLength() <<
endl; 
return 0;
}

When the above code is compiled and executed, it produces the following result −

Object is being created
Length of line : 6

Parameterized Constructor

A default constructor does not have any parameter, but if you need, a constructor can have parameters. This helps you to assign an initial value to an object at the time of its creation as shown in the following example −

#include 
using namespace std;
class Line 
{ 
public: 
void setLength( double len ); 
double getLength( void ); 
Line(double len); // This is the constructor 
private: 
double length;}; // Member functions definitions including constructorLine::Line( double len) 
{ 
 cout << "Object is being created, length = " << 
len << 
endl;
length = len;
}
void Line::setLength( double len ) 
{ 
 length = len;
}
double Line::getLength( void ) 
{ 
return length;
} 
// Main function for the program
int main() 
{ 
Line line(10.0); // get initially set length. 
 cout << "Length of line : " << 
line.getLength() <<endl; // set line length again line.setLength(6.0); 
cout << "Length of line : " << 
line.getLength() <<
endl; 
return 0;
}

When the above code is compiled and executed, it produces the following result −

Object is being created, length = 10
Length of line : 10
Length of line : 6

C++ Program for Constructor Overloading

#include<iostream>
using namespace std;
class item
{
int code,price;
public:
item()
{
code=0; price=0;
}
item(int c, int p)// Over Loading Constructor
{
code=c; price=p;
}
ite5m(item &x)
{
code=x.code; price=x.price;
}
void display()
{
cout<<"\ncode:"<<code<<"\nPrice:"< }
};
int main()
{
item i1;
item i2(102,300);//Passing Value
item i3(i2);
i1.display();
i2.display();
i3.display();
}