Passare un puntatore intelligente come argomento all'interno di una classe: scoped_ptr o shared_ptr?

Question

Ho una classe che crea un oggetto all'interno di un metodo pubblico. L'oggetto è privato e non visibile agli utenti della classe. Questo metodo quindi chiama altri privati ​​ metodi all'interno della stessa classe e passare l'oggetto creato come parametro:

class Foo { 
    ... 
}; 

class A { 
    private: 
     typedef scoped_ptr<Foo> FooPtr; 

     void privateMethod1(FooPtr fooObj); 

    public: 
     void showSomethingOnTheScreen() { 
      FooPtr fooObj(new Foo); 
      privateMethod1(fooObj); 
     }; 
}; 

Credo che il puntatore intelligente corretto in questo caso sarebbe uno scoped_ptr, però, non posso fare questo perché scoped_ptr rende la non copiabili classe, se usato in questo modo, quindi dovrei fare i metodi come questo:

void privateMethod1(FooPtr& fooObj); 

privateMethod1 non memorizza l'oggetto, né mantiene i riferimenti di esso. Recupera solo i dati dalla classe Foo.

Probabilmente il modo corretto sarebbe non utilizzare affatto un puntatore intelligente e allocare l'oggetto nello stack, ma ciò non è possibile perché utilizza una libreria che non consente oggetti nello stack, che devono essere nell'heap .

Dopotutto, sono ancora confuso riguardo al reale utilizzo di scoped_ptr.

Answer 1

Utilizzare qui semplice std :: auto_ptr poiché non è possibile creare oggetti nello stack. Ed è meglio per la tua funzione privata accettare semplicemente il puntatore raw.

L'utilizzo reale è che non è necessario prendere tutte le eccezioni possibili e fare l'eliminazione manuale.

In realtà, se l'oggetto è non modificare l'oggetto e l'oggetto di ritorno API di sicuro è meglio usare

void privateMethod1(const Foo& fooObj); 

e passare l'oggetto lì come

privateMethod1(*fooObj.get()); 

Answer 2

I' m sospettoso del commento "usa una libreria che non ammette oggetti in pila, devono essere nell'heap".

Perché? Questo in genere significa che devono essere deallocati in un modo speciale, quindi forse nessuna di queste soluzioni funzionerà.

Answer 3

Un'ulteriore possibilità è quella di creare l'oggetto come static_ptr per facilità di gestione della memoria, ma solo passare il puntatore grezzo agli altri metodi privati:

void privateMethod1(Foo *fooObj); 

void showSomethingOnTheScreen() { 
    scoped_ptr<Foo> fooObj(new Foo); 
    privateMethod1(fooObj.get()); 
}; 

Answer 4

userei scoped_ptr all'interno showSomethingOnTheScreen, ma passare un puntatore (o riferimento) crudo a privateMethod1, ad es

scoped_ptr <Foo> fooObj (nuovo Foo);
privateMethod1 (fooObj.get());

Answer 5

In tal caso, è sufficiente sostituire il meccanismo di assegnazione.
Creare l'oggetto nell'heap, ma passare l'oggetto come riferimento ai metodi privati.

class A { 
    private: 
     void privateMethod1(Foo& fooObj); 

    public: 
     void showSomethingOnTheScreen() { 
      scoped_ptr<Foo> fooObj(new Foo); 
      privateMethod1(*(fooObj.get())); 
     }; 
};