How do I prevent a class from being allocated via the ‘new’ operator? (I’d like to ensure my RAII class is always allocated on the stack.)

by

All you need to do is declare the class’ new operator private:

class X
{
    private: 
      // Prevent heap allocation
      void * operator new   (size_t);
      void * operator new[] (size_t);
      void   operator delete   (void *);
      void   operator delete[] (void*);

    // ...
    // The rest of the implementation for X
    // ...
};

Making ‘operator new’ private effectively prevents code outside the class from using ‘new’ to create an instance of X.

To complete things, you should hide ‘operator delete’ and the array versions of both operators.

Since C++11 you can also explicitly delete the functions:

class X
{
// public, protected, private ... does not matter
    static void *operator new     (size_t) = delete;
    static void *operator new[]   (size_t) = delete;
    static void  operator delete  (void*)  = delete;
    static void  operator delete[](void*)  = delete;
};

Related Question: Is it possible to prevent stack allocation of an object and only allow it to be instiated with ‘new’?

More Related Contents:

  1. What are the basic rules and idioms for operator overloading?
  2. How should I write ISO C++ Standard conformant custom new and delete operators?
  3. Overloading member access operators ->, .*
  4. Why would one replace default new and delete operators?
  5. Rationale of enforcing some operators to be members
  6. Resolve build errors due to circular dependency amongst classes
  7. Why isn’t sizeof for a struct equal to the sum of sizeof of each member?
  8. How do I use arrays in C++?
  9. What is the difference between const int*, const int * const, and int const *?
  10. Default constructor with empty brackets
  11. Do the parentheses after the type name make a difference with new?
  12. Why is volatile not considered useful in multithreaded C or C++ programming?
  13. How to overload std::swap()
  14. Does C++ support ‘finally’ blocks? (And what’s this ‘RAII’ I keep hearing about?)
  15. Why must the copy assignment operator return a reference/const reference?
  16. Does const mean thread-safe in C++11?
  17. virtual assignment operator C++
  18. When to Overload the Comma Operator?
  19. Semantics of flags on basic_ios
  20. Making operator
  21. Should I include or in C++ programs?
  22. How to write C++ getters and setters
  23. operator= and functions that are not inherited in C++?
  24. FAQ: Why does dynamic_cast only work if a class has at least 1 virtual method?
  25. difference between global operator and member operator
  26. When do extra parentheses have an effect, other than on operator precedence?
  27. What does “operator = must be a non-static member” mean?
  28. How could comma separated initialization such as in Eigen be possibly implemented in C++?
  29. Where should non-member operator overloads be placed?
  30. operator

Leave a Comment