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

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.

Answer 2

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 3

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 4

You can give the class a private new operator. See Public operator new, private operator delete: getting C2248 "can not access private member" when using new for more information.

Answer 5

Late for the party, but I think I found a way to define and use a class only instantiable on stack. I must admit its use is rather limited, as you can only:

• take it as a const reference and
• call its const member functions and
• read its data members.

There is no way, however, to use it in a new expression or allocate it with dynamic storage duration as a member of another object (like Steve Folly shows in his answer).

Example implementation:

class StackOnly
{
  const char* _str{ "" };
  StackOnly() = default;
  StackOnly(const StackOnly&) = default;
  constexpr StackOnly(const char* str) : _str{ str } {};
public:
  template <typename ...Args>
  constexpr static StackOnly create(Args&&... args)
  { return StackOnly{ std::forward<Args>(args)... }; }

  void print() const { std::cout << _str; }
};

Please note that even though its limits, object still can be used quite decently, if you … well … use it in a function:

void useStackOnly(const StackOnly& obj)
{
    // function extends the lifetime of our temporary :)
    const StackOnly& stackObj = obj;
    stackObj.print();
}

int main()
{
    useStackOnly(StackOnly::create("greetings from stack"));
}

Note 1: The object itself might allocate on heap and use mutable data members - technically you can make up a vector :).

Note 2: C++11 is not required. One can achieve this in older C++ revisions as well.

Answer 6

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.