如何为带有一个参数的类初始化一个shared_ptr向量？

Question

The following is the expanded version, which works fine, only I'd like to use an initializer list

vector<shared_ptr<Foo>> inputs = {
    make_shared<Foo>("foo"),
    make_shared<Foo>("bar"),
    make_shared<Foo>("baz")
};

So I've tried something like

vector<shared_ptr<Foo>> inputs2 = {
    { "foo" },
    { "bar" },
    { "baz" }
};

as well as with two brackets, or none, ie {{ "foo" }} and just "foo" .

std::shared_ptr<Foo> foo = { "foo" };

doesn't compile either, so I think this isn't a matter of vectors at all, but initializing shared_ptrs with initializer lists.

Answer 1

The only reasonable version is the first one you suggested.
If you look at the std::shared_ptr documentation , you will see that there is no constructor that gets the managed - object constructor arguments as variadic template. Meaning you will not find something like:

template<class T,class... Arg>
std::shared_ptr<T>::shared_ptr(Args&&... args)

so you can't really do something like

std::shared_ptr<std::string> p("hi there");

It will not work. What you can do for std::shared_ptr is construct it with T* , so this should work:

std::shared_ptr<std::string> p(new std::string("hi"));

Now, you might be thinking, "Hey! I can use it inside an initializer-list!" but no, this:

std::initializer_list<std::shared_ptr<std::string>> il{
        new std::string("hi there"),
        new std::string("hi there")
};

will not work, because that specific constructor has the explicit keyword on it, so it must be declared explicitly!

So eventually, you can write something like

std::initializer_list<std::shared_ptr<std::string>> il{
     std::shared_ptr<std::string>(new std::string("hi there"))
};

but as you see yourself, your first attempt is far simpler and shorter.

Summary: Given the fact that there is no shared_ptr constructor that passes the arguments into the managed object constructor, you can't really use {args...} as a valid syntax. Given the fact that the shared_ptr which gets T* must be declared explicitly, you can't do something like {new T(args..)} , so the simplest way is to use std::make_shared .

PS In your first snippet, the thing that is used to initialize the vector is initializer list. Except that its type is std::initializer_list<std::shared_ptr<Foo>> and not std::initializer_list<Foo> like the second snippet.

Answer 2

You could do something silly like this:

template< typename Cont >
void consume_append_shared( Cont& c ) {} // terminator

template< typename Cont, typename T, typename... Args >
void consume_append_shared( Cont& c, T&& t, Args&& ...args )
{
    typedef typename Cont::value_type::element_type ElemType;
    c.push_back(
        std::make_shared<ElemType> ( std::forward<T>(t) )
    );
    consume_append_shared( c, std::forward<Args>(args)... );
}

template<typename T, typename... Args>
std::vector< std::shared_ptr<T> > make_shared_vector( Args&& ...args )
{
    std::vector< std::shared_ptr<T> > vec;
    vec.reserve( sizeof...(Args) );
    consume_append_shared( vec, std::forward<Args>(args)... );
    return vec;
}

See it live here

It only works if T's constructor expect one parameter.