Come impedire la creazione di un oggetto sull'heap?

Question

Qualcuno sa come posso, in codice C++ indipendente dalla piattaforma impedire la creazione di un oggetto sull'heap? Cioè, per una classe di "Pippo", voglio impedire agli utenti di fare questo:

Foo *ptr = new Foo; 

e solo permettere loro di fare questo:

Foo myfooObject; 

Qualcuno ha qualche idea?

Cheers,

Answer 1

Nick's answer è un buon punto di partenza, ma incompleta, come è effettivamente necessario sovraccaricare:

private: 
    void* operator new(size_t);   // standard new 
    void* operator new(size_t, void*); // placement new 
    void* operator new[](size_t);  // array new 
    void* operator new[](size_t, void*); // placement array new 

(buona pratica di codifica suggerirebbe si dovrebbe anche sovraccaricare l'eliminazione ed eliminare gli operatori [] - lo farei, ma dal momento che non stanno andando a ottenere chiamato non è davvero necessario.)

Pauldoo è anche corretto che questo non sopravvive aggregando su Foo, anche se non sopravvive che eredita da Foo. Potresti fare qualche modello di meta-programmazione magica per AIUTARE a prevenire questo, ma non sarebbe immune da "utenti malvagi" e quindi probabilmente non vale la complicazione. La documentazione su come dovrebbe essere usata, e la revisione del codice per assicurarsi che sia usata correttamente, sono l'unico modo ~ 100%.

Answer 2

Si potrebbe dichiarare una funzione chiamata "operatore nuovo" all'interno della classe Foo, che avrebbe bloccato l'accesso alla forma normale di nuovo.

È questo il tipo di comportamento che si desidera?

Answer 3

È possibile sovraccaricare nuovo per Foo e renderlo privato. Ciò significherebbe che il compilatore si lamenterebbe ... a meno che tu non stia creando un'istanza di Foo sull'heap dall'interno di Foo. Per cogliere questo caso, potresti semplicemente non scrivere il nuovo metodo di Foo e quindi il linker si lamenterebbe dei simboli non definiti.

class Foo { 
private: 
    void* operator new(size_t size); 
}; 

PS. Sì, so che questo può essere aggirato facilmente. Non lo raccomando davvero - penso che sia una cattiva idea - stavo solo rispondendo alla domanda! ;-)

Answer 4

Non sono sicuro se questo offre opportunità in fase di compilazione, ma hai visto sovraccaricare il "nuovo" operatore per la tua classe?

Answer 5

non so come farlo in modo affidabile e in modo portatile .. ma ..

Se l'oggetto è in pila allora si potrebbe essere in grado di far valere all'interno del costruttore che il valore di ' questo 'è sempre vicino al puntatore dello stack. C'è una buona probabilità che l'oggetto sia in pila, se questo è il caso.

credo che non tutte le piattaforme implementano loro stack nella stessa direzione, così si potrebbe desiderare di fare un test una tantum quando l'applicazione inizia a verificare in che modo la pila cresce .. O fare un po 'fudge:

FooClass::FooClass() { 
    char dummy; 
    ptrdiff_t displacement = &dummy - reinterpret_cast<char*>(this); 
    if (displacement > 10000 || displacement < -10000) { 
     throw "Not on the stack - maybe.."; 
    } 
} 

Answer 6

@ Nick

Questo potrebbe essere aggirato creando una classe che deriva da o aggregati Foo. Penso che quello che suggerisco (anche se non robusto) funzionerebbe ancora per le classi derivate e aggregatrici.

es:

struct MyStruct { 
    Foo m_foo; 
}; 

MyStruct* p = new MyStruct(); 

Qui ho creato un'istanza di 'Foo' sul mucchio, bypassando nuovo operatore nascosto di Foo.

Answer 7

È possibile dichiararlo come interfaccia e controllare la classe di implementazione più direttamente dal proprio codice.

Answer 8

Perché le intestazioni di debug possono ignorare l'operatore firma nuova, è meglio usare le firme ... come rimedio completo:

private: 
void* operator new(size_t, ...) = delete; 
void* operator new[](size_t, ...) = delete; 

Answer 9

questo può essere evitato facendo i costruttori privati ​​e fornendo un membro statico a creare un oggetto nello stack

Class Foo 
{ 
    private: 
     Foo(); 
     Foo(Foo&); 
    public: 
     static Foo GenerateInstance() { 
      Foo a ; return a; 
     } 
} 

questo renderà la creazione dell'oggetto sempre nello stack.