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

Каков наилучший способ передать a 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));

но это кажется неоптимальным по двум причинам:

• A dynamic_castкажется немного чрезмерным для простого приведения типа производного к основному.
• Насколько я понимаю, dynamic_pointer_castсоздает копию (пусть и временную) указателя для перехода к функции.

Есть ли лучшее решение?

Обновление для потомков:

Оказалось, проблема в отсутствующем файле заголовка. Кроме того, то, что я пытался здесь сделать, считается антипаттерном. В общем-то,

• Функции, которые не влияют на время жизни объекта (т. Е. Объект остается действующим на время выполнения функции), должны принимать простую ссылку или указатель, например int foo(bar& b).

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

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

См. Доклад Херба Саттера « Назад к основам» .

Хотя Baseи Derivedявляются ковариантными, но необработанные указатели на них будут действовать соответственно shared_ptr<Base>и неshared_ptr<Derived> являются ковариантными. Это самый правильный и простой способ справиться с этой проблемой.dynamic_pointer_cast

( Изменить: static_pointer_cast было бы более подходящим, потому что вы выполняете преобразование из производного в базовый, что безопасно и не требует проверок во время выполнения. См. Комментарии ниже.)

Однако, если ваша foo()функция не желает принимать участие в продлении времени жизни (или, скорее, участвовать в совместном владении объектом), то лучше всего принять 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компилятора, компилятор не мог видеть, что один класс является производным от другого.