Ist es möglich, die Stapelzuweisung eines Objekts zu verhindern und nur zuzulassen, dass es mit 'neu' instanziiert wird?

Question

Ist es möglich, die Stapelzuweisung eines Objekts zu verhindern und nur zuzulassen, dass es auf dem Heap mit 'neu' versehen wird?

Answer 1

Eine Möglichkeit wäre, die Konstruktoren privat zu machen und nur die Konstruktion über eine statische Methode zuzulassen, die einen Zeiger zurückgibt. Zum Beispiel:

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

Answer 2

Sie könnten den Konstruktor private erstellen und dann eine statische Factory-Methode public zum Erstellen der Objekte bereitstellen.

Answer 3

Sie könnten eine Header-Datei erstellen, die eine abstrakte Schnittstelle für das Objekt zur Verfügung stellt und Fabrik-Funktionen, die Zeiger auf Objekte erstellt auf dem Heap zurück.

// Header file 

class IAbstract 
{ 
    virtual void AbstractMethod() = 0; 

public: 
    virtual ~IAbstract(); 
}; 

IAbstract* CreateSubClassA(); 
IAbstract* CreateSubClassB(); 

// Source file 

class SubClassA : public IAbstract 
{ 
    void AbstractMethod() {} 
}; 

class SubClassB : public IAbstract 
{ 
    void AbstractMethod() {} 
}; 

IAbstract* CreateSubClassA() 
{ 
    return new SubClassA; 
} 

IAbstract* CreateSubClassB() 
{ 
    return new SubClassB; 
} 

Answer 4

Im Fall von 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(); 
}; 

Answer 5

Nachstehend ermöglicht öffentliche Konstruktoren und wird durch das Werfen zur Laufzeit Stapelzuordnungen stoppen. Hinweis thread_local ist ein C++ 11-Schlüsselwort.

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;