Gemeinsame Zeiger als Argumente übergeben

Wenn ich ein Objekt deklariere, das in einen gemeinsamen Zeiger eingeschlossen ist:

std::shared_ptr<myClass> myClassObject(new myClass());

dann wollte ich es als Argument an eine Methode übergeben:

DoSomething(myClassObject);

//the called method
void DoSomething(std::shared_ptr<myClass> arg1)
{
   arg1->someField = 4;
}

Erhöht das oben Gesagte einfach die Referenzanzahl von shared_pt und alles ist cool? Oder hinterlässt es einen baumelnden Zeiger?

Solltest du das noch tun?:

DoSomething(myClassObject.Get());

void DoSomething(std::shared_ptr<myClass>* arg1)
{
   (*arg1)->someField = 4;
}

Ich denke, dass der zweite Weg effizienter sein kann, da nur 1 Adresse kopiert werden muss (im Gegensatz zum gesamten Smart Pointer), aber der erste Weg scheint besser lesbar zu sein und ich erwarte nicht, die Leistungsgrenzen zu überschreiten. Ich möchte nur sicherstellen, dass nichts Gefährliches daran ist.

Danke dir.

Ich möchte einen gemeinsamen Zeiger an eine Funktion übergeben. Kannst du mir damit helfen?

Klar, das kann ich dir helfen. Ich gehe davon aus, dass Sie ein gewisses Verständnis der Besitzersemantik in C ++ haben. Ist das wahr?

Ja, ich bin ziemlich zufrieden mit dem Thema.

Gut.

Ok, ich kann mir nur zwei Gründe vorstellen, um ein shared_ptrArgument anzunehmen:

1. Die Funktion möchte das Eigentum an dem Objekt teilen.
2. Die Funktion führt eine Operation aus, die speziell für shared_ptrs funktioniert .

Für welches interessieren Sie sich?

Ich suche nach einer allgemeinen Antwort, also interessiere ich mich eigentlich für beides. Ich bin allerdings gespannt, was Sie in Fall 2 meinen.

Beispiele für solche Funktionen sind std::static_pointer_castbenutzerdefinierte Komparatoren oder Prädikate. Wenn Sie beispielsweise alle eindeutigen shared_ptr aus einem Vektor suchen müssen, benötigen Sie ein solches Prädikat.

Ah, wenn die Funktion tatsächlich den Smart Pointer selbst manipulieren muss.

Genau.

In diesem Fall sollten wir meiner Meinung nach als Referenz dienen.

Ja. Und wenn sich der Zeiger dadurch nicht ändert, möchten Sie die const-Referenz übergeben. Sie müssen nicht kopieren, da Sie das Eigentum nicht teilen müssen. Das ist das andere Szenario.

OK habe es. Lassen Sie uns über das andere Szenario sprechen.

Der, an dem Sie das Eigentum teilen? OK. Wie teilen Sie das Eigentum mit shared_ptr?

Durch Kopieren.

Dann muss die Funktion eine Kopie von a shared_ptrerstellen, richtig?

Offensichtlich. Also übergebe ich es durch einen Verweis auf const und kopiere es in eine lokale Variable?

Nein, das ist eine Pessimisierung. Wenn es als Referenz übergeben wird, hat die Funktion keine andere Wahl, als die Kopie manuell zu erstellen. Wenn es als Wert übergeben wird, wählt der Compiler die beste Wahl zwischen einer Kopie und einer Verschiebung und führt sie automatisch aus. Übergeben Sie also den Wert.

Guter Punkt. Ich muss mich öfter an den Artikel " Willst du Geschwindigkeit? Pass by Value " erinnern .

Warten Sie, was ist, wenn die Funktion das beispielsweise shared_ptrin einer Mitgliedsvariablen speichert ? Wird das nicht eine redundante Kopie machen?

Die Funktion kann das shared_ptrArgument einfach in seinen Speicher verschieben. Das Verschieben von a shared_ptrist billig, da es keine Referenzanzahl ändert.

Ah, gute Idee.

Aber ich denke an ein drittes Szenario: Was ist, wenn Sie das nicht manipulieren shared_ptroder das Eigentum teilen wollen?

In diesem Fall shared_ptrist für die Funktion völlig irrelevant. Wenn Sie den Pointee manipulieren möchten, nehmen Sie einen Pointee und lassen Sie die Anrufer auswählen, welche Besitzersemantik sie möchten.

Und sollte ich den Pointee als Referenz oder als Wert nehmen?

Es gelten die üblichen Regeln. Intelligente Zeiger ändern nichts.

Übergeben Sie den Wert, wenn ich kopieren möchte, und übergeben Sie ihn als Referenz, wenn ich eine Kopie vermeiden möchte.

