When is Manually Calling a Destructor Justifiable?

The notion that manually calling a destructor indicates flawed design is often asserted. However, this begs the question: Are there exceptions to this rule?

Counter-Examples: Cases Requiring Manual Destructor Calls

Indeed, there are situations where it becomes necessary to explicitly invoke the destructor:

1. Controlled Memory Deallocation:

When memory allocation and deallocation are managed independently of object construction and destruction, manual destructor calls become crucial. In such cases, object construction occurs via placement new on an existing memory buffer, while destruction happens through an explicit destructor call.

char buffer[sizeof(MyClass)];

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

2. Specific Memory Allocators:

Another example is std::vector's usage of the default std::allocator. Here, elements are constructed during push_back operations, but memory allocation occurs in chunks that predate the element construction. As such, vector::erase must destroy the elements without necessarily deallocating the memory, particularly if further push_backs are imminent.

Implications:

Manually calling destructors may violate strict OOP principles by blurring the lines between object and memory management. However, in low-level programming or scenarios where memory allocation and deallocation are decoupled, it can be appropriate.

Moreover, while random manual destructor calls can indicate design issues, its localized use within purpose-built classes can be considered sound practice.