如何使用可变长度序列容器的内容初始化结构内的 std::array 字段？

Question

I have a struct which in an extremely simplified representation looks like this:

struct Flags {
    const std::array<unsigned int, 8> flags;

    Flags(std::vector<unsigned int> initialFlagValues) : flags(initialFlagValues) {}
};

Which of course does not compile. For the purposes of my program, I'd like to initialise an arbitrary number of elements in flags , depending on the length of a parameter ( std::vector , C-style array, or otherwise) passed into the constructor of the struct.

Now I'd like to use a std::array inside the struct, as the struct itself is created many times (so a std::vector would not be ideal here due to many allocations/deallocations), but the number of values within flags that need to be initialised is not always the same.

Is there a way I can initialise a specific number of fields in flags depending on the size of the sequence container passed as a parameter into the constructor?

Answer 1

Use a helper function, perhaps in the form of a lambda:

Flags(std::vector<unsigned int> initialFlagValues) :
    flags([](const auto& init) {
             std::array<unsigned int, 8> flags;
             // bounds check omitted for brevity
             std::copy(init.begin(), init.end(), flags.begin());
             return flags;
         }(initialFlagValues))
{}

Answer 2

Maybe the helper function can be a delegated constructor

struct Flags
 {
   std::array<unsigned int, 8u> const flagsArr;

   template <std::size_t ... Is>
   Flags (std::vector<unsigned int> iFV, std::index_sequence<Is...>)
      : flagsArr{ Is < iFV.size() ? iFV[Is] : 0u ... }
    {}

   Flags (std::vector<unsigned int> iFV)
      : Flags{iFV, std::make_index_sequence<8u>{}}
    {}
};

You can generalize with for generic types supporting operator [] and std::size() (so also C-style arrays) as follows

struct Flags
 {
   std::array<unsigned int, 8u> const flagsArr;

   template <typename T, std::size_t ... Is>
   Flags (T const & iFV, std::index_sequence<Is...>)
      : flagsArr{ Is < std::size(iFV) ? iFV[Is] : 0u ... }
    {}

   template <typename T>
   Flags (T const & iFV)
      : Flags{iFV, std::make_index_sequence<8u>{}}
    {}
};

Answer 3

std::array is an aggregate. That means the only way to initialized it is with a braced_init_list ( {} ). There is no way to convert a std::vector into a braced_init_list so one thing you can do is to use a loop inside the constructor like

Flags(std::vector<unsigned int> initialFlagValues) : flags{} // zero out flags
{
    auto size = std::min(initialFlagValues.size(), flags.size())
    for (size_t i = 0; i < size; ++i)
        flags[i] = initialFlagValues[i];
}

This will nessecitate that flags be non-const. If that is a change you can't make, then you'll need to make initialFlagValues a std::array , or use a helper function to return an array that you can use to initialize flags with.

Answer 4

You can also do everything at (almost) compile-time, with no iterations:

#include <iostream>
#include <type_traits>
#include <iterator>

struct Omg {
        static constexpr std::size_t SIZE = 8;

        template<class Container> Omg(Container &&c)
                : Omg(std::forward<Container>(c), std::make_index_sequence<SIZE>{})
        {}

        void omg() const {
                for(auto i: array) std::cout << i << ' ';
                std::cout << '\n';
        }
private:
        template<class C, std::size_t... is> Omg(C &&c, std::index_sequence<is...>)
                : array{get<is>(std::forward<C>(c))...}
        {}

        template<std::size_t i, class C> static constexpr auto get(C &&c) {
                return i < std::size(c)? c[i] : 0;
        }

        std::array<int, SIZE> array;
};

int main() {
        Omg(std::vector<int>{0, 1, 2, 3}).omg();
        int nyan[] = {42, 28, 14};
        Omg(nyan).omg();
}