的std :: shared_ptr的 <type> （new DerivedType（…））！= std :: make_shared <type> （DerivedType（...））？

Question

I haven't found any issues quite like this yet: but if someone finds one then sorry. I've been trying to use std::shared_ptr to greatly simplify memory management, however I've come across what must be some sort of bug.

When I create a DerivedType pointer with std::make_shared<type>(DerivedType(...)) It can only be addressed as a Type rather than a DerivedType .

Yet when I use the syntax std::shared_ptr<Type>(new DerivedType) the vfptr table lists the correct entries and it can be cast to a DerivedType without a problem.

I believe there should be no difference. Is this a bug in my understanding? or an actual bug?

Thanks for your help. Luke

Answer 1

You must pass to std::make_shared the parameters that you'd pass to your type's constructor, and they are forwarded .
You can then convert the resulting pointer to a base pointer implicitly.

std::shared_ptr<Type> p = std::make_shared<DerivedType>(...);

Let's dig a bit in the "why" in your question.

std::shared_ptr<Type>(new DerivedType);

This does work, and does nothing noteworthy. However, std::make_shared is usually preferred, because the latter can allocate std::shared_ptr 's bookkeeping data along with your object, and thus is faster and cheaper, as well as exception-safe*.

std::make_shared<Type>(DerivedType(...))

You saw it : it doesn't work. What happens here is that you create a DerivedType instance. std::make_shared happily forwards it to the constructor of Type .
Overload resolution happens, and Type 's copy constructor (or its move constructor, if available) is called, with a reference to your DerivedType 's base part. And a plain Type object gets instantiated and pointed to. The original DerivedType vanishes. This issue as a whole is called slicing .

* Note on exception safety : Shoud you use a function of the form :

void func(std::shared_ptr<A> a, std::shared_ptr<B> b);

... constructing the std::shared_ptr s like so :

func(std::shared_ptr<A>(new A), std::shared_ptr<B>(new B);

... can leak if, for example, new A is called, then new B , and the latter throws an exception. The A has not yet been wrapped into a smart pointer, and is unrecoverable.

Answer 2

std::make_shared<type>(DerivedType(...))

HEre replace make_shared<Type> with make_shared<DerivedType> and it all should work

upd: highlighted the change