Why would you ever make operator `new` private?

Question

I'm using OpenSplice DDS, and there, almost all C++ classes (basic ones that I used, I can mention them if that matters) have overloaded new operators to be private (to prevent users from using them). I don't understand, why would anyone do that? Could someone provide some examples that show the necessity of this?

Why I need new: Because most of these classes don't have default constructors, and I need to initialize them later in my implementation through a unique_ptr.

Easy trick: On the other hand... I can very easily trick this! I can just wrap this class with another class, and use new all I want, right? Hence I don't understand the motivation and it feels like bad style. Could someone explain?

---

EDIT:

Just to clarify: Providing a good example where this can't be escaped is a good answer. It'll be helpful for all people who see new operators made private.

Answer 1

why would anyone [overload new operators to be private (to prevent users from using them)]

Presumably to prevent allocating the objects directly on heap (i.e. dynamically).

Could someone provide some examples that show the necessity of this?

I don't know anything that necessitates this. Best source to find information about decision like this is the documentation. If it isn't documented, then you can ask the developers.

I can only guess. My guess is that the designers hope to make it more difficult for their users to make mistakes, by forgetting to free dynamic objects, or by trying to destroy or use non-existing ones.

---

EDIT: This is not provably official, but a user tagged as employee of the company that provides the library has commented on their forum:

The ISO C++ API is designed to have all objects created on the stack rather than the heap as this allows all memory management to happen automatically based on whether objects are still referred to. Copying an ISO C++ object will not incur an overhead as this will just copy the underlying smart pointer resulting in two references to the same object.

---

Because most of these classes don't have default constructors, and I need to initialize them later ...

That doesn't necessarily mean that you require dynamic allocation. Even though a class might not have a default constructor, it might still have a sensible default state, that can be achieved by passing some canonical value to the constructor (say, nullptr).

Answer 2

Lots of embedded C++ need to guarantee that NO dynamic allocations are done once the system is started. The aeronautics, automotive and medical device industry often have this requirement. See the following links for such coding standards and the rational behind it:

• http://www.stroustrup.com/JSF-AV-rules.pdf
• http://www.qa-systems.com/tools/qa-misra/

Answer 3

You do not strictly need new.

New can be forbidden to force stack allocation of objects (as opposed to heap allocation). Consider:

struct Point {
   int x, y;
};

Point * a = new Point{3, 5}; //sizeof(Point) in heap + sizeof(Point *) in stack.
Point b{3, 5}; //sizeof(Point), directly in the stack

So if you delete operator new (in C++11 it is the right way if you want to forbid) or make it private (pre-C++11) you enforce the protocol for users.

Another reason to forbid (but not delete) newing and constructors could be to return some kind of smart pointer of your object factory:

class MyClass {
private:
    MyClass();
    void * operator new(...);
public:
    static std::shared_ptr<MyClass> create() {
       //check if object in cache...
       auto c = std::make_shared<MyClass>();
       //Do more stuff maybe
       return c;
    }
};

This would enforce something in the factory constructor if needed, such as using caches or any other thing, would forbid outside users from using new also, but would still allow using new inside the class for the allocation (if you delete operator new you cannot do this anymore).