Richtig.

Hmm. Ich denke, Sie haben noch ein anderes Szenario vergessen. Was ist, wenn ich das Eigentum teilen möchte, aber nur abhängig von einer bestimmten Bedingung?

Ah, ein interessanter Randfall. Ich erwarte nicht, dass das oft passiert. In diesem Fall können Sie entweder den Wert übergeben und die Kopie ignorieren, wenn Sie sie nicht benötigen, oder als Referenz übergeben und die Kopie erstellen, wenn Sie sie benötigen.

Ich riskiere eine redundante Kopie in der ersten Option und verliere einen möglichen Zug in der zweiten. Kann ich den Kuchen nicht essen und ihn auch haben?

Wenn Sie sich in einer Situation befinden, in der dies wirklich wichtig ist, können Sie zwei Überladungen bereitstellen, eine mit einer Konstantenwertreferenz und eine mit einer Wertreferenz. Eine Kopie, die andere bewegt sich. Eine perfekte Weiterleitungsfunktionsvorlage ist eine weitere Option.

Ich denke, das deckt alle möglichen Szenarien ab. Vielen Dank.

Ich denke, die Leute haben unnötig Angst davor, rohe Zeiger als Funktionsparameter zu verwenden. Wenn die Funktion den Zeiger nicht speichern oder seine Lebensdauer auf andere Weise beeinflussen soll, funktioniert ein Rohzeiger genauso gut und repräsentiert den kleinsten gemeinsamen Nenner. Überlegen Sie zum Beispiel, wie Sie a unique_ptran eine Funktion übergeben würden, die a shared_ptrals Parameter verwendet, entweder nach Wert oder nach const-Referenz?

void DoSomething(myClass * p);

DoSomething(myClass_shared_ptr.get());
DoSomething(myClass_unique_ptr.get());

Ein Rohzeiger als Funktionsparameter hindert Sie nicht daran, intelligente Zeiger im aufrufenden Code zu verwenden, wo es wirklich darauf ankommt.

Ja, die gesamte Idee eines shared_ptr <> besteht darin, dass mehrere Instanzen denselben Rohzeiger enthalten können und der zugrunde liegende Speicher nur freigegeben wird, wenn dort die letzte Instanz von shared_ptr <> zerstört wird.

Ich würde einen Zeiger auf einen shared_ptr <> vermeiden, da dies den Zweck zunichte macht, da Sie sich jetzt wieder mit raw_pointers beschäftigen.

Das Übergeben von Werten in Ihrem ersten Beispiel ist sicher, aber es gibt eine bessere Redewendung. Wenn möglich an const-Referenz übergeben - ich würde ja sagen, auch wenn es sich um intelligente Zeiger handelt. Ihr zweites Beispiel ist nicht gerade kaputt, aber es ist sehr !???. Dumm, nichts zu erreichen und einen Teil des Punktes der intelligenten Zeiger zu besiegen, und Sie in einer fehlerhaften Welt voller Schmerzen zurückzulassen, wenn Sie versuchen, Dinge zu dereferenzieren und zu modifizieren.

In Ihrer Funktion DoSomething ändern Sie ein Datenelement einer Klasseninstanz. Sie ändern myClass also das verwaltete Objekt (Rohzeiger) und nicht das Objekt (shared_ptr). Dies bedeutet, dass am Rückgabepunkt dieser Funktion alle gemeinsam genutzten Zeiger auf den verwalteten Rohzeiger ihr Datenelement sehen: myClass::someFieldgeändert auf einen anderen Wert.

In diesem Fall übergeben Sie ein Objekt an eine Funktion mit der Garantie, dass Sie es nicht ändern (es handelt sich um shared_ptr, nicht um das eigene Objekt).

Die Redewendung, um dies auszudrücken, ist durch: ein const ref, wie so

void DoSomething(const std::shared_ptr<myClass>& arg)

Ebenso versichern Sie dem Benutzer Ihrer Funktion, dass Sie der Liste der Eigentümer des Rohzeigers keinen weiteren Eigentümer hinzufügen. Sie haben jedoch die Möglichkeit beibehalten, das zugrunde liegende Objekt zu ändern, auf das der Rohzeiger zeigt.

CAVEAT: Das heißt, wenn auf irgendeine Weise jemand anruft, shared_ptr::resetbevor Sie Ihre Funktion aufrufen, und in diesem Moment der letzte shared_ptr ist, der den raw_ptr besitzt, wird Ihr Objekt zerstört und Ihre Funktion manipuliert einen baumelnden Zeiger auf ein zerstörtes Objekt. SEHR GEFÄHRLICH!!!