Is there no way to have shared_ptr be silently created?

Question

Consider the following code:

#include <memory>

class A {};
class B : public A {};

void func( std::shared_ptr<A> ptr )
{
}

int main( int argc, char* argv[] )
{
    func( std::shared_ptr<A>( new B ) );
}

The syntax std::shared_ptr<A>( new B ) requires A class to be specified. It's a pain if the class is in a namespace and it makes code too verbose when it actually does not need to.

Is there no STL template function that would make the syntax lighter and have A be deduced automatically? I was thinking of something like: func( std::make_shared( new B ) ) but that's not what std::make_shared is meant for.

I mean, there's the same for pair, you can use std::make_pair without having to specify what are the first/second pair types, ther are automatically deduced. Is there not "equivalent" for shared_ptr?

related: https://stackoverflow.com/questions/16262338/get-base-class-for-a-type-in-class-hierarchy. Afaik you cannot find the base class given a derived type. — 463035818_is_not_an_ai, Dec 16 '20 at 10:41
even if you could, what would you expect for `struct X {}; struct Y {}; struct A : X {}; struct B : A,Y {};` ? which base is the most basy base of `B` ? — 463035818_is_not_an_ai, Dec 16 '20 at 10:42
`but that's not what std::make_shared is meant for.` Why do you think so? As far as I can tell, this is an ideal use case for it. Unlike your example, that one doesn't have undefined behaviuor. — eerorika, Dec 16 '20 at 10:43
@largest_prime_is_463035818: If func takes `shared_ptr` it would pickup `A`. If it takes `shared_ptr` it would pickup `Y`. If it's overloaded and takes both, I would expect an error saying the compiler is unable to deduce the argument... — jpo38, Dec 16 '20 at 10:45
@eerorika: What would be the syntax then? I could not use `std::make_shared` without specifying `A` template parameter. — jpo38, Dec 16 '20 at 10:46
@jpo38 You don't specify A since you're not creating an A object. You specify B because you are creating a B object. — eerorika, Dec 16 '20 at 10:47
@eerorika: I mean the syntax will be `std::make_shared( ... )`, while I'm looking for `std::some_function( new B )`, as I d'ont want `A` class to be specified, I want it to be automatically deduced. — jpo38, Dec 16 '20 at 10:49
@jpo38 That would be a wrong syntax for creating a `B` object. — eerorika, Dec 16 '20 at 10:50

score 2 · Accepted Answer · answered Dec 16 '20 at 10:49

2

but that's not what std::make_shared is meant for.

On the contrary, this is an ideal use case for std::make_shared:

 func(std::make_shared<B>());

Not only was no need to specify A, but also we have the advantage of the pointed object and the control block having a shared allocation.

Your example has undefined behaviour because the shared pointer would delete the object through pointer to a non-polymorphic base. This make_shared version doesn't have that problem.

answered Dec 16 '20 at 10:49

eerorika

232,697
12
197
326

All right, That's just what I was looking for and I was surprised `std::make_shared` did not help...but I was simply not using `make_shared`correctly! – jpo38 Dec 16 '20 at 10:52

Is there no way to have shared_ptr be silently created?

1 Answers1