std::initializer_list as std::array constructor

Question

I need to pass arguments to a wrapper class that looks as minimal example like this:

template<class TStack, unsigned int TBins>
class Wrapper : Stack<......>
{
    std::array<TStack, TBins> m_oStacks;

    template<typename ... Args>
    Wrapper(std::initializer_list<const unsigned int> const& size, Args&&... args)
    : Stack<.......>(args), m_oStacks{5,2,3,4,5,6,7,8,9,10}
    //, m_oStacks(size) //,m_oStacks{size} //,m_oStacks{{size}}
    {
        //m_oStacks = { size };           
    }
};

I tried to init the array with the initializer_list size but nothing works (commented parts of the source) only the constant {5,2,3,4,5,6,7,8,9,10} part does

Someone know the reason and a fix?

Sincerely Matyro

Edit 1: The main problem is that TStack does (in most cases) not have a default constructor so i need to initialize the array at construction

@Matyro Class std::array does not have a constructor that accepts the initializer_list. You should copy initializer_list in the array yourself. — Vlad from Moscow
– Vlad from Moscow, Commented Feb 18, 2016 at 17:51
Use std::array<TStack, TBins> instead of std::initializer_list<const unsigned int>, it can be list-initialized as well, and a std::array itself does have a copy constructor — Piotr Skotnicki
– Piotr Skotnicki, Commented Feb 18, 2016 at 18:16

Piotr Skotnicki · Accepted Answer · 2016-02-18 19:15:11Z

4

With std::initializer_list:

template <typename TStack, std::size_t TBins>
class Wrapper
{
public:
    Wrapper(std::initializer_list<unsigned int> il)
        : Wrapper(il, std::make_index_sequence<TBins>{})
    {
    }

private:
    template <std::size_t... Is>
    Wrapper(std::initializer_list<unsigned int> il, std::index_sequence<Is...>)
        : m_oStacks{{ *(il.begin() + Is)... }}
    {
    }

    std::array<TStack, TBins> m_oStacks;
};

DEMO

With std::array:

template <typename TStack, std::size_t TBins>
class Wrapper
{
public:
    Wrapper(const std::array<unsigned int, TBins>& a)
        : Wrapper(a, std::make_index_sequence<TBins>{})
    {
    }

private:
    template <std::size_t... Is>
    Wrapper(const std::array<unsigned int, TBins>& a, std::index_sequence<Is...>)
        : m_oStacks{{ a[Is]... }}
    {
    }

    std::array<TStack, TBins> m_oStacks;
};

DEMO 2

answered Feb 18, 2016 at 19:15

Piotr Skotnicki

48.8k7 gold badges122 silver badges167 bronze badges

Sign up to request clarification or add additional context in comments.

3 Comments

NathanOliver Over a year ago

I din't think that through all the way. Looks great.

Claas Bontus Over a year ago

The first case results in UB if the length of il is smaller than TBINS.

Jonathon Reinhart Over a year ago

Now can you deduce the TBins size (in either case)?

Collectives™ on Stack Overflow

std::initializer_list as std::array constructor

1 Answer 1

3 Comments

Your Answer

Linked

Hot Network Questions

Collectives™ on Stack Overflow

1 Answer 1

3 Comments

Your Answer

Sign up or log in

Post as a guest

Linked

Related