Returning a shared_ptr from a function

Question

I'm very new to C++11, 'still very much experimenting with the extensions. I find the auto keyword very convenient, particularly when dealing with template variables. This means that given

template<typename ... Types>
struct Foo
{
};

template<typename ... Types>
Foo<Types ...>* create( Types ... types ... )
{
    return new Foo<Types ...>;
}

I can now make the assignment

auto t1 = create( 'a' , 42 , true , 1.234 , "str" );

instead of

Foo<char, int, bool, double , const char*>* t2 = create( 'a' , 42 , true , 1.234 , "str" );

The problem now is that because t1 is a pointer I'd like to hold it in a shared_ptr as Herb Sutter recommended. Therefore, I'd like to store the return value of create() in a shared_ptr without having to name the template argument types, as in t2.

There is no such thing as "an `auto`". See, this is why I disagreed with the proposal. — Lightness Races in Orbit, Oct 20 '12 at 22:15
`auto` is not a type, so the wording of the question is not really sensible. I'm pointing this out not to nitpick but because it suggests that you need to read up more on it to understand how it works. — Tamás Szelei, Oct 20 '12 at 22:16
What @fish said. It's easy to sound like an ass when pointing this sort of thing out, but it's genuinely done for good reason. — Lightness Races in Orbit, Oct 20 '12 at 22:17

nosid · Answer 1 · 2012-10-20T20:48:20.850

2

Avoid using raw pointers all together. Use std::make_shared and make_unique (not right in the standard) instead of new. Then auto will work nicely. E.g.

template <typename ...Args>
auto create(Args&&... args)
    -> std::shared_ptr<Foo<typename std::decay<Args>::type...>>
{
    return std::make_shared<Foo<typename std::decay<Args>::type...>>(
        std::forward<Args>(args)...);
}

edited Oct 20 '12 at 20:48

answered Oct 20 '12 at 20:35

nosid

48,932
13
112
139

`std::shared_ptr>` – Xeo Oct 20 '12 at 20:40
Is `-> std::shared_ptr` really part of the signature? – Olumide Oct 20 '12 at 20:47
3

@Olumide: Yes, but it's *entirely* unnecessary to use a [late-specified return type](http://en.wikipedia.org/wiki/C%2B%2B11#Alternative_function_syntax) here. – Nicol Bolas Oct 20 '12 at 21:35
Are the `...`s part of the actual code that you would compile? – David Grayson Oct 21 '12 at 00:55

score 0 · Answer 2 · answered Oct 20 '12 at 22:21

This is too long to post as a comment. Therefore I'm posting it here instead. Besides it might be an answer.

@nosid why not the following. Its less convoluted.

template<typename ... Types>
struct Foo
{
    Foo( Types ... types ... ) : m_data( types ...)
    {
    }

    std::tuple<Types...>    m_data;
};

template<typename ... Types>
std::shared_ptr<Foo<Types ...> > create( Types ... types ... )
{
    return std::make_shared<Foo<Types ...> >( types ... );
}

Returning a shared_ptr from a function

2 Answers2