Destructors

Introduction

In the previous lesson, you learned about constructors, which participate in initializing objects when their lifetimes begin.

Objects can also acquire resources while they exist. A file object may open a file, a network object may own a socket, and a class may manage dynamically allocated memory.

When the lifetime of such an object ends, the resources it owns may need to be released correctly. C++ provides destructors for this purpose.

What is a Destructor?

A destructor is a special non-static member function that is invoked when an object of a class type is destroyed.

Its purpose is to perform any cleanup required before the object’s lifetime ends completely. This may include releasing resources directly owned by the object.

class Student
{
public:
    ~Student()
    {
        // Cleanup code
    }
};

Object Exists
      │
      ▼
Lifetime Ends
      │
      ▼
Destructor Executes
      │
      ▼
Cleanup Completes
      │
      ▼
Object Destroyed

Why Do We Need Destructors?

Many objects manage resources that must be released when those objects are destroyed. Destructors allow cleanup logic to be tied directly to object lifetime.

Real-World Analogy

Imagine staying in a hotel room. During your stay, you use the room and its facilities. When your stay ends, checkout procedures complete the lifecycle of that reservation.

A destructor plays a similar role for an object. When the object’s lifetime ends, the destructor provides a final opportunity to release resources owned by that object.

🏨 Check In
      │
      ▼
🛏️ Use Room
      │
      ▼
🧹 Checkout
      │
      ▼
🔑 Return Resources
      │
      ▼
🚪 Stay Ends

Characteristics of Destructors

class Student
{
public:
    Student()   // Constructor
    {
    }

    ~Student()  // Destructor
    {
    }
};

Destructor Syntax

A destructor is declared using a tilde followed by the class name.

class ClassName
{
public:
    ~ClassName()
    {
        // Cleanup code
    }
};

class Student
{
public:
    ~Student()
    {
        // Cleanup code
    }
};

// ❌ Incorrect
void ~Student()
{
}

// ❌ Incorrect
~Student(int id)
{
}

// ✅ Correct
~Student()
{
}

When is a Destructor Called?

A destructor is invoked when the lifetime of an object ends. The exact moment depends on the object’s storage duration and how it was created.

void run()
{
    Student student1;

    // student1 exists here
}
// student1 is destroyed here

Student* student1 = new Student;

delete student1;
// Destructor runs as part of delete

Example 1: Simple Destructor

This example shows the relationship between construction and destruction for a local object.

#include <iostream>

class Student
{
public:
    Student()
    {
        std::cout << "Constructor Called"
                  << std::endl;
    }

    ~Student()
    {
        std::cout << "Destructor Called";
    }
};

int main()
{
    Student student1;

    return 0;
}

Constructor Called
Destructor Called

Object Lifetime & LIFO Order

Every object has a lifetime. For local objects created in the same scope, destruction normally occurs in the reverse order of successful construction.

Student student1;
Student student2;
Student student3;

Construction
────────────
1. student1
2. student2
3. student3

Destruction
───────────
1. student3
2. student2
3. student1

Example 2: Multiple Objects

Using an identifier for each object makes the reverse destruction order easier to observe.

#include <iostream>

class Student
{
private:
    int id;

public:
    Student(int studentId)
        : id(studentId)
    {
        std::cout
            << "Constructing Student "
            << id
            << std::endl;
    }

    ~Student()
    {
        std::cout
            << "Destroying Student "
            << id
            << std::endl;
    }
};

int main()
{
    Student student1(1);
    Student student2(2);

    return 0;
}

Constructing Student 1
Constructing Student 2
Destroying Student 2
Destroying Student 1

Create
──────
student1
   │
   ▼
student2

Destroy
───────
student2
   │
   ▼
student1

Example 3: Releasing Resources

The most important use of destructors is lifetime-based resource management. A resource should be acquired by an object and released when that object is destroyed.

#include <fstream>
#include <iostream>

class LogFile
{
private:
    std::ofstream file;

public:
    LogFile(const std::string& filename)
        : file(filename)
    {
        std::cout << "File resource acquired"
                  << std::endl;
    }

    ~LogFile()
    {
        std::cout << "LogFile object destroyed";
    }

    void write(const std::string& message)
    {
        file << message;
    }
};

int main()
{
    LogFile log("app.log");
    log.write("Application started");

    return 0;
}

The std::ofstream member manages its own file resource. When the LogFile object is destroyed, its members are also destroyed automatically, and the stream releases its file resource.

class Number
{
private:
    int* value;

public:
    Number(int n)
        : value(new int(n))
    {
    }

    ~Number()
    {
        delete value;
    }
};

Constructor vs Destructor

Constructors and destructors represent opposite ends of an object’s lifetime.

Real-World Applications

Destruction-based cleanup appears throughout C++ systems because many resources have clear ownership and release requirements.

{
    std::lock_guard<std::mutex> guard(mutex);

    // Protected work
}
// guard is destroyed here
// The mutex is unlocked automatically

Acquire Resource
       │
       ▼
Object Owns Resource
       │
       ▼
Use Resource
       │
       ▼
Object Destroyed
       │
       ▼
Release Resource

Advantages of Destructors

Common Beginner Mistakes

Student student1;

// ❌ Usually incorrect
// student1.~Student();

// Let normal lifetime rules destroy it automatically.

// ❌ Incorrect
// ~Student(int id)
// {
// }

// ✅ Correct
~Student()
{
}

// ❌ Incorrect
// void ~Student()
// {
// }

// ✅ Correct
~Student()
{
}

Student student1;

// ❌ Incorrect
// delete &student1;

Best Practices

#include <memory>

class Number
{
private:
    std::unique_ptr<int> value;

public:
    Number(int n)
        : value(std::make_unique<int>(n))
    {
    }

    // No custom destructor required
};

class Base
{
public:
    virtual ~Base() = default;
};

class Derived : public Base
{
};

Frequently Asked Questions

Key Takeaways

Summary

Destructors are special member functions that participate in object destruction. They provide a place to perform cleanup when an object’s lifetime ends.

A destructor uses the class name prefixed with a tilde, has no return type, accepts no parameters, and cannot be overloaded.

For automatic objects in the same scope, destruction occurs in the reverse order of successful construction. Other objects follow the lifetime rules associated with their storage duration and ownership.

Destructors are especially important for RAII, where resources are owned by objects and released automatically when those objects are destroyed.

Modern C++ usually prefers standard containers, smart pointers, streams, and other resource-managing types. These types often eliminate the need to write custom destructors.

Now that you understand how object lifetimes begin with construction and end with destruction, the next lesson will introduce encapsulation, which controls how an object’s internal data and behavior are accessed.