Passando shared_ptr <Derived> como shared_ptr <Base>

Qual é o melhor método para passar a shared_ptrde um tipo derivado para uma função que recebe a shared_ptrde um tipo base?

Eu geralmente passo shared_ptrs por referência para evitar uma cópia desnecessária:

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

mas isso não funciona se eu tentar fazer algo como

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

...

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

eu poderia usar

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

mas isso parece abaixo do ideal por dois motivos:

• A dynamic_castparece um pouco excessivo para um elenco simples de derivado para base.
• Pelo que entendi, dynamic_pointer_castcria uma cópia (embora temporária) do ponteiro para passar para a função.

Existe uma solução melhor?

Atualização para a posteridade:

Era um problema de falta de um arquivo de cabeçalho. Além disso, o que eu estava tentando fazer aqui é considerado um antipadrão. Geralmente,

• Funções que não afetam a vida útil de um objeto (ou seja, o objeto permanece válido durante a função) devem receber uma referência simples ou ponteiro, por exemplo int foo(bar& b).

• Funções que consomem um objeto (ou seja, são os usuários finais de um determinado objeto) devem assumir um unique_ptrvalor por, por exemplo int foo(unique_ptr<bar> b). Os chamadores devem std::moveinserir o valor na função.

• As funções que estendem a vida útil de um objeto devem assumir um shared_ptrvalor por, por exemplo int foo(shared_ptr<bar> b). O conselho usual para evitar referências circulares se aplica.

Consulte a palestra de volta ao básico de Herb Sutter para obter detalhes.

Embora Basee Derivedsejam covariantes, os ponteiros brutos para eles agirão de acordo shared_ptr<Base>e nãoshared_ptr<Derived> são covariantes. Esta é a maneira correta e mais simples de lidar com esse problema.dynamic_pointer_cast

( Editar: static_pointer_cast seria mais apropriado porque você está transmitindo do derivado para a base, o que é seguro e não requer verificações de tempo de execução. Veja os comentários abaixo.)

No entanto, se sua foo()função não deseja participar do prolongamento da vida útil (ou, melhor, participar da propriedade compartilhada do objeto), então é melhor aceitar const Base&ae desreferenciá-la shared_ptrao passá-la para foo().

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

Como um aparte, porque shared_ptr tipos não podem ser covariantes, as regras de conversões implícitas entre os tipos de retorno covariante não se aplicam ao retornar tipos de shared_ptr<T>.

Isso também acontecerá se você se esquecer de especificar a herança pública na classe derivada, ou seja, se, como eu, você escrever isto:

class Derived : Base
{
};

Parece que você está se esforçando demais. shared_ptré barato para copiar; esse é um de seus objetivos. Repassá-los por referência não faz muito. Se você não quiser compartilhar, passe o ponteiro bruto.

Dito isso, há duas maneiras de fazer isso que posso imaginar de início:

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

Verifique também se #includeo arquivo de cabeçalho que contém a declaração completa da classe derivada está em seu arquivo de origem.

Eu tive esse problema. O std::shared<derived>não seria lançado std::shared<base>. Eu havia declarado as duas classes para que pudesse conter ponteiros para elas, mas, como não tinha o, #includeo compilador não conseguia ver que uma classe era derivada da outra.