4.4) Destructors in C++

Destructors are special member functions in C++ that are used to perform cleanup operations and release resources held by an object before it goes out of scope or is explicitly deleted.

Destructors are called automatically when an object’s lifetime ends, typically when it goes out of scope, the function it was defined in returns, or when the delete operator is used to deallocate memory for objects created with the new operator.

Here are the key points to understand about destructors:

1. Destructor Signature

A destructor has the same name as the class with a tilde (~) followed by the class name. Destructors do not have parameters or a return type, and you cannot overload or define more than one destructor for a class.

class MyClass {
public:
    // Constructor

    // Other member functions

    ~MyClass() {
        // Destructor
    }
};

2. Cleanup and Resource Release

Destructors are primarily used to clean up resources acquired by the object during its lifetime. This can include releasing memory allocated with new, closing files, freeing other resources, and performing any necessary cleanup operations.

class FileHandler {
public:
    FileHandler(const std::string& filename) : file(std::fopen(filename.c_str(), "r")) {
        if (file == nullptr) {
            throw std::runtime_error("Unable to open file");
        }
    }

    ~FileHandler() {
        if (file != nullptr) {
            std::fclose(file);
        }
    }

private:
    FILE* file;
};

3. Automatic Invocation

Destructors are automatically called when an object goes out of scope or when the program deallocates memory for objects created with new. This ensures proper cleanup and resource release.

void functionWithObjects() {
    MyClass obj1;  // Destructor called when obj1 goes out of scope

    MyClass* obj2 = new MyClass;  // Destructor will be called when 'delete obj2' is executed
    delete obj2;
}  // Destructor of obj1 is called here

4. Order of Destructor Calls

When objects are part of a more complex structure, like containers or classes with inheritance, the order in which destructors are called is the reverse of the order in which constructors were called.

class Base {
public:
    ~Base() {
        std::cout << "Base destructor" << std::endl;
    }
};

class Derived : public Base {
public:
    ~Derived() {
        std::cout << "Derived destructor" << std::endl;
    }
};

int main() {
    Derived derived;
    return 0;
}

Output:

Derived destructor
Base destructor

5. Resource Management

Destructors play a vital role in managing resources and preventing memory leaks. They ensure that any resources held by an object are properly released, even in scenarios where exceptions are thrown or program execution is halted.

6. Limitations

Destructors do not take any parameters, and they are not explicitly called by user code. Their automatic invocation is determined by the object’s lifetime scope. It’s essential to avoid complex or time-consuming operations within destructors to prevent unwanted side effects.

Destructors are a critical part of C++ programming as they contribute to proper resource management and cleanup, ensuring the correct behavior of your program even in the presence of exceptions or unexpected termination.