Channels ▼
RSS

Design

Destructors Considered Harmful


Staying Out of Harm's Way

The key to avoiding destructors is to realize that a destructor is always executed in addition to the destructors of its class' data members and base classes. Therefore, although it is not possible to avoid destructors completely, it is possible to encapsulate them in classes that do nothing but allocate and free resources. One such class is the shared_ptr template from the new C++ standard. Using it, we can rewrite our ThingHandle class this way:

// This version avoids the hazard
class ThingHandle {
public:
     ThingHandle(): tp(new Thing) { }
     // …
private:
     std::shared_ptr<Thing> tp;
};

By changing the type of our tp member from Thing* to std::shared_ptr<Thing>, we have handed the job of worrying about memory allocation to the shared_ptr class, thereby dropping the destructor from ThingHandle entirely. If the compiler generates a copy constructor or assignment operator for us (or, in the new C++ standard, a move constructor or move-assignment operator), it will be up to the definition of shared_ptr to do the right thing.

We may not be able to avoid transferring control from one part of the program to another, but at least we can give someone else the responsibility for dealing with that transfer to the compiler in the case of goto statements, or to the runtime library in the case of destructors. In doing so, we have replaced dynamic analysis ("Does every path through every constructor leave tp in an appropriate state?") by static analysis ("tp has a type that does the right thing however we use it.")

Conclusion

Dijkstra wanted to make it easier to understand how programs work by encapsulating goto statements in appropriately limited control structures. Analogously, we can simplify our programs by encapsulating resource management in appropriately limited data structures. Destructors often mark opportunities for such encapsulation.


Andrew Koenig's career in computing ranges from teaching programming classes at Lowell Observatory to writing the first portable implementation of printf. Andrew was a founding member of the C++ standards committee, is the author or coauthor of three books, and is a blogger for Dr. Dobb's.


Related Reading


More Insights






Currently we allow the following HTML tags in comments:

Single tags

These tags can be used alone and don't need an ending tag.

<br> Defines a single line break

<hr> Defines a horizontal line

Matching tags

These require an ending tag - e.g. <i>italic text</i>

<a> Defines an anchor

<b> Defines bold text

<big> Defines big text

<blockquote> Defines a long quotation

<caption> Defines a table caption

<cite> Defines a citation

<code> Defines computer code text

<em> Defines emphasized text

<fieldset> Defines a border around elements in a form

<h1> This is heading 1

<h2> This is heading 2

<h3> This is heading 3

<h4> This is heading 4

<h5> This is heading 5

<h6> This is heading 6

<i> Defines italic text

<p> Defines a paragraph

<pre> Defines preformatted text

<q> Defines a short quotation

<samp> Defines sample computer code text

<small> Defines small text

<span> Defines a section in a document

<s> Defines strikethrough text

<strike> Defines strikethrough text

<strong> Defines strong text

<sub> Defines subscripted text

<sup> Defines superscripted text

<u> Defines underlined text

Dr. Dobb's encourages readers to engage in spirited, healthy debate, including taking us to task. However, Dr. Dobb's moderates all comments posted to our site, and reserves the right to modify or remove any content that it determines to be derogatory, offensive, inflammatory, vulgar, irrelevant/off-topic, racist or obvious marketing or spam. Dr. Dobb's further reserves the right to disable the profile of any commenter participating in said activities.

 
Disqus Tips To upload an avatar photo, first complete your Disqus profile. | View the list of supported HTML tags you can use to style comments. | Please read our commenting policy.
 

Video