Open In App

Destructors in C++

Improve
Improve
Improve
Like Article
Like
Save Article
Save
Share
Report issue
Report

What is a destructor?

Destructor is an instance member function that is invoked automatically whenever an object is going to be destroyed. Meaning, a destructor is the last function that is going to be called before an object is destroyed.

  • A destructor is also a special member function like a constructor. Destructor destroys the class objects created by the constructor. 
  • Destructor has the same name as their class name preceded by a tilde (~) symbol.
  • It is not possible to define more than one destructor. 
  • The destructor is only one way to destroy the object created by the constructor. Hence destructor can-not be overloaded.
  • Destructor neither requires any argument nor returns any value.
  • It is automatically called when an object goes out of scope. 
  • Destructor release memory space occupied by the objects created by the constructor.
  • In destructor, objects are destroyed in the reverse of an object creation.

The thing is to be noted here if the object is created by using new or the constructor uses new to allocate memory that resides in the heap memory or the free store, the destructor should use delete to free the memory.   

Syntax

The syntax for defining the destructor within the class:

~ <class-name>() {
    // some instructions
}

The syntax for defining the destructor outside the class:

<class-name> :: ~<class-name>() {
    // some instructions
}

Example 1

The below code demonstrates the automatic execution of constructors and destructors when objects are created and destroyed, respectively.

C++




// C++ program to demonstrate the execution of constructor
// and destructor
 
#include <iostream>
using namespace std;
 
class Test {
public:
    // User-Defined Constructor
    Test() { cout << "\n Constructor executed"; }
 
    // User-Defined Destructor
    ~Test() { cout << "\nDestructor executed"; }
};
main()
{
    Test t;
 
    return 0;
}


Output

 Constructor executed
Destructor executed

Example 2

The below code demonstrates the automatic execution of constructors and destructors each time when multiple objects are created and destroyed, respectively.

C++




// C++ program to demonstrate the execution of constructor
// and destructor when multiple objects are created
 
#include <iostream>
using namespace std;
class Test {
public:
    // User-Defined Constructor
    Test() { cout << "\n Constructor executed"; }
 
    // User-Defined Destructor
    ~Test() { cout << "\n Destructor executed"; }
};
 
main()
{
    // Create multiple objects of the Test class
    Test t, t1, t2, t3;
    return 0;
}


Output

 Constructor executed
 Constructor executed
 Constructor executed
 Constructor executed
 Destructor executed
 Destructor executed
 Destructor executed
 Destructor executed

Example 3

The below C++ program demonstrates the number of times constructors and destructors are called.

C++




// C++ program to demonstrate the number of times
// constructor and destructors are called
 
#include <iostream>
using namespace std;
static int Count = 0;     //It is static so that every class object has the same value
class Test {
public:
    // User-Defined Constructor
    Test()
    {
 
        // Number of times constructor is called
        Count++;
        cout << "No. of Object created: " << Count
            << endl;
    }
 
    // User-Defined Destructor
    ~Test()
    {
         
        cout << "No. of Object destroyed: " << Count    //It will print count in  
            << endl;                                    //decending order
        Count--;
        // Number of times destructor is called
    }
};
 
// driver code
int main()
{
    Test t, t1, t2, t3;
 
    return 0;
}


Output

No. of Object created: 1
No. of Object created: 2
No. of Object created: 3
No. of Object created: 4
No. of Object destroyed: 4
No. of Object destroyed: 3
No. of Object destroyed: 2
No. of Object destroyed: 1

Note: Objects are destroyed in the reverse order of their creation. In this case, t3 is the first to be destroyed, while t is the last.

Properties of Destructor

The following are the main properties of Destructor:

  • The destructor function is automatically invoked when the objects are destroyed.
  • It cannot be declared static or const.
  • The destructor does not have arguments.
  • It has no return type not even void.
  • An object of a class with a Destructor cannot become a member of the union.
  • A destructor should be declared in the public section of the class.
  • The programmer cannot access the address of the destructor.

When is the 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  

Note: destructor can also be called explicitly for an object.

How to call destructors explicitly?

We can call the destructors explicitly using the following statement:

object_name.~class_name()

How are destructors different from normal member functions?

  • Destructors have the same name as the class preceded by a tilde (~) 
  • Destructors don’t take any argument and don’t return anything

C++




#include <bits/stdc++.h>
using namespace std;
 
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; }
 
int main()
{
    String str = "Hello, World!";
    String myString(str);
    cout << "String: " << myString.s << endl;
    return 0;
}


Can there be more than one destructor in a class?

No, there can only be one destructor in a class with a class name 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, the 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 the class, we should write a destructor to release memory before the class instance is destroyed. This must be done to avoid memory leaks.

Can a destructor be virtual? 

Yes, In fact, it is always a good idea to make destructors virtual in the base class when we have a virtual function. See virtual destructor for more details. 

You may like to take a quiz on destructors.

Related Articles



Last Updated : 08 Sep, 2023
Like Article
Save Article
Previous
Next
Share your thoughts in the comments
Similar Reads