Nesnenin yığın ayırmasını önlemek ve yalnızca 'yeni' ile sonuçlanmasına izin vermek mümkün mü?

Question

bir nesnenin yığın ayırma önlenmesi ve sadece yığın 'yeni' ile instiated izin vermek için mümkün mi?

Answer 1

Bunu yapmanın bir yolu, kurucuları özel yapmak ve yalnızca bir işaretçi döndüren statik bir yöntemle yapılaşmaya izin vermek olabilir. Örneğin:

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

Answer 2

Sen yapıcı private ardından nesneleri oluşturmak için bir public statik fabrika yöntem sağlar yapabiliriz.

Answer 3

Bir nesne için soyut bir arayüz sağlar başlık dosyası ve öbek üzerinde oluşturulan nesnelere işaretçileri dönmek fabrika fonksiyonlarını oluşturabilir. 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 4

halka kurucular izin verir ve zamanında atarak yığın tahsisleri durdurulur. Not thread_local, bir C++ 11 anahtar sözcüğüdür. Ayrıca okuyucu için ilginç olabilir

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; 

Answer 5

şu halinde

// 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; 
}