C++ Constructor

Constructor is a specific method in C ++ that is automatically called when an object is created. Typically, it is used to set the data members of a new object. In C++, the function Object () is referred to as a class or structure.

What distinguishes constructors from regular member functions?

• The function Object () { [native code] } has the same name as the class.
• Default although constructors do not have an input argument, Copy and Parameterized do. Input parameters are sent to constructors.
• There is no return type for constructors.
• When an object is formed, the function Object() { [native code] } is automatically invoked.
• It must be shown in the classroom's public area.
• If a function object () {[native code] is not specified, the C ++ compiler creates the default function object () {[native code] for the object (no parameters are expected and the body is empty).cpp-constructor1.png

Types of Constructor in C++

• Default constructor
• Parameterized constructor
• Copy Constructor

Default Constructor

Constructors that take no arguments are called default constructors. When creating an object.

Example of a program containing constructor in C++:

#include <bits/stdc++.h>
#include <iostream>
using namespace std;
class construct
{
public:
int i,j; 
// Default Constructor
construct()
{
i= 23;
j= 45;
}
};
int main()
{
// Default constructor called automatically
// when the object is created
construct k
cout << "i: " << k.i << endl
<< "j: " << k.j;
return 1;
}

OUTPUT:

i: 23
j: 45

Explanation:

Even if we don't explicitly declare a function Object (), the compiler will offer a default function Object() implicitly.

Parameterized constructor

Arguments can be sent to the constructor. These parameters are often used to help start an object when it is created. Just add arguments to the parameterized function object (). The same way you would for any other task. Use arguments to initialize the object while defining the main body of the constructor.

Example of a program containing parameterized constructor in C++:

#include <stdlib>
#include <bits/stdc++.h>
#include <iostream>
using namespace std; 
class Const
{
private:
int i, j;




public:
// Parameterized Constructor
Const(int i1, int j1)
{
i = i1;
j = j1;
}
int getI()
{
return i;
}
int getJ()
{
return j;
}
};
int main()
{
// Constructor called
Const C1 (23, 34); 
// Access values assigned by constructor
cout << "C1.i = " << C1.getI() << ", C1.j = " << C1.getJ();
return 0;
}

OUTPUT:

 C1.i = 23 , C1.j = 34

Explanation:

The initial values must be passed as arguments to the function Object (). Function when an object is declared in a parameterized function Object (). It's possible that the standard method of object definition won't work. Constructors can be invoked either explicitly or implicitly.

NOTE: When objects are formed, it is used to initialize the various data components with distinct values. It's used to make constructors overloaded.

IMPORTANT: We can have more than one constructor in a class.

Copy Constructor

A copy function Object () is a member function that uses another object of the same class to initialize an object. When we declare one or more non-default constructors (with arguments) for a class, we need additionally provide a default constructor (without parameters), as the compiler will not give one in this situation. It is not required, but it is regarded best practice to declare a default function Object () at all times.

Example of program containing copy constructor in C++:

#include <iostream>
#include <stdlib>
#include <bits/stdc++.h>
using namespace std; 
class Const
{
private:
double i, j; 
public: 
// Non-default Constructor &
// default Constructor
Const (double Ci, double Cj)
{
i = Ci, j = Cj;
}
};
int main(void)
{
// Define an array of size
// 10 & of type point
// This line will cause error
Const x[26]; 
// Remove above line and program
// will compile without error
Const y = Const(1, 4);
}

OUTPUT:

error: point (double Ci, double Cj): expects 2 arguments, 0 provided

Explanation

In the above program in C++, If a new item is produced as a copy of an existing item, a copy maker is requested.

Another Example:

#include<iostream>
#Inlcude<stdlib>
#include<bits/stdc++.h>
using namespace std; 
class const
{
int i, j;
public:
const (int x = 14, int y = 34 )
{
i = x;
j = y;
}
void Display()
{
cout<< i << " " << j << endl;
}
};
int main()
{
const val;
val.Display();
return 0;
}

OUTPUT:

Parameterized constructor (Output will be 14,34)

Explanation:

The compiler does not produce the default function Object (). When we define any function Object () in a class. In this scenario, the same thing happens, but because the parameterized function Object () has default values for all of the parameters, it is called. However, if you specify default function Object () here, the compiler will throw an error (ambiguous call) since it won't know which function Object () to call.