How can the creation of class objects in dynamic…

Restrict object creation of a class in dynamic memory by making the new and delete operators private or protected.

Private new and delete operators: This is the strictest method. Only class members and friend functions can access them (the new[] operator should also be declared private).

class NoHeapAlloc {
private:
    void* operator new(size_t size);
    void operator delete(void* ptr);
    // You can also prohibit array operators
    void* operator new[](size_t size);
    void operator delete[](void* ptr);

public:
    NoHeapAlloc() = default;
    // ... other class members
};

// Usage:
// NoHeapAlloc* obj = new NoHeapAlloc(); // Compilation error

Protected new and delete operators: Allows creating objects on the heap for derived classes, but prohibits external creation.

class BaseNoHeapAlloc {
protected:
    void* operator new(size_t size);
    void operator delete(void* ptr);
    void* operator new[](size_t size);
    void operator delete[](void* ptr);

public:
    BaseNoHeapAlloc() = default;
    // ... other class members
};

// Derived class can create on the heap
class DerivedCanAlloc : public BaseNoHeapAlloc {
public:
    DerivedCanAlloc() : BaseNoHeapAlloc() {}
    // ...
};

// Usage:
// BaseNoHeapAlloc* base_obj = new BaseNoHeapAlloc(); // Compilation error
// DerivedCanAlloc* derived_obj = new DerivedCanAlloc(); // OK (if called from a member/friend of DerivedCanAlloc)

// External creation is still prohibited
// BaseNoHeapAlloc* base_obj_ext = new BaseNoHeapAlloc(); // Compilation error
// DerivedCanAlloc* derived_obj_ext = new DerivedCanAlloc(); // Compilation error (if not from a class member)

In both cases, the user can only create objects on the stack or as members of other classes:

// Correct usage for NoHeapAlloc with private new/delete operators
NoHeapAlloc obj_on_stack; // OK

How can the creation of class objects in dynamic memory (heap) be restricted by users of this class?