Übergeben von shared_ptr <Derived> als shared_ptr <Base>

Was ist die beste Methode, um shared_ptreinen abgeleiteten Typ an eine Funktion zu übergeben, die shared_ptreinen Basistyp verwendet?

Ich übergebe im Allgemeinen shared_ptrs als Referenz, um eine unnötige Kopie zu vermeiden:

int foo(const shared_ptr<bar>& ptr);

aber das funktioniert nicht, wenn ich versuche, so etwas zu tun

int foo(const shared_ptr<Base>& ptr);

...

shared_ptr<Derived> bar = make_shared<Derived>();
foo(bar);

ich könnte benutzen

foo(dynamic_pointer_cast<Base, Derived>(bar));

Dies scheint jedoch aus zwei Gründen nicht optimal zu sein:

• A dynamic_castscheint für eine einfache Ableitung von der Basis zur Basis etwas übertrieben zu sein.
• So wie ich es verstehe, dynamic_pointer_castwird eine Kopie (wenn auch eine temporäre) des Zeigers erstellt, die an die Funktion übergeben wird.

Gibt es eine bessere Lösung?

Update für die Nachwelt:

Es stellte sich heraus, dass eine Header-Datei fehlte. Auch was ich hier versucht habe, wird als Antimuster angesehen. Allgemein,

• Funktionen, die sich nicht auf die Lebensdauer eines Objekts auswirken (dh das Objekt bleibt für die Dauer der Funktion gültig), sollten eine einfache Referenz oder einen Zeiger verwenden, z int foo(bar& b).

• Funktionen, die ein Objekt verbrauchen (dh die Endbenutzer eines bestimmten Objekts sind), sollten einen unique_ptrBy-Wert annehmen , z int foo(unique_ptr<bar> b). Anrufer sollten std::moveden Wert in die Funktion einfließen lassen .

• Funktionen, die die Lebensdauer eines Objekts verlängern, sollten einen shared_ptrBy-Wert annehmen , z int foo(shared_ptr<bar> b). Die übliche Beratung zu vermeiden zirkuläre Referenzen gilt.

Weitere Informationen finden Sie im Back to Basics-Vortrag von Herb Sutter .

Obwohl Baseund Derivedsind kovariant und rohe Zeiger auf sie werden entsprechend handeln shared_ptr<Base>und shared_ptr<Derived>sind nicht kovariant. Dasdynamic_pointer_cast ist der richtige und einfachste Weg , um dieses Problem zu behandeln.

( Bearbeiten: static_pointer_cast wäre besser geeignet, da Sie von abgeleitet zu Basis übertragen, was sicher ist und keine Laufzeitprüfungen erfordert. Siehe Kommentare unten.)

Wenn Ihre foo()Funktion jedoch nicht an der Verlängerung der Lebensdauer teilnehmen möchte (oder vielmehr am gemeinsamen Besitz des Objekts teilnehmen möchte), ist es am besten, a zu akzeptieren const Base&und das zu dereferenzieren, shared_ptrwenn Sie es an übergeben foo().

void foo(const Base& base);
[...]
shared_ptr<Derived> spDerived = getDerived();
foo(*spDerived);

Da shared_ptrTypen nicht kovariant sein können, gelten die Regeln für implizite Konvertierungen über kovariante Rückgabetypen hinweg nicht, wenn Typen von zurückgegeben werden shared_ptr<T>.

Dies geschieht auch, wenn Sie vergessen haben, die öffentliche Vererbung für die abgeleitete Klasse anzugeben , dh wenn Sie wie ich Folgendes schreiben:

class Derived : Base
{
};

Klingt so, als würden Sie sich zu sehr anstrengen. shared_ptrist billig zu kopieren; Das ist eines seiner Ziele. Wenn Sie sie als Referenz weitergeben, wird nicht wirklich viel erreicht. Wenn Sie keine Freigabe wünschen, übergeben Sie den Rohzeiger.

Es gibt jedoch zwei Möglichkeiten, die ich mir auf den ersten Blick vorstellen kann:

foo(shared_ptr<Base>(bar));
foo(static_pointer_cast<Base>(bar));

Überprüfen Sie auch, ob sich die #includeHeader-Datei mit der vollständigen Deklaration der abgeleiteten Klasse in Ihrer Quelldatei befindet.

Ich hatte dieses Problem. Das std::shared<derived>würde nicht besetzen std::shared<base>. Ich hatte beide Klassen vorwärts deklariert, damit ich Zeiger auf sie halten konnte, aber weil ich den nicht hatte, konnte #includeder Compiler nicht sehen, dass eine Klasse von der anderen abgeleitet war.