Class constructed only on stack; not with new. C++

Question

Is there a way to create a class Foo

so that I can do:

Foo foo;

but not

Foo* foo = new Foo(); 

?

I don't want people to be able to allocate copies of Foo on the heap.

Thanks!

EDIT: Sorry, I was wrong on the "stack only, not heap". What I want to say is "can not use new operator".

Answer 1

In your documentation, put "do not create on the heap". Explaining why would be a good idea. Note that any attempt to enforce stack-only construction will also prevent the class from being used in standard containers and similar classes - it's not a good idea.

Answer 2

You can give the class a private new operator. See http://stackoverflow.com/questions/1820069/public-operator-new-private-operator-delete-getting-c2248-can-not-access-priva for more information.

Answer 3

Make your operator new private.

#include <new>

struct Foo {
        int x;
private:
        void* operator new (std::size_t size) throw (std::bad_alloc);
};

---

On C++0x you can delete the operator new:

struct Foo {
        int x;
        void* operator new (std::size_t size) throw (std::bad_alloc) = delete;
};

---

Note that you need to do the same for operator new[] separately.

Answer 4

Why don't you want people to create Foo on the heap? I can think of absolutely no reason why this would be useful.

Anyway, you can give your class a private new operator to accomplish this, but do note that this will also prevent people from using your class in standard containers, as those all allocate their contained objects on the heap. It's simply a bad idea to do what you're trying to do.

Answer 5

It's impossible to prevent an object being created on the heap. There are always ways around it. Even if you manage to hide operator new for Foo, you can always do:

#include <new>

struct Foo {
        int x;
private:
        void* operator new (std::size_t size) throw (std::bad_alloc);
};

struct Bar
{
    Foo foo;
};

int main()
{
    Bar* bar = new Bar;
    return 0;
}

And hey presto, you have a Foo on the heap.