Why there is no placement delete expression in C++?

by

operator delete is unique in being a non-member or static member function that is dynamically dispatched. A type with a virtual destructor performs the call to its own delete from the most derived destructor.

struct abc {
    virtual ~abc() = 0;
};

struct d : abc {
    operator delete() { std::cout << "goodbye\n"; }
};

int main() {
    abc *p = new d;
    delete p;
}

(Run this example.)

For this to work with placement delete, the destructor would have to somehow pass the additional arguments to operator delete.

  • Solution 1: Pass the arguments through the virtual function. This requires a separate virtual destructor for every static member and global operator delete overload with different arguments.
  • Solution 2: Let the virtual destructor return a function pointer to the caller specifying what operator delete should be called. But if the destructor does lookup, this hits the same problem of requiring multiple virtual function definitions as #1. Some kind of abstract overload set would have to be created, which the caller would resolve.

You have a perfectly good point, and it would be a nice addition to the language. Retrofitting it into the existing semantics of delete is probably even possible, in theory. But most of the time we don’t use the full functionality of delete and it suffices to use a pseudo-destructor call followed by something like arena.release(p).

More Related Contents:

  1. Is “delete this” allowed in C++?
  2. How should I write ISO C++ Standard conformant custom new and delete operators?
  3. How does delete[] know it’s an array?
  4. How do you ‘realloc’ in C++?
  5. Meaning of = delete after function declaration
  6. Why would one replace default new and delete operators?
  7. overloading new/delete
  8. delete[] an array of objects
  9. When to use new and delete
  10. How does the custom deleter of std::unique_ptr work?
  11. Why doesn’t delete destroy anything?
  12. How serious is the new/delete operator mismatch error?
  13. How does =delete on destructor prevent stack allocation?
  14. Calling delete on NULL pointers – C++03 vs C++11
  15. What are the advantages of list initialization (using curly braces)?
  16. Difference between std::regex_match & std::regex_search?
  17. What does the standard library guarantee about self move assignment?
  18. What is a raw string?
  19. Why should I avoid std::enable_if in function signatures
  20. C++ unordered_set of vectors
  21. Can returning a local variable by value in C++11/14 result in the return value being constructed by rvalue when no copy/move is involved?
  22. std::optional specialization for reference types
  23. What is decltype with two arguments?
  24. Do built-in types have move semantics?
  25. Variadic function template with pack expansion not in last parameter
  26. What is different between join() and detach() for multi threading in C++?
  27. Advantage of using trailing return type in C++11 functions
  28. Dependent name resolution & namespace std / Standard Library
  29. Implementation of Permutation, Combinations and PowerSet in C++ [duplicate]
  30. std::this_thread::sleep_for() and GCC

Leave a Comment