Przekazywanie shared_ptr <Derived> jako shared_ptr <Base>

Jaka jest najlepsza metoda przekazywania a shared_ptrtypu pochodnego do funkcji, która przyjmuje shared_ptrtyp podstawowy?

Generalnie przekazuję shared_ptrje jako odniesienie, aby uniknąć niepotrzebnych kopii:

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

ale to nie działa, jeśli spróbuję zrobić coś takiego

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

...

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

mógłbym użyć

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

ale wydaje się to nieoptymalne z dwóch powodów:

• dynamic_castWydaje się nieco nadmierne dla prostego pochodzi do podstawy obsady.
• Jak rozumiem, dynamic_pointer_casttworzy kopię (choć tymczasową) wskaźnika, aby przejść do funkcji.

Czy jest lepsze rozwiązanie?

Aktualizacja dla potomnych:

Okazało się, że był to problem z brakującym plikiem nagłówkowym. Poza tym to, co próbowałem tutaj zrobić, jest uważane za anty-wzór. Ogólnie,

• Funkcje, które nie wpływają na czas życia obiektu (tj. Obiekt pozostaje ważny przez czas trwania funkcji) powinny przyjmować zwykłe odwołanie lub wskaźnik, np int foo(bar& b).

• Funkcje, które konsumują obiekt (czyli są końcowymi użytkownikami danego obiektu) powinny przyjmować unique_ptrwartość, np int foo(unique_ptr<bar> b). Wzywający powinni std::movepodać wartość do funkcji.

• Funkcje wydłużające żywotność obiektu powinny przyjmować shared_ptrwartość, np int foo(shared_ptr<bar> b). Obowiązuje zwyczajowa rada, aby unikać odwołań cyklicznych .

Szczegóły w artykule Herba Suttera Back to Basics .

Chociaż Basei Derivedsą kowariantne, a surowe wskaźniki do nich będą działać odpowiednio shared_ptr<Base>i nieshared_ptr<Derived> są kowariantne. Jest to poprawny i najprostszy sposób rozwiązania tego problemu.dynamic_pointer_cast

( Edycja: static_pointer_cast byłoby bardziej odpowiednie, ponieważ rzutujesz z wersji pochodnej do bazy, co jest bezpieczne i nie wymaga sprawdzania w czasie wykonywania. Zobacz komentarze poniżej).

Jeśli jednak twoja foo()funkcja nie chce brać udziału w wydłużaniu czasu życia (a raczej brać udział we współwłasności obiektu), to najlepiej jest zaakceptować a const Base&i usunąć odniesienie do shared_ptrpodczas przekazywania go foo().

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

Na marginesie, ponieważ shared_ptrtypy nie mogą być kowariantne, reguły niejawnych konwersji w kowariantnych typach zwracanych nie mają zastosowania podczas zwracania typów shared_ptr<T>.

Dzieje się tak również, jeśli zapomniałeś określić dziedziczenie publiczne w klasie pochodnej, tj. Jeśli tak jak ja napiszesz to:

class Derived : Base
{
};

Wygląda na to, że za bardzo się starasz. shared_ptrjest tani w kopiowaniu; to jeden z jego celów. Przekazywanie ich przez odniesienie tak naprawdę niewiele daje. Jeśli nie chcesz udostępniać, przekaż nieprzetworzony wskaźnik.

To powiedziawszy, są na to dwa sposoby, które przychodzą mi do głowy:

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

Sprawdź również, czy #includeplik nagłówkowy zawierający pełną deklarację klasy pochodnej znajduje się w pliku źródłowym.

Miałem ten problem. Nie std::shared<derived>chciał rzucać std::shared<base>. Zadeklarowałem obie klasy, aby móc przechowywać do nich wskaźniki, ale ponieważ nie miałem #includekompilatora, nie mogłem zobaczyć, że jedna klasa pochodzi od drugiej.