C++, evitando que se cree una instancia de clase en la pila (durante la compilación)

Question

Sé que hay métodos para evitar que una clase se cree en el montón evitando que el usuario use el operador new y delete. Estoy tratando de hacer todo lo contrario. Tengo una clase en la que quiero evitar que el usuario cree una instancia de la misma en la pila, y solo se compilarán las instancias iniciadas con el operador new. Más específicamente, quiero el código siguiente para recibir un error durante la compilación:

MyClass c1; //compilation error 

MyClass* c1 = new MyClass(); //compiles okay 

De buscar en la web, me encontré con esta sugerencia sobre cómo hacerlo:

class MyClass { 
public: 
    MyClass(); 
private: 
    void destroy() const { delete this; } 

... 

private: 
    ~MyClass(); 
}; 

int main(int argc,char** argv) 
{ 
    MyClass myclass; // <--- error, private destructor called here !!! 

    MyClass* myclass_ptr = new MyClass; 
    myclass_ptr->destroy(); 
} 

Lo que no entiendo es por eso que esto debería funcionar. ¿Por qué se llamaría al destructor al crear una instancia de MyClass?

Answer 1

Cuando myclass llega al final de su alcance (el siguiente }) el compilador llama al destructor para liberarlo de la pila. Si el destructor es privado, sin embargo, no se puede acceder al destructor, por lo que la clase no se puede colocar en la pila.

No me gusta el aspecto de delete this. En general, creo que los objetos no deberían destruirse a sí mismos. Tal vez una mejor manera es tener un constructor privado para su clase y luego use una función estática para crear una instancia.

// In class declaration... 
static MyClass* Create() 
{ 
    return new MyClass(); // can access private constructor 
} 

// ... 

MyClass myclass; // illegal, cannot access private constructor 

MyClass* pMyClass = MyClass::Create(); 
delete pMyClass; // after usage 

Answer 2

¿Por qué el destructor se llama al crear una instancia de MyClass?

No lo es. Sin embargo, debe invocarse automáticamente cuando la instancia se sale del alcance. Si es privado, el compilador no debe generar ese código, de ahí el error.

Si cree que haciendo lo privado destructor es oscura, otra manera de restringir una clase para la asignación dinámica es hacer que todos los constructores privados y sólo tienen MyClass::create() funciones que devuelven los objetos asignados dinámicamente:

class MyClass { 
public: 
    static MyClass* create()    {return new MyClass();} 
    static MyClass* create(const Foo& f) {return new MyClass(f);} 
private: 
    MyClass(); 
    MyClass(const Foo&); 
}; 

Note que el regreso los indicadores desnudos de los objetos que deben borrarse están mal visto. Debe devolver punteros inteligentes lugar:

class MyClass { 
public: 
    static std::shared_ptr<MyClass> create()    {return new MyClass();} 
    static std::shared_ptr<MyClass> create(const Foo& f) {return new MyClass(f);} 
    // ... 
}; 

Answer 3

instancia Porque cuando sale del ámbito, que tiene que ser destruido mediante destructor. Puntero a instancia no hace esto.

Answer 4

Cuando una variable local se sale del alcance, se destruye. Y en la destrucción, se llama destructor de objeto. Aquí, el alcance es de función principal. Cuando el programa sale, el destructor del objeto myclass se llamará

Answer 5

No lo es. El compilador intenta llamar al destructor cuando sale del alcance e indica la línea de código que produce este efecto, que es mucho más útil que señalar al final de la función.