Constructors in C++
What is constructor?
A constructor is a member function of a class which initializes objects of a class. In
C++, Constructor is automatically called when object(instance of class) create. It is
special member function of the class.
How constructors are different from a normal member function?
A constructor is different from normal functions in following ways:
● Constructor has same name as the class itself
● Constructors don’t have return type
● A constructor is automatically called when an object is created.
● If we do not specify a constructor, C++ compiler generates a default
constructor for us (expects no parameters and has an empty body).
Types of Constructors
1.Default Constructors: Default constructor is the constructor which doesn’t take any
argument. It has no parameters.
// Program to illustrate the concept of Constructors
#include <iostream.h>
class construct
{
public:
int a, b;
construct() // Default Constructor
{
a = 10;
b = 20;
}
};
int main()
{
// Default constructor called automatically
// when the object is created
construct c;
cout << "a: " << c.a << endl
<< "b: " << c.b;
return 1;
}
Output:
a: 10
b: 20
Note : Even if we do not define any constructor explicitly, the compiler will automatically
provide a default constructor implicitly.
2. Parameterized Constructors: It is possible to pass arguments to constructors.
Typically, these arguments help initialize an object when it is created. To create a
parameterized constructor, simply add parameters to it the way you would to any other
function. When you define the constructor’s body, use the parameters to initialize the
object.
// CPP program to illustrate parameterized constructors
#include <iostream>
using namespace std;
class Point {
private :
int x, y;
public :
Point(int x1, int y1) // Parameterized Constructor
{
x = x1;
y = y1;
}
int getX()
{
return x;
}
int getY()
{
return y;
}
};
int main()
{
Point p1(10, 15); // Constructor called
// Access values assigned by constructor
cout << "p1.x = " << p1.getX() << ", p1.y = " << p1.getY();
return 0;
}
Output:
p1.x = 10, p1.y = 15
When an object is declared in a parameterized constructor, the initial values have to be
passed as arguments to the constructor function. The normal way of object declaration
may not work. The constructors can be called explicitly or implicitly.
Example e = Example(0, 50); // Explicit call
Example e(0, 50); // Implicit call
Uses of Parameterized constructor:
a. It is used to initialize the various data elements of different
objects with different values when they are created.
b. It is used to overload constructors.
Can we have more than one constructors in a class?
Yes, It is called Constructor Overloading.
3.Copy Constructor: A copy constructor is a member function which initializes an object
using another object of the same class.
Whenever we define one or more non-default constructors( with parameters ) for a
class, a default constructor( without parameters ) should also be explicitly defined as
the compiler will not provide a default constructor in this case. However, it is not
necessary but it’s considered to be the best practice to always define a default
constructor.
class point {
private:
double x, y;
public:
// Non-default Constructor & default Constructor
point (double px, double py) {
x = px, y = py;
}
};
int main(void) {
// Define an array of size 10 & of type point
// This line will cause error
point a[10];
// Remove above line and program will compile without error
point b = point(5, 6);
}
Destructors in C++
What is destructor?
Destructor is a member function which destructs or deletes an object.
When is destructor called?
A destructor function is called automatically when the object goes out of scope :
(1) the function ends
(2) the program ends
(3) a block containing local variables ends
(4) a delete operator is called
How destructors are different from a normal member function?
● Destructors have same name as the class preceded by a tilde (~)
● Destructors don’t take any argument and don’t return anything
class String
{
private:
char *s;
int size;
public:
String(char *); // constructor
~String(); // destructor
};
String::String(char *c)
{
size = strlen(c);
s = new char[size+1];
strcpy(s,c);
}
String::~String()
{
delete []s;
}
Can there be more than one destructor in a class?
No, there can only one destructor in a class with classname preceded by ~, no
parameters and no return type.
When do we need to write a user-defined destructor?
If we do not write our own destructor in class, compiler creates a default destructor for
us. The default destructor works fine unless we have dynamically allocated memory or
pointer in class. When a class contains a pointer to memory allocated in class, we
should write a destructor to release memory before the class instance is destroyed.
This must be done to avoid memory leak.
Can a destructor be virtual?
Yes, In fact, it is always a good idea to make destructors virtual in base class when we
have a virtual function.
Virtual Destructor
Deleting a derived class object using a pointer to a base class that has a non-virtual
destructor results in undefined behavior. To correct this situation, the base class should
be defined with a virtual destructor. For example, following program results in undefined
behavior.
// CPP program without virtual destructor causing undefined behavior
#include<iostream.h>
class base {
public:
base()
{ cout<<"Constructing base \n"; }
~base()
{ cout<<"Destructing base \n"; }
};
class derived: public base {
public:
derived()
{ cout<<"Constructing derived \n"; }
~derived()
{ cout<<"Destructing derived \n"; }
};
int main(void)
{
derived *d = new derived();
base *b = d;
delete b;
getchar();
return 0;
}
Although the output of following program may be different on different compilers, when
compiled using Dev-CPP, it prints following:
Constructing base
Constructing derived
Destructing base
Making base class destructor virtual guarantees that the object of derived class is
destructed properly, i.e., both base class and derived class destructors are called.
For example,
// A program with virtual destructor
#include<iostream.h>
class base {
public:
base()
{ cout<<"Constructing base \n"; }
virtual ~base()
{ cout<<"Destructing base \n"; }
};
class derived: public base {
public:
derived()
{ cout<<"Constructing derived \n"; }
~derived()
{ cout<<"Destructing derived \n"; }
};
int main(void)
{
derived *d = new derived();
base *b = d;
delete b;
getchar();
return 0;
}
Output:
Constructing base
Constructing derived
Destructing derived
Destructing base
As a guideline, any time you have a virtual function in a class, you should immediately
add a virtual destructor (even if it does nothing).
