Передача shared_ptr <Derived> як shared_ptr <Base>

Який найкращий метод використовувати передачу shared_ptrпохідного типу функції, яка приймає shared_ptra базового типу?

Я зазвичай передаю shared_ptrs за посиланням, щоб уникнути непотрібної копії:

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

але це не працює, якщо я намагаюся зробити щось подібне

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

...

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

Я міг би використати

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

але це здається неоптимальним з двох причин:

• А dynamic_castздається трохи надмірним для простого похідного акторського складу.
• Як я розумію, dynamic_pointer_castстворює копію (хоча і тимчасову) вказівника для передачі функції.

Чи є краще рішення?

Оновлення для нащадків:

Це виявилося проблемою відсутнього файлу заголовка. Крім того, те, що я намагався зробити тут, вважається антиобразцем. Як правило,

• Функції , які не впливають життя об'єкта (тобто об'єкт залишається в силі в протягом терміну дії функції) повинні взяти звичайну посилання або покажчик, наприклад int foo(bar& b).

• Функції, які споживають об'єкт (тобто є кінцевими користувачами даного об'єкта), повинні приймати unique_ptrзначення by, наприклад int foo(unique_ptr<bar> b). Викличники повинні ввести std::moveзначення у функцію.

• Функції, що продовжують час життя об'єкта, повинні приймати shared_ptrзначення за значенням, наприклад int foo(shared_ptr<bar> b). Застосовується звичайна порада уникати циркулярних посилань .

Детальніше див. У розмові Herb Sutter « Назад до основ» .

Хоча Baseі Derivedє коваріантними, і необроблені вказівники на них діятимуть відповідно, shared_ptr<Base>і неshared_ptr<Derived> є коваріантними. Це правильний і найпростіший спосіб вирішення цієї проблеми.dynamic_pointer_cast

( Редагувати: static_pointer_cast було б доречніше, оскільки ви проводите кастинг з похідного на базу, що безпечно і не вимагає перевірки часу виконання. Див. Коментарі нижче.)

Однак, якщо ваша foo()функція не бажає брати участь у продовженні терміну служби (або, вірніше, брати участь у спільному володінні об'єктом), тоді найкраще прийняти a const Base&та розмежувати його shared_ptrпри передачі foo().

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

Окрім того, оскільки shared_ptrтипи не можуть бути коваріантними, правила неявних перетворень між коваріантними типами повернення не застосовуються при поверненні типів shared_ptr<T>.

Це також трапиться, якщо ви забули вказати загальнодоступне успадкування для похідного класу, тобто якщо, як я, ви напишете це:

class Derived : Base
{
};

Здається, ви занадто стараєтесь. shared_ptrкопіювати дешево; це одна з його цілей. Передача їх за допомогою посилання насправді не дає багато чого. Якщо ви не хочете ділитися, передайте сирий вказівник.

Тим не менш, є два способи зробити це, про що я можу подумати з маківки:

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

Також перевірте, чи #includeфайл заголовка, що містить повну декларацію похідного класу, знаходиться у вашому вихідному файлі.

У мене була ця проблема. Не std::shared<derived>хотів би кинути std::shared<base>. Я попередньо оголосив обидва класи, щоб міг тримати вказівники на них, але оскільки у мене не було #includeкомпілятора, я не міг бачити, що один клас походить від іншого.