A destructor is a member function that is invoked automatically when the object goes out of scope or is explicitly destroyed by a call to delete. A destructor has the same name as the class, preceded by a tilde (~). For example, the destructor for class String is declared: ~String().
Because of that, we don't care about maxing Gladiator Might or Rush. However, we do care about attack speed on Deconstructor so it can shoot a little faster. Healing Return = 55% for each attack (3 glaives are thrown every 5 seconds). 2 60/60 mods giving you 55% status chance per glaive per enemy. Deconstructor: Destroy buildings in this retro shooter! Watch out for enemies that will do anything to stop you from destroying their city! Free Shooting Games from AddictingGames.
If you do not define a destructor, the compiler will provide a default one; for many classes this is sufficient. You only need to define a custom destructor when the class stores handles to system resources that need to be released, or pointers that own the memory they point to.
Consider the following declaration of a String class:
Deconstructor definition: Noun (plural deconstructors) 1. One who, or that which, deconstructs.Origin deconstruct + -or. Atomic Deconstructor: Each of your attack has a very low percent to instant kill mobs and player. Bane of Arthropods: Increases damage to arthropods. Mutually exclusive with Smite and Sharpness. Has lesser, advanced and supreme variants. V Blast Protection: Reduces explosion damage and knockback. Mutually exclusive with other protections. XT-002 Deconstructor is the fourth raid boss in Ulduar raid. He directly blocks the entrance into the lower level of Ulduar in the Scrapyard. The fight is a rather straightforward gear check. A companion version of this boss, Lil' XT, is available from the Blizzard Pet Store.
In the preceding example, the destructor String::~String uses the delete operator to deallocate the space dynamically allocated for text storage.
Declaring destructors
Destructors are functions with the same name as the class but preceded by a tilde (~)
Several rules govern the declaration of destructors. Destructors:
Do not accept arguments.
Do not return a value (or
void).Cannot be declared as
const,volatile, orstatic. However, they can be invoked for the destruction of objects declared asconst,volatile, orstatic.Can be declared as
virtual. Using virtual destructors, you can destroy objects without knowing their type — the correct destructor for the object is invoked using the virtual function mechanism. Note that destructors can also be declared as pure virtual functions for abstract classes.
Using destructors
Destructors are called when one of the following events occurs:
A local (automatic) object with block scope goes out of scope.
An object allocated using the
newoperator is explicitly deallocated usingdelete.The lifetime of a temporary object ends.
A program ends and global or static objects exist.
The destructor is explicitly called using the destructor function's fully qualified name.
Destructors can freely call class member functions and access class member data.
There are two restrictions on the use of destructors:
You cannot take its address.
Derived classes do not inherit the destructor of their base class.
Order of destruction
When an object goes out of scope or is deleted, the sequence of events in its complete destruction is as follows:
The class's destructor is called, and the body of the destructor function is executed.
Destructors for nonstatic member objects are called in the reverse order in which they appear in the class declaration. The optional member initialization list used in construction of these members does not affect the order of construction or destruction.
Destructors for non-virtual base classes are called in the reverse order of declaration.
Destructors for virtual base classes are called in the reverse order of declaration.
Virtual base classes
Destructors for virtual base classes are called in the reverse order of their appearance in a directed acyclic graph (depth-first, left-to-right, postorder traversal). the following figure depicts an inheritance graph.
Inheritance graph that shows virtual base classes
The following lists the class heads for the classes shown in the figure.
Deconstructor Prime
To determine the order of destruction of the virtual base classes of an object of type E, the compiler builds a list by applying the following algorithm:
Traverse the graph left, starting at the deepest point in the graph (in this case,
E).Perform leftward traversals until all nodes have been visited. Note the name of the current node.
Revisit the previous node (down and to the right) to find out whether the node being remembered is a virtual base class.
If the remembered node is a virtual base class, scan the list to see whether it has already been entered. If it is not a virtual base class, ignore it.
If the remembered node is not yet in the list, add it to the bottom of the list.
Traverse the graph up and along the next path to the right.
Go to step 2.
When the last upward path is exhausted, note the name of the current node.
Go to step 3.
Continue this process until the bottom node is again the current node.
Therefore, for class E, the order of destruction is:
The non-virtual base class
E.The non-virtual base class
D.The non-virtual base class
C.The virtual base class
B.The virtual base class
A.
This process produces an ordered list of unique entries. No class name appears twice. Once the list is constructed, it is walked in reverse order, and the destructor for each of the classes in the list from the last to the first is called.
The order of construction or destruction is primarily important when constructors or destructors in one class rely on the other component being created first or persisting longer — for example, if the destructor for A (in the figure shown above) relied on B still being present when its code executed, or vice versa.
Such interdependencies between classes in an inheritance graph are inherently dangerous because classes derived later can alter which is the leftmost path, thereby changing the order of construction and destruction.
Non-virtual base classes
The destructors for non-virtual base classes are called in the reverse order in which the base class names are declared. Consider the following class declaration:
In the preceding example, the destructor for Base2 is called before the destructor for Base1.
Explicit destructor calls
Calling a destructor explicitly is seldom necessary. However, it can be useful to perform cleanup of objects placed at absolute addresses. These objects are commonly allocated using a user-defined new operator that takes a placement argument. The delete operator cannot deallocate this memory because it is not allocated from the free store (for more information, see The new and delete Operators). A call to the destructor, however, can perform appropriate cleanup. To explicitly call the destructor for an object, s, of class String, use one of the following statements:
Deconstructor Prime
The notation for explicit calls to destructors, shown in the preceding, can be used regardless of whether the type defines a destructor. This allows you to make such explicit calls without knowing if a destructor is defined for the type. An explicit call to a destructor where none is defined has no effect.
Robust programming
A class needs a destructor if it acquires a resource, and to manage the resource safely it probably has to implement a copy constructor and a copy assignment.
If these special functions are not defined by the user, they are implicitly defined by the compiler. The implicitly generated constructors and assignment operators perform shallow, memberwise copy, which is almost certainly wrong if an object is managing a resource.
In the next example, the implicitly generated copy constructor will make the pointers str1.text and str2.text refer to the same memory, and when we return from copy_strings(), that memory will be deleted twice, which is undefined behavior:
Explicitly defining a destructor, copy constructor, or copy assignment operator prevents implicit definition of the move constructor and the move assignment operator. In this case, failing to provide move operations is usually, if copying is expensive, a missed optimization opportunity.
See also
Copy Constructors and Copy Assignment Operators
Move Constructors and Move Assignment Operators
What Are Constructors?
Constructors are a particular type of method associated with a class and gets automatically invoked when the classes instance (i.e., objects) are created. Like other member functions, i.e., methods, these constructors also contain specific instructions that get executed when the objects are created. It is specifically used to assign values to all or some data members of a class.
Some Special Characteristics of the Constructor:
- The name of the constructors must have to be the same as that of the class's name in which will resides.
- A constructor can never be final, abstract, synchronized, and static.
- You can produce only a single static constructor.
- A static constructor cannot be used as a parameterized constructor.
- Constructors usually don't have a return type, not even void.
- The number of constructors can be any within a class.
- Constructors can contain access modifiers along with it.
Types of Constructors in C#
- Default Constructor: When constructors do not have parameters, then it is called the default constructor. These types of constructors have all its instance initialized with the same value.
- Parameterized Constructor: When any constructor has at least one parameter, it is called the parameterized constructor.
- Copy Constructor: When the constructor is used to create an object just by copying all of its variables from another object, such constructors are called copy constructor. They are used for initializing a new instance from an existing one.
- Private Constructor: When a constructor is produced with a private access modifier, it is called Private Constructor. It does not make it possible for other classes to inherit any data from this class.
- Static Constructor: When a constructor needs to be invoked only once, and when that constructor needs to be invoked at creating the first reference, then those constructors are made static and are called static constructors.
C# Program to Demonstrate Constructor
Deconstructor C#
What Are Destructors?
Destructor is another method that uses the class-name but is preceded with a ~ (tilde) operator/symbol. Destructors are used to de-initialize objects, and the memories occupied when constructors are created. You can consider them as the opposite of constructors.
C# Program to Demonstrate Destructor