C++, impedendo la creazione di istanze di classe nello stack (durante la compilazione)

Question

So che esistono metodi per impedire la creazione di una classe nello heap, impedendo all'utente di utilizzare l'operatore new e delete. Sto cercando di fare esattamente il contrario. Ho una classe che voglio impedire all'utente di creare un'istanza di esso nello stack e che verranno compilate solo le istanze istigate usando l'operatore new. Più in particolare, voglio il seguente codice per ricevere un errore durante la compilazione:

MyClass c1; //compilation error 

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

Dalla ricerca sul web, ho trovato questo suggerimento su come farlo:

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

Quello che non capisco è perché questo dovrebbe funzionare. Perché dovrebbe essere chiamato il distruttore durante la creazione di un'istanza di MyClass?

Answer 1

Quando myclass raggiunge la fine del suo ambito (il prossimo }) il compilatore chiama il distruttore per liberarlo dallo stack. Se il distruttore è privato, tuttavia, non è possibile accedere al distruttore, quindi la classe non può essere posizionata nello stack.

Non mi piace l'aspetto di delete this. In generale, penso che gli oggetti non dovrebbero distruggersi. Forse un modo migliore è quello di avere un costruttore privato per la classe quindi utilizzare una funzione statica per creare un'istanza.

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

Perché il distruttore viene chiamato durante la creazione di un'istanza di MyClass?

Non lo è. Deve essere invocato automaticamente quando l'istanza esce dall'ambito, però. Se è privato, il compilatore non deve generare quel codice, quindi l'errore.

Se pensate che facendo il privato distruttore è oscura, un altro modo per limitare una classe per l'allocazione dinamica è quello di rendere tutti i costruttori privati ​​e hanno solo MyClass::create() funzioni che restituiscono oggetti allocati dinamicamente:

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

Nota che il ritorno puntatori nudi a oggetti che devono essere cancellati è disapprovato. Dovresti invece restituire dei puntatori intelligenti:

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

Perché quando l'istanza esce dal campo di applicazione, deve essere distrutta utilizzando il distruttore. Puntatore ad esempio non lo fa.

Answer 4

Ogniqualvolta una variabile locale esce dall'ambito, viene distrutta. E sulla distruzione, viene chiamato il distruttore dell'oggetto. Qui, lo scopo è della funzione principale. Quando il programma termina, il distruttore dell'oggetto myclass si chiamerà

Answer 5

Non lo è. Il compilatore sta tentando di chiamare il distruttore quando esce dall'ambito e indica la linea di codice che produce questo effetto, che è molto più utile del puntamento alla fine della funzione.