How to prevent an object being created on the heap?

by

Nick’s answer is a good starting point, but incomplete, as you actually need to overload:

private:
    void* operator new(size_t);          // standard new
    void* operator new(size_t, void*);   // placement new
    void* operator new[](size_t);        // array new
    void* operator new[](size_t, void*); // placement array new

(Good coding practice would suggest you should also overload the delete and delete[] operators — I would, but since they’re not going to get called it isn’t really necessary.)

Pauldoo is also correct that this doesn’t survive aggregating on Foo, although it does survive inheriting from Foo. You could do some template meta-programming magic to HELP prevent this, but it would not be immune to “evil users” and thus is probably not worth the complication. Documentation of how it should be used, and code review to ensure it is used properly, are the only ~100% way.

More Related Contents:

  1. Stack, Static, and Heap in C++
  2. Calling delete on variable allocated on the stack
  3. Which is faster: Stack allocation or Heap allocation
  4. Proper stack and heap usage in C++?
  5. Does this type of memory get allocated on the heap or the stack?
  6. Is it possible to force c++ class instantiation on the heap?
  7. Are there differences between pointers to object stored on stack and heap? [closed]
  8. What is memory fragmentation?
  9. Why are the terms “automatic” and “dynamic” preferred over the terms “stack” and “heap” in C++ memory management?
  10. Object creation on the stack/heap?
  11. What is the difference between “new” and “malloc” and “calloc” in C++? [duplicate]
  12. When and how to use GCC’s stack protection feature?
  13. Stack-buffer based STL allocator?
  14. Why not use pointers for everything in C++?
  15. Where are temporary object stored?
  16. What is the behavior of “delete” with stack objects? [duplicate]
  17. Does std::stack expose iterators?
  18. g++ variable size array no warning?
  19. Declare variables at top of function or in separate scopes?
  20. Critique my non-intrusive heap debugger
  21. How is heap and stack memories managed, implemented, allocated?
  22. Understanding stack frame of function call in C/C++? [closed]
  23. Is accessing data in the heap faster than from the stack?
  24. Linux Allocator Does Not Release Small Chunks of Memory
  25. What happens if I increment an array variable?
  26. Weird MSC 8.0 error: “The value of ESP was not properly saved across a function call…”
  27. How to find if a variable is allocated in stack or heap?
  28. What’s the advantage of using std::allocator instead of new in C++?
  29. Are global variables in C++ stored on the stack, heap or neither of them?
  30. Heap versus Stack allocation implications (.NET)

Leave a Comment