Best strategy for initializing static arrays in a struct in C++

Question

Suppose the struct is supplied with two template arguments, one being typename T and the other one being size_t N. Now, that struct should store a static array of element type T and size N. In some cases, it might be fine to initialize the array with default values upon creation of an instance, which is what I think happens anyway if you have something like

template<typename T, size_t N>
struct Foo {
    T values[N];
    size_t size;
    
    explicit Foo(size_t _size) : size{ _size } {}
}

So, as said, I think the behaviour in this case is that values just automatically gets initialized with default values (calling the default constructor of T). But what if I want to pass some values for the array when constructing an object? The goal here is that I am able to pass a static array to the constructor and let that static array take the place of values. And ideally, there would be only two array creations in the whole procedure. But is that even possible? Consider the following example:

template<typename T, size_t N>
struct Foo {
    T values[N];
    size_t size;
    
    explicit Foo(T _values[N], size_t _size) : values{ _values }, size{ _size} {}
}

Now, apart from me not even knowing if the above would work as expected, I am still a bit unsure about when copies happen in C++. I'd imagine that in the worst case, there would be 4 arrays created when calling the constructor of Foo:

1. To call the constructor of Foo, you need to pass an array, so you need to create that beforehand.
2. The constructor parameter _values is pass-by-value, so a copy is happening here.
3. Before the constructor initializes any values, the static array is already initialized (?)
4. When assigning _values to values, another copy is happening (?)

Now as said I'm really not sure about the copying behaviours in C++. Of course, we can rule out one array creation by making the _values parameter pass-by-reference. But still, the static array values would be initialized before being overwritten by _values, or so I think.

My question, therefore, is: What is the best strategy here? How do I have to write the code so that I trigger the least amount of array creations?

Thanks!

Edit:

No, I cannot use std::vector or any other data structure from the stdlib. And even if I could, my question is still about the best strategy for raw arrays, and not how to switch out my approach in favour of some wrapper.

Answer 1

To avoid the copy and the pointer decay, _values can be passed by reference:

template<typename T, std::size_t N>
struct Foo {
    T values[N];
    std::size_t size;
    
    explicit Foo(T const(&_values)[N], std::size_t _size) : size{ _size}{
         std::copy(std::begin(_values), std::end(_values), std::begin(values));
    }
};

https://godbolt.org/z/dnb9zTooG

but better use std::array<T, N> values; member.

---

This answer created some controversy. To be clear, if the problem is the initialization of the nested array, you are better off without (any) constructor and use aggregate initialization. Which is very limiting if you want do do other things with the class. At the end you are reinventing std::array anyway.

Answer 2

You can do it like this:

#include <cstddef>
#include <type_traits>
#include <utility>
#include <algorithm>

using namespace std;

struct S
{
    S();
    S(int);
    S(S const&);
    S(S&&);
    ~S();
    S& operator=(S const&);
    S& operator=(S&&);
};


template<class F>
struct inplacer
{
    F f_;
    operator std::invoke_result_t<F&>() { return f_(); }
};

template<class F> inplacer(F) -> inplacer<F>;


template<size_t maxN, typename T>
struct myarray
{
    size_t      sz_{};
    T           data_[maxN];
    
    template<class... Ts>
    myarray(Ts&&... args) : sz_{sizeof...(Ts)}, data_{forward<Ts>(args)...} {}

    template<class E, size_t N>
    static myarray make(E const (&a)[N], size_t count = N)
    {
        return make_copy(a, count, make_index_sequence<maxN>());
    }

    template<class E, size_t N>
    static myarray make(E (&&a)[N], size_t count = N)
    {
        return make_move(a, count, make_index_sequence<maxN>());
    }

private:
    template<class E, size_t... Indices>
    static myarray make_copy(E const* p, size_t count, index_sequence<Indices...>)
    {
        auto r = myarray( inplacer{ [&]{ return Indices < count ? p[Indices] : T(); } }... );
        r.sz_ = min(count, maxN);
        return r;
    }

    template<class E, size_t... Indices>
    static myarray make_move(E* p, size_t count, index_sequence<Indices...>)
    {
        auto r = myarray( inplacer{ [&]{ return Indices < count ? move(p[Indices]) : T(); } }... );
        r.sz_ = min(count, maxN);
        return r;
    }
};


auto f()
{
    auto v = myarray<16, int>(1, 2);

    //myarray<100, int> v = {3, 4};

    //static int d[] = {1, 2, 3, 4};
    //auto v = myarray<12, int>::make(d, 3);

    //myarray<4, S> v = {S(1), 2};
    //myarray<4, S> v = {inplacer{ []{ return S(1); } }, 2};

    //static S d[] = {3, 4, 1};
    //auto v = myarray<4, S>::make(d, 2);
    //auto v = myarray<4, S>::make(move(d));

    return v;
}

I bet this can be improved in many ways, I am going to leave it up to you...

Notes:

• no matter how hard I tried -- I couldn't get GCC to default-initialize unused elements of array. I tried to populate them with result of trick<T>() call, but it didn't work... It complained about unused variable and insisted on filling the rest of array with zeroes.

  template<class T> T trick() { T r; return r; } 
  

• which means this class is quite inefficient, better approach would be to use raw storage and manually control it (maybe try putting array into an unrestricted union? be warned though -- compilers have bugs when it comes to handling unions)

• also keep in mind that compilers don't like too many function parameters -- related optimizations work nicely only for relatively small maxN values. Code generated for myarray<1000, int>::make(d, 3) looks horrendous and compilation time shoots into stratosphere...

• myarray ctor allows for aggregate-init-like initialization, it is pretty close but not entirely same. It doesn't permit in-place construction (simply because arguments need to be constructed before call is made) -- you can use inplacer to overcome this (see one of examples in f())