Constructor and Destructor in C++

Default Constructor

The default constructor is basically the most basic type of constructor which doesn’t take any type of passing arguments.

For Example –

class A
{
int i;
public:
A()
 {
  i=1;
 }
};

int main()
{
A a;
cout << a.i;
}

When the object is created with A a; automatically our defined constructor is called and assigned a value of 1;

Output : 1

Even if, we don’t create a constructor the complier implicitly will call its own default constructor –

Example –

#include <iostream>
using namespace std;
class A
{
public:
int i;
};

int main()
{
A a;
cout << a.i;
}

• In this case the output will be 0.
• The compiler calls its own default constructor and assigns a value of 0.
• It may be any value randomly chosen by computer not necessarily 0.

Parameterised Constructors

In the extension of default constructor, we pass arguments in the constructor call and set values.

Example –

#include
using namespace std;
class A
{
  public:
    int i;
    A(int val)
    {
       i=val;
    }
};
int main()
{
    //setting parameterised values
    A a(10);
    A a2(20)
    cout << a.i;
    cout << a2.i;
}

Output will be 10 and 20.

Copy Constructor

These are the special type of Constructors which takes an object as an argument, and is used to copy values of data members of one object into another object.

Syntax –

class_name (class-name &){
....
}

• Copy Constructor is a type of constructor which is used to create a copy of an already existing object of a class type.
• It is usually of the form X (X&), where X is the class name.
• The compiler provides a default Copy Constructor to all the classes.

#include <iostream>
using namespace std;

class PrepInsta 
{ 
private: 
    int x, y; 
public: 
    PrepInsta()
    {

    }
    PrepInsta(int x1, int y1) 
    { 
        x = x1; 
        y = y1;

        cout << "Parameterized constructor called here" << endl;

    } 

    // Copy constructor 
    PrepInsta(const PrepInsta &p2) 
    {
        x = p2.x; 
        y = p2.y; 

        cout << "Copy constructor called here" << endl;

    } 

    int getX()            
    {  
        return x; 

    } 
    int getY()            
    {  
        return y; 

    } 
}; 

int main() 
{ 
      // Trying to call parameterized constructor here
    PrepInsta p1(10, 15); 
      // Trying to call copy constructor here 
    PrepInsta p2 = p1; 
      // Trying to call Copy constructor here
    PrepInsta p3(p1);
    PrepInsta p4;
 // Here there is no copy constructor called only assignment operator happens
    p4 = p1;
    cout << "For p4 & p3 no copy constructor called only assignment operation happens" << endl;


      // displaying values for both constructors 
    cout << "p1.x = " << p1.getX() << ", p1.y = " << p1.getY();
    cout << "\np2.x = " << p2.getX() << ", p2.y = " << p2.getY(); 

    cout << "\np3.x = " << p3.getX() << ", p3.y = " << p3.getY(); 
    cout << "\np4.x = " << p4.getX() << ", p4.y = " << p4.getY(); 
    return 0; 
}

In the above example there are two ways to call copy constructor –

• PrepInsta p2 = p1;
• PrepInsta p3(p1);

However, PrepInsta p4; followed by p4 = p1; doesn’t call copy constructor, its just simply and assignment operator

Output

Parameterized constructor called here 
Copy constructor called here 
Copy constructor called here 
For p4 & p3 no copy constructor called only assignment operation happens 

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

Read more about Copy Constructors here

Reference

Constructor Overloading

Both Default and Parameterised constructors can be overloaded

Example –

#include<iostream> 
using namespace std; 

class A{ 
  int x, y;
  public:
  A(int a)
 {
    x=a;
    y=0;
    cout<<"I am called and only a(10) was called\n";
  }

  A(int a, int b)
  {
    cout<<"I am called and a(10,20) was called\n";

    x=a;
    y=b;

  }
};

int main()
{
  A a(10);
  A b(10, 20);
}

​