Is calling destructor manually always a sign of bad design?

by

All answers describe specific cases, but there is a general answer:

You call the dtor explicitly every time you need to just destroy the object (in C++ sense) without releasing the memory the object resides in.

This typically happens in all the situation where memory allocation / deallocation is managed independently from object construction / destruction. In those cases construction happens via placement new upon an existent chunk of memory, and destruction happens via explicit dtor call.

Here is the raw example:

{
  char buffer[sizeof(MyClass)];

  {
     MyClass* p = new(buffer)MyClass;
     p->dosomething();
     p->~MyClass();
  }
  {
     MyClass* p = new(buffer)MyClass;
     p->dosomething();
     p->~MyClass();
  }

}

Another notable example is the default std::allocator when used by std::vector: elements are constructed in vector during push_back, but the memory is allocated in chunks, so it pre-exist the element contruction. And hence, vector::erase must destroy the elements, but not necessarily it deallocates the memory (especially if new push_back have to happen soon…).

It is “bad design” in strict OOP sense (you should manage objects, not memory: the fact objects require memory is an “incident”), it is “good design” in “low level programming”, or in cases where memory is not taken from the “free store” the default operator new buys in.

It is bad design if it happens randomly around the code, it is good design if it happens locally to classes specifically designed for that purpose.

More Related Contents:

  1. C++ – destructors [closed]
  2. If you shouldn’t throw exceptions in a destructor, how do you handle errors in it?
  3. return statement vs exit() in main()
  4. C++ cast syntax styles
  5. Pure virtual destructor in C++
  6. Is pass-by-value a reasonable default in C++11?
  7. Is it a good practice to place C++ definitions in header files?
  8. A free tool to check C/C++ source code against a set of coding standards? [closed]
  9. Do I need to explicitly call the base virtual destructor?
  10. Why is the destructor of the class called twice?
  11. GNU GCC (g++): Why does it generate multiple dtors?
  12. What is the proper use of the comma operator?
  13. What’s the purpose of using braces (i.e. {}) for a single-line if or loop?
  14. Destructors of builtin types (int, char etc..)
  15. When should you use the “this” keyword in C++? [duplicate]
  16. Why use prefixes on member variables in C++ classes
  17. Iterate through a C++ Vector using a ‘for’ loop
  18. Advantages of std::for_each over for loop
  19. Will exit() or an exception prevent an end-of-scope destructor from being called?
  20. When to use an elaborated type specifier
  21. What are your favorite C++ Coding Style idioms [closed]
  22. How to add constructors/destructors to an unnamed class?
  23. How can I avoid including class implementation files?
  24. In C++, is it still bad practice to return a vector from a function?
  25. Isn’t the const modifier here unnecessary? [duplicate]
  26. Why do some experienced programmers write comparisons with the value before the variable? [duplicate]
  27. problems with Move constructor and Move overloaded assignment operator?
  28. Why does destructor disable generation of implicit move methods?
  29. What is the difference between if (NULL == pointer) vs if (pointer == NULL)?
  30. Is the whole object freed with a non-virtual destructor and a Base class pointer?

Leave a Comment