Contents

Destructor (computer programming)

With most kinds of automatic garbage collection algorithms, the releasing of memory may happen a long time after the object becomes unreachable, making destructors (called finalizers in this case) unsuitable for most purposes. In such languages, the freeing of resources is done either through a lexical construct (such as try..finally, Python's "with" or Java's "try-with-resources"), which is the equivalent to RAII, or explicitly by calling a function (equivalent to explicit deletion); in particular, many object-oriented languages use the Dispose pattern.

Destructor syntax[edit]

• C++: destructors have the same name as the class with which they are associated, but with a tilde (~) prefix.^[2]
• D: destructors are declared with name ~this() (whereas constructors are declared with this()).
• Object Pascal: destructors have the keyword destructor and can have user-defined names, but are mostly named Destroy.
• Objective-C: the destructor method has the name dealloc.
• Perl: the destructor method has the name DESTROY; in the Moose object system extension, it is named DEMOLISH.
• PHP: In PHP 5+, the destructor method has the name __destruct. There were no destructors in prior versions of PHP.^[3]
• Python: there are __del__ methods called destructors by the Python 2 language guide,^[4] but they are actually finalizers as acknowledged in Python 3.^[5]
• Rust: the destructor method for rust has the name drop.^[6]
• Swift: the destructor method has the name deinit.

In C++[edit]

The destructor has the same name as the class, but with a tilde (~) before it.^[2] For example, a class called foo will have the destructor ~foo(). Additionally, destructors have neither parameters nor return types.^[2] As stated above, a destructor for an object is called whenever the object's lifetime ends.^[2] If the object was created as an automatic variable, its lifetime ends and the destructor is called automatically when the object goes out of scope. Because C++ does not have garbage collection, if the object was created with a new statement (dynamically on the heap), then its destructor is called when the delete operator is applied to a pointer to the object. Usually that operation occurs within another destructor, typically the destructor of a smart pointer object.

In inheritance hierarchies, the declaration of a virtual destructor in the base class ensures that the destructors of derived classes are invoked properly when an object is deleted through a pointer-to-base-class. Objects that may be deleted in this way need to inherit a virtual destructor.

A destructor should never throw an exception.^[7]

Non-class scalar types have what's called a pseudo-destructor which can be accessed by using typedef or template arguments. This construct makes it possible to write code without having to know if a destructor exists for a given type.

int f() {
    int a = 123;
    using T = int;
    a.~T();
    return a; // undefined behavior
}

In older versions of the standard, pseudo-destructors were specified to have no effect, however that was changed in a defect report to make them end the lifetime of the object they are called on.^[8]

Example[edit]

#include <cstring>
#include <iostream>

class Foo {
public:
    Foo(): data_(new char[sizeof("Hello, World!")]) {
        std::strcpy(data_, "Hello, World!");
    }

    Foo(const Foo& other) = delete;             // disable copy construction
    Foo& operator=(const Foo& other) = delete;  // disable assignment

    ~Foo(void) { delete[] data_; }

private:
    friend std::ostream& operator<<(std::ostream& os, const Foo& foo) {
        os << foo.data_;
        return os;
    }

    char* data_;
};

int main() {
    Foo foo;
    std::cout << foo << std::endl;
}

Objects which cannot be safely copied and/or assigned should be disabled from such semantics by declaring their corresponding functions as deleted within a public encapsulation level. A detailed description of this method can be found in Scott Meyers' popular book, Effective Modern C++ (Item 11: "Prefer deleted functions to private undefined ones."^[9]).

In C with GCC extensions[edit]

The GNU Compiler Collection's C compiler comes with 2 extensions that allow implementing destructors:

• The destructor function attribute^[10] allows defining global prioritized destructor functions: when main() returns, these functions are called in priority order before the process terminates. See also: Hacking the art of exploitation.^[11]
• The cleanup variable attribute allows attaching a destructor function to a variable: the function is called when the variable goes out of scope.

Xojo[edit]

Destructors in Xojo (REALbasic) can be in one of two forms. Each form uses a regular method declaration with a special name (with no parameters and no return value). The older form uses the same name as the Class with a ~ (tilde) prefix. The newer form uses the name Destructor. The newer form is preferred because it makes refactoring the class easier.

Class Foobar
  // Old form
  Sub ~Foobar()
  End Sub

  // New form
  Sub Destructor()
  End Sub
End Class

See also[edit]

• Finalizer
• Constructor (computer science)
• Object lifetime
• Resource Acquisition Is Initialization
• Rule of three (C++ programming)

References[edit]