Übergeben eines intelligenten Zeigers als Argument in einer Klasse: scoped_ptr oder shared_ptr?

Question

Ich habe eine Klasse, die ein Objekt innerhalb einer öffentlichen Methode erstellt. Das Objekt ist privat und für die Benutzer der Klasse nicht sichtbar. Diese Methode ruft dann andere privaten Methoden innerhalb der gleichen Klasse und übergeben Sie das erstellte Objekt als Parameter:

class Foo { 
    ... 
}; 

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

     void privateMethod1(FooPtr fooObj); 

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

ich die richtige Smart-Pointer in diesem Fall glauben, wäre ein scoped_ptr sein, jedoch kann ich nicht tun dies, weil scoped_ptr macht die nicht kopierbar Klasse, wenn auf diese Weise verwendet wird, so sollte ich die Methoden wie diese machen:

void privateMethod1(FooPtr& fooObj); 

privateMethod1 speichert nicht das Objekt, weder hält Referenzen davon. Ruft nur Daten aus der Klasse Foo ab.

Der richtige Weg würde wahrscheinlich überhaupt keinen intelligenten Zeiger verwenden und das Objekt im Stapel zuweisen, aber das ist nicht möglich, weil es eine Bibliothek verwendet, die Objekte auf dem Stapel nicht erlaubt, sie müssen auf dem Heap sein .

Schließlich bin ich immer noch verwirrt über die tatsächliche Verwendung von scoped_ptr.

Answer 1

Verwenden Sie hier einfach std :: auto_ptr, da Sie keine Objekte auf dem Stapel erstellen können. Und es ist besser, Ihre private Funktion einfach nur rohe Zeiger zu akzeptieren.

Wirkliche Verwendung ist, dass Sie nicht alle möglichen Ausnahmen abfangen und manuell löschen müssen.

In der Tat, wenn Ihr Ziel ist es ändert nicht Objekt und Ihr API Rückgabeobjekt sicher ist besser,

void privateMethod1(const Foo& fooObj); 

zu verwenden und das Objekt dort passieren, wie

privateMethod1(*fooObj.get()); 

Answer 2

I‘ Ich bin misstrauisch gegenüber dem Kommentar "es verwendet eine Bibliothek, die keine Objekte auf dem Stapel erlaubt, sie müssen auf dem Heap sein."

Warum? Das bedeutet normalerweise, dass sie auf eine spezielle Art und Weise aufgelöst werden müssen - also wird vielleicht keine dieser Lösungen funktionieren.

Answer 3

Eine weitere Möglichkeit ist, das Objekt als static_ptr für einfache Speicherverwaltung zu schaffen, sondern nur den rohen Zeiger auf die anderen privaten Methoden übergeben:

void privateMethod1(Foo *fooObj); 

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

Answer 4

I scoped_ptr innen showSomethingOnTheScreen verwenden würde, aber ein Pass roher Zeiger (oder Verweis) auf privateMethod1, z

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

Answer 5

In diesem Fall müssen Sie nur den Zuweisungsmechanismus ersetzen.
Erstellen Sie das Objekt auf dem Heap, übergeben Sie das Objekt jedoch als Verweis auf private Methoden.

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

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