Destructors in C++

---

---

A destructor is a special member function of a class that is executed automatically whenever an object of its class goes out of scope or whenever the delete expression is applied to a pointer to the object of that class.

Note: In C++, the static keyword has a different meaning. In this chapter, we're using static memory allocation for stack-based / non-dynamic memory allocation.

The syntax of defining a destructor manually is given below −

 ~class_name() { // body } 

Here's the syntax to define a destructor outside the class, but first we need to declare the destructor in the class −

 class_name { public: // Destructor Declaration ~class_name(); } // Defining Destructor class_name :: ~class_name() { // Body } 

Defining a Destructor Inside a Class

In this example, we have used the above syntax for defining a destructor manually inside a class. Here, destructor is not needed, we have used destructor just to illustrate how a destructor is defined inside a class −

 #include <iostream> using namespace std; class Example{ public: // Constructor called Example(void) { cout << "Constructor is called" << endl; } // Defining destructor inside class ~Example(void) { cout << "Destructor is called" << endl; } }; int main(){ Example ex; return 0; } 

The output of the above code is given below −

 Constructor is called Destructor is called 

Defining a Destructor Outside a Class

The example below demonstrates how to define a destructor(Example) outside the class using scope resolution operator. But first, it needs to be declared inside the class.

 #include <iostream> using namespace std; class Example { public: // Constructor called Example(void) { cout << "Constructor is called" << endl; } // Declaring destructor inside class ~Example(); }; // Defining destructor outside class using scope resolution operator Example :: ~Example(void) { cout << "Destructor is called" << endl; } int main(){ Example ex; return 0; } 

The output of the above code is given below −

 Constructor is called Destructor is called 

Why Do We Need Custom Destructors?

C++ provides a default destructor for every class as the classes are created. The default destructor cleans up the statically allocated memory. But, if we have used a pointer for dynamic memory allocation using new, then we need to define a custom destructor with delete operator to clean up the memory.

In this example, the destructor Example1 is just used for displaying the message and not to free the memory as the memory of class Example1 gets freed automatically. But the destructor Example2 is used for freeing the memory using delete operator.

 #include <iostream> using namespace std; class Example1 { public: // Constructor called Example1() { cout << "Constructor of Example1 is called" << endl; } // Destructor called ~Example1() { cout << "Destructor of Example1 is called" << endl; } }; class Example2 { private: int *ptr; public: Example2() { ptr = new int; // dynamically allocated memory *ptr = 42; cout << "Constructor of Example2 is called with ptr Value = " << *ptr << endl; } // Destructor called to free dynamically allocated memory ~Example2() { delete ptr; // dynamically allocated memory is freed cout << "Destructor of Example2 is called" << endl; } }; int main(){ Example1 ex1; // object with static memory allocation Example2 ex2; // object with dynamic memory allocation return 0; } 

The output of the above code is given below −

 Constructor of Example1 is called Constructor of Example2 is called with ptr Value = 42 Destructor of Example2 is called Destructor of Example1 is called 

Properties of Destructors in C++

Destructors in C++ have the following properties −

• Destructors are automatically called when an object goes out of scope.
• Destructor has the same name as the class and is denoted using tilde(~) sign.
• It is automatically created when a class is created.
• Destructors do not have any return type and do not accept any parameters/arguments.
• You can not define more than one destructor.
• Destructors cannot be inherited.
• Destructors cannot be overloaded.

Automatic Destructor Call for Statically Allocated Objects

For objects that are created using static memory allocation, destructors are automatically called. Below is an example −

 #include <iostream> using namespace std; class MyClass { public: MyClass() { cout << "Constructor called" << endl; } ~MyClass() { cout << "Destructor called automatically" << endl; } }; int main() { cout << "Creating an object using static memory allocation" << endl; { MyClass obj; cout << "Object created" << endl; } // Object goes out of scope here, //destructor called automatically cout << "Object destroyed" << endl; return 0; } 

The output of the above code is given below −

 Creating an object using static memory allocation Constructor called Object created Destructor called automatically Object destroyed 

C++ Destructor for Dynamic Objects

For objects that are created using dynamic memory allocation, you need to manually call the destructor using delete. In the example below, we have manually deleted the object using the delete operator:

 #include <iostream> using namespace std; class MyClass { public: MyClass() { cout << "Constructor called" << endl; } ~MyClass() { cout << "Destructor called" << endl; } }; int main() { cout << "Creating an object using dynamic memory allocation:" << endl; // Dynamically creating an object MyClass *obj = new MyClass(); cout << "Object created" << endl; // Manually invoking destructor delete obj; cout << "Object destroyed manually using delete" << endl; return 0; } 

The output of the above code is given below −

 Creating an object using dynamic memory allocation: Constructor called Object created Destructor called Object destroyed manually using delete 

Destructor Call Order for Multiple Objects

Destructors are called in reverse order of construction for multiple objects. In the example below, we can see that the destructors are called in the reverse order −

 #include <iostream> using namespace std; class MyClass { private: int id; public: MyClass(int num) : id(num) { cout << "Constructor called for object " << id << endl; } ~MyClass() { cout << "Destructor called for object " << id << endl; } }; int main() {	cout << "Creating 3 objects:" << endl;	{	MyClass obj1(1); // First object	MyClass obj2(2); // Second object	MyClass obj3(3); // Third object	cout << "All objects created" << endl;	} // All objects go out of scope here	cout << "All objects destroyed" << endl;	return 0; } 

The output of the above code is given below −

 Creating 3 objects: Constructor called for object 1 Constructor called for object 2 Constructor called for object 3 All objects created Destructor called for object 3 Destructor called for object 2 Destructor called for object 1 All objects destroyed 

Destructors with Arrays

To clean the memory after an array gets deleted or gets out of scope, we need to call destructor for each array item to avoid any memory leak. There can be three different types of scenarios while using a destructor with an array.

• Using Destructor with Static Array
• Using Destructor with a Dynamic Array
• Using Destructor with an Array of Pointers to Objects

Using a Destructor with a Static Array

In this example, we have a static array of objects, and the memory is freed automatically by the compiler. Here, the destructor is used just for displaying the message.

 #include <iostream> using namespace std; class Example { private: int id; public: Example(int i) : id(i) { cout << "Constructor called for object " << id << endl; } ~Example() { cout << "Destructor called for object " << id << endl; } }; int main(){ cout << "Creating array of 3 objects:" << endl; Example arr[3] = {Example(1), Example(2), Example(3)}; cout << "Array created" << endl; return 0; // Destructors called automatically } 

The output of the above code is given below −

 Creating array of 3 objects: Constructor called for object 1 Constructor called for object 2 Constructor called for object 3 Array created Destructor called for object 3 Destructor called for object 2 Destructor called for object 1 

Using a Destructor with a Dynamic Array

In this example, a dynamic array of objects is created using new[] operator. Here, the destructor is used with delete[] operator to clear the memory.

 #include <iostream> using namespace std; class Student { private: int rollNo; public: Student(int r = 0) // constructor with default argument { rollNo = r; cout << "Constructor called for roll no: " << rollNo << endl; } ~Student() { cout << "Destructor called for roll no: " << rollNo << endl; } }; int main() { cout << "Creating dynamic array of 3 students:" << endl; Student *students = new Student[3] {101, 102, 103}; // initialize with roll numbers cout << "\nDeleting array:" << endl; delete[] students; // destructor for all 3 objects return 0; } 

The output of the above code is given below −

 Creating dynamic array of 3 students: Constructor called for roll no: 101 Constructor called for roll no: 102 Constructor called for roll no: 103 Deleting array: Destructor called for roll no: 103 Destructor called for roll no: 102 Destructor called for roll no: 101 

Using a Destructor with an Array of Pointers to Objects

In this example, an array of pointers to objects is created. Here, the destructor is used with the delete operator to free the memory of each object individually as each pointer is pointing to a uniquely allocated object.

 #include <iostream> using namespace std; class Book { private: string title; public: Book(string t) : title(t) { cout << "Book created: " << title << endl; } ~Book() { cout << "Book destroyed: " << title << endl; } }; int main(){ cout << "Creating array of 3 books:" << endl; Book *library[3]; // Creating individual book objects library[0] = new Book("C++ Basics"); library[1] = new Book("CSS Basics"); library[2] = new Book("Javascript Basics"); cout << "\nDeleting books:" << endl; // Deleting each object individually for (int i = 0; i < 3; i++){ delete library[i]; } return 0; } 

The output of the above code is given below −

 Creating array of 3 books: Book created: C++ Basics Book created: CSS Basics Book created: Javascript Basics Deleting books: Book destroyed: C++ Basics Book destroyed: CSS Basics Book destroyed: Javascript Basics 

Common Mistakes While Working with Destructors

Some of the common beginner mistakes while working with destructors are listed below −

• Using destructor for statically allocated memory. It gets deleted automatically, so there is no need to use a destructor.
• For dynamically allocated memory, forgetting to use the delete.
• In inheritance, not declaring the destructor as virtual in the base class.
• For arrays, use delete[] instead of delete.
• Trying to delete an already-deleted memory twice, also known as double deletion. Set the pointer to nullptr after deleting it, and check the pointer for nullptr before deletion.

Conclusion

Destructors are special member functions to clean up memory when objects go out of scope or program is executed. In C++, there is a default destructor for statically allocated memory, and custom destructors are used for clearing the dynamically allocated memory using the new operator.