How to prevent others create a new instance of a class on heap?

Question

Possible Duplicate:
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.)

Suppose I define a class in the library

class Base {};

and I publish the class to the users.

And one user defines a new class

class Derived : public Base {}

The question what can I do in Base to prevent users create an instance of Derived on heap?

For example, this is allowed

Derived dd;

This is not

Derived* dd = new Derived();

Thanks,

@Greg: You probably mean [this question](http://stackoverflow.com/questions/124856/how-do-i-prevent-a-class-from-being-allocated-via-the-new-operator-id-like). — Jesse Good, Jun 14 '12 at 21:02
@Greg -I believe that question you linked is infact, the exact opposite of what the OP is looking for. — Perception, Jun 14 '12 at 21:02
@user315052 Surely that only prevents the creation of `Base` objects on the heap, and doesn't affect `Derived` objects at all? — Neil, Jun 14 '12 at 21:04

score 9 · Accepted Answer · answered Jun 14 '12 at 21:05

I think the best you can do is to declare a private operator new (I can't recall if this is needed but you'll probably want to do all three: normal, array, and placement) in your base class. The user can still get around this by creating their own operator new in the Derived class but at least they have to think about it and actively work to subvert your intention.

If you're worried about non-accidental problems with creating your class on the heap (for example malicious developers of child classes), C++ is not the language for this project. It's powerful and has lots of places where your have to rely on your end-programmers not bypassing the intentions.

score 4 · Answer 2 · answered Jun 14 '12 at 21:04

4

You make operator new private in the base class.

class Base {
    void* operator new(size_t);
};
class Derived : public Base {
}

//...

Base* p = new Derived; //ERROR
Derived d;             //OK

answered Jun 14 '12 at 21:04

Luchian Grigore

253,575
64
457
625

score 0 · Answer 3 · answered Jun 14 '12 at 21:29

In addition to making the new operator private in Base, you can give a reminder to the user of Base what the intention of Base is. This way, a developer using Base can't claim the intentions were not documented.

class Base
{
    void * operator new (size_t) {}
    void * operator new[] (size_t) {}
    void * operator new (size_t, void *) {}
protected:
    struct I_promise_not_to_dynamically_allocate_Base {};
    Base (I_promise_not_to_dynamically_allocate_Base) {}
    virtual ~Base () {}
    //...
};

Now, when the developer uses the Base, they are forced to pass in the argument:

class Derived : public Base
{
public:
    Derived () : Base(I_promise_not_to_dynamically_allocate_Base()) {}
    //...
};

As already stated, nothing prevents the the developer from overloading new and delete themselves, but then they would be breaking a promise!

How to prevent others create a new instance of a class on heap?

3 Answers3