[ACCEPTED]-Is it possible to prevent stack allocation of an object and only allow it to be instantiated with 'new'?-c++-faq

Accepted answer

Score: 86

One way you could do this would be to make 3 the constructors private and only allow 2 construction through a static method that 1 returns a pointer. For example:

class Foo
{
public:
    ~Foo();
    static Foo* createFoo()
    {
        return new Foo();
    }
private:
    Foo();
    Foo(const Foo&);
    Foo& operator=(const Foo&);
};

Score: 24

In the case of C++11

class Foo
{
  public:
    ~Foo();
    static Foo* createFoo()
    {
        return new Foo();
    }

    Foo(const Foo &) = delete; // if needed, put as private
    Foo & operator=(const Foo &) = delete; // if needed, put as private
    Foo(Foo &&) = delete; // if needed, put as private
    Foo & operator=(Foo &&) = delete; // if needed, put as private

  private:
    Foo();
};

Score: 12

You could make the constructor private, then provide 1 a public static factory method to create the objects.

Score: 6

The following allows public constructors 2 and will stop stack allocations by throwing 1 at runtime. Note thread_local is a C++11 keyword.

class NoStackBase {
    static thread_local bool _heap;
protected:
    NoStackBase() {
        bool _stack = _heap;
        _heap = false;
        if (_stack)
            throw std::logic_error("heap allocations only");
    }
public:
    void* operator new(size_t size) throw (std::bad_alloc) { 
        _heap = true;
        return ::operator new(size);
    }
    void* operator new(size_t size, const std::nothrow_t& nothrow_value) throw () {
        _heap = true;
        return ::operator new(size, nothrow_value);
    }
    void* operator new(size_t size, void* ptr) throw () {
        _heap = true;
        return ::operator new(size, ptr);
    }
    void* operator new[](size_t size) throw (std::bad_alloc) {
        _heap = true;
        return ::operator new[](size);
    }
    void* operator new[](size_t size, const std::nothrow_t& nothrow_value) throw () {
        _heap = true;
        return ::operator new[](size, nothrow_value);
    }
    void* operator new[](size_t size, void* ptr) throw () {
        _heap = true;
        return ::operator new[](size, ptr);
    }
};

bool thread_local NoStackBase::_heap = false;

Score: 2

This should be possible in C++20 using a 8 destroying operator delete, see p0722r3.

#include <new>

class C
{
private:
  ~C() = default;
public:
  void operator delete(C *c, std::destroying_delete_t)
  {
    c->~C();
    ::operator delete(c);
  }
};

Note that 7 the private destructor prevents it from 6 being used for anything else than dynamic 5 storage duration. But the destroying operator 4 delete allows it to be destroyed via a delete 3 expression (as the delete expression does 2 not implicitly call the destructor in this 1 case).

Source: stackoverflow.com

[ACCEPTED]-Is it possible to prevent stack allocation of an object and only allow it to be instantiated with 'new'?-c++-faq

Function with same name but different signature in derived class

Does std::list::remove method call destructor of each removed element?

When do extra parentheses have an effect, other than on operator precedence?

Explain C++ SFINAE to a non-C++ programmer

How to implement classic sorting algorithms in modern C++?

Different floating point result with optimization enabled - compiler bug?

What exactly is the "as-if" rule?

How should I write ISO C++ Standard conformant custom new and delete operators?

Why aren't my include guards preventing recursive inclusion and multiple symbol definitions?

How can I efficiently select a Standard Library container in C++11?