Pasando shared_ptr <Derived> como shared_ptr <Base>

¿Cuál es el mejor método para pasar a shared_ptrde un tipo derivado a una función que toma a shared_ptrde un tipo base?

Generalmente paso shared_ptrs por referencia para evitar una copia innecesaria:

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

pero esto no funciona si trato de hacer algo como

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

...

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

Podría usar

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

pero esto parece subóptimo por dos razones:

• A dynamic_castparece un poco excesivo para un elenco simple derivado a base.
• Según tengo entendido, dynamic_pointer_castcrea una copia (aunque temporal) del puntero para pasar a la función.

¿Existe una solución mejor?

Actualización para la posteridad:

Resultó ser un problema de falta de archivo de encabezado. Además, lo que estaba tratando de hacer aquí se considera un antipatrón. Generalmente,

• Las funciones que no afectan la vida útil de un objeto (es decir, el objeto sigue siendo válido durante la duración de la función) deben tomar una referencia simple o un puntero, por ejemplo int foo(bar& b).

• Las funciones que consumen un objeto (es decir, son los usuarios finales de un objeto dado) deben tomar un unique_ptrvalor por ej int foo(unique_ptr<bar> b). Las personas que llaman deben incluir std::moveel valor en la función.

• Las funciones que extienden la vida útil de un objeto deben tomar un shared_ptrvalor por ejemplo, por ejemplo int foo(shared_ptr<bar> b). Se aplica el consejo habitual para evitar referencias circulares .

Consulte la charla Back to Basics de Herb Sutter para obtener más detalles.

Aunque Basey Derivedson indicadores covariantes y crudos, actuarán en consecuencia shared_ptr<Base>y noshared_ptr<Derived> son covariantes. El es la manera correcta y sencilla de manejar este problema.dynamic_pointer_cast

( Editar: static_pointer_cast sería más apropiado porque está transmitiendo de derivado a base, que es seguro y no requiere verificaciones de tiempo de ejecución. Consulte los comentarios a continuación).

Sin embargo, si su foo()función no desea participar en la extensión de la vida útil (o, más bien, participar en la propiedad compartida del objeto), entonces es mejor aceptar const Base&y eliminar la referencia shared_ptral pasarlo a foo().

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

Además, dado que los shared_ptrtipos no pueden ser covariantes, las reglas de conversiones implícitas entre tipos de devolución covariantes no se aplican al devolver tipos de shared_ptr<T>.

Esto también sucederá si ha olvidado especificar la herencia pública en la clase derivada, es decir, si como yo, escribe esto:

class Derived : Base
{
};

Parece que te estás esforzando demasiado. shared_ptres barato de copiar; ese es uno de sus objetivos. Pasarlos por referencia no logra mucho. Si no desea compartir, pase el puntero sin procesar.

Dicho esto, hay dos formas de hacer esto en las que puedo pensar:

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

También verifique que el #includedel archivo de encabezado que contiene la declaración completa de la clase derivada esté en su archivo fuente.

Tuve este problema. El std::shared<derived>no lanzaría a std::shared<base>. Había declarado hacia adelante ambas clases para poder contener punteros hacia ellas, pero como no tenía el, #includeel compilador no podía ver que una clase se derivaba de la otra.