> The name of the destructor is `~this`, and just like constructors, it has no return type. # Automatic destructor execution The destructor is executed as soon as the lifetime of the struct object ends. As you have seen in a [previous chapter](https://www.educative.io/courses/advanced-programming-techniques-in-d/lifetimes), the lifetime of an object ends when it leaves the scope that it is defined in. The lifetime of a struct type ends at the following times: 1. When leaving the scope of the object either normally or due to a thrown exception: ```D if (aCondition) { auto duration = Duration(7); // ... } // ← The destructor is executed for 'duration' // at this point ``` 2. Anonymous objects are destroyed at the end of the whole expression that they are constructed in: ```D time.increment(Duration(5)); // ← The Duration(5) object gets destroyed at the end of the whole expression. ``` 3. All of the struct members of a struct object get destroyed when the outer object is destroyed. > This is not the case for objects that are constructed with the `new` keyword. # Destructor example Let's design a type for generating simple XML documents. XML elements are defined by *angle brackets*. They contain data and other XML elements. XML elements can have attributes as well, but we will ignore them here. Our aim will be to ensure that an element that has been opened by a *< name >* tag will always be closed by a matching *< /name >* tag: ```xml ← opening the outer XML element ← opening the inner XML element 57 ← the data ← closing the inner element ← closing the outer element ``` A struct that can produce the output above can be designed by two members that store the tag for the XML element and the indentation to use when printing it: ```c struct XmlElement { string name; string indentation; } ``` If the responsibilities of opening and closing the XML element are given to the constructor and the destructor, respectively, the desired output can be produced by managing the lifetimes of the XmlElement objects. For example, the constructor can print *< tag>* and the destructor can print *< /tag>*. The following definition of the constructor produces the opening tag: ```C this(string name, int level) { this.name = name; this.indentation = indentationString(level); writeln(indentation, '<', name, '>'); } ``` `indentationString()` is the following function: ```C import std.array; // ... string indentationString(int level) { return replicate(" ", level * 2); } ``` The function calls `replicate()` from the `std.array` module, which makes and returns a new string made up of the specified value repeated the specified number of times. The destructor can be defined similar to the constructor to produce the closing tag: ``` ~this() { writeln(indentation, "'); } ``` Here is a test code to demonstrate the effects of the automatic constructor and destructor calls:

Destructor

Destructor definition