Destructor

Similar to constructor, a class has another special member function called destructor. Destructor cleans up the object.  

When an object goes out of scope, the destructor is automatically called. Destructor is also called when the pointer to the object is released using delete operator.

Destructor has a same name as class and is preceded by tilde (~) symbol. 

Class A has a destructor ~A()

 

Destructor should be used to clean up the object -  release memory and other resources, close files, stop threads etc.

#include <iostream>
using namespace std; 
class Arr
{
 int *elements;
 int len;
public:
 Arr(int len=5);
 ~Arr();//destructor
 int & operator[](int index);
};
Arr::Arr(int len)
{
 elements = new int[len];
}
Arr::~Arr()
{
 delete []elements;
}
int & Arr::operator[](int index)
{
 return elements[index];
} 
int main()
{
 Arr obj(10);
 for(int i=0;i<10;i++)
 obj[i] = i*i; 
} 
 

In the above code, you see the destructor of class Arr, which  releases the memory  allocated by constructor. The object obj is destroyed when main function terminates, and its destructor is called which releases memory.

Destructor takes no parameters. So destructor can not be overloaded.

If there is no user defined destructor, then compiler provides a trivial destructor.

The example shown above uses dynamic memory and hence needs user defined destructor to release memory.

Order of destructor call

Destructor of an object is called when the object is being destroyed - that is when the object goes out of scope.

1. For global objects, destructor is called at the end of the program.
2. For local objects, it is called when the block exits.
3. For parameters and return values, it is called when the function exits.
4. For dynamically created objects, destructor is called when delete operator is used.
   

Also note that the order of destructors is the opposite of order of constructors. Which means that the object created last, is destroyed first.

The program below shows the order of destructors.

class A
{
 int num;
public:
 A(int n):num(n){cout<<"constructor"<<n<<endl;}
 ~A()
 {
 cout<<"Destructor";
 }
};
int main()
{
 A obj1(10); 
 if(10>5)
 {
 A obj3(15);
 }
 A obj2(12);
}

The output of the program above will be

constructor10
constructor15
Destructor15
constructor12
Destructor12
Destructor10

Note :

• Compiler provides the following 4 functions automatically for a class
1. Default constructor - if the class has no other constructors
2. Copy Constructor
3. Destructor
4. Assignment operator
   
• Destructor should be public. If not, objects of class can not be destroyed.

You will find all these notes, quiz and complete programs in Simplified C++ app by Hegdeapps