Destructor (computer programming)

From Wikipedia, the free encyclopedia

In object-oriented programming, a destructor (sometimes abbreviated dtor[1]) is a method which is invoked mechanically just before the memory of the object is released.[2] It can happen when its lifetime is bound to scope and the execution leaves the scope, when it is embedded in another object whose lifetime ends, or when it was allocated dynamically and is released explicitly. Its main purpose is to free the resources (memory allocations, open files or sockets, database connections, resource locks, etc.) which were acquired by the object during its life and/or deregister from other entities which may keep references to it. Use of destructors is needed for the process of Resource Acquisition Is Initialization (RAII).

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;
    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]


#include <cstring>
#include <iostream>

class Foo {
    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_; }

    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.


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]


  1. ^ "dtor". Retrieved 2018-10-14.
  2. ^ a b c d e Sebesta, Robert W. (2012). "" Constructors and Destructors"". Concepts of Programming Languages (print) (10th ed.). Boston, MA, USA: Addison-Wesley. p. 487. ISBN 978-0-13-139531-2.
  3. ^ Constructors and Destructors, from PHP online documentation
  4. ^ "3. Data model — Python 2.7.18 documentation".
  5. ^ "3. Data model — Python 3.10.4 documentation".
  6. ^ "Destructors - the Rust Reference".
  7. ^ GotW #47: Uncaught exceptions Accessed 31 July 2011.
  8. ^ Smith, Richard; Voutilainen, Ville. "P0593R6:Implicit creation of objects for low-level object manipulation". Retrieved 2022-11-25.
  9. ^ Scott Meyers: Effective Modern C++, O'REILLY, ISBN 9781491903995
  10. ^ C "destructor" function attribute
  11. ^ Erickson, Jon (2008). Hacking the art of exploitation. No Starch Press. ISBN 978-1-59327-144-2.