Arrays of Objects without standard constructor using Parameter Packs

Question

I want to fill an std::array of size N with objects without a standard constructor.

std::array<non_std_con,N> myArray;

(It's std::array<kissfft<float>, 64> in my case, to be specific)

This results in the error

error: use of deleted function ... standard constructor

Setup

You can fill the array using an intializer list:

std::array<non_std_con,N> myArray{non_std_con{init1,init2},non_std_con{init1,init2},...}

The initializer list needs N objects.

And you can build an array using parameter packs:

template <class... Params>
auto constexpr build_array(Params... params)
{
    std::array<non_std_con, sizeof...(params)> myArray= {params...};
    return myArray;
}

Question

Is there a way to use this the other way around and build a parameter pack out of a single argument:

std::array<non_std_con,N> buildArray(inti1,init2);

This would build an array of N non_std_con where every object is initialized with {init1,init2}

Thank you for your time

so, does a simple `auto my_array = std::array{{init1, init2}};` work? — Marcus Müller, Nov 20 '21 at 18:57
Unfortunatly no. This results in the error: could not convert ‘init1’ from ‘int’ to ‘non_std_con’ — SpiRelli, Nov 20 '21 at 19:02
I didnt write the object, I'm using a library. Only the constructor is defined in the source. So i guess the rest is defined by the compiler. [library](https://github.com/mborgerding/kissfft/blob/master/kissfft.hh) — SpiRelli, Nov 20 '21 at 19:23
could you simply actually use the type you're using in your code example? that'd take the guessing out of this? — Marcus Müller, Nov 20 '21 at 19:26
I wanted my example to be more generic. But my the code should look like this: ```std::array, 64> buildArray(2 << 14, false)``` — SpiRelli, Nov 20 '21 at 19:30
hm, that should be copy-constructable. I take it `std::array,64> my_array{kissfft(1<<15, false)}` doesn't work, either? — Marcus Müller, Nov 20 '21 at 19:41
No this results in 64 errors of >error: could not convert ‘()’ from ‘’ to ‘kissfft’ — SpiRelli, Nov 20 '21 at 20:00

Bernd · Accepted Answer · 2021-11-20T19:54:41.093

You could write:

#include <array>
#include <utility>
#include <iostream>

namespace detail
{
    template <
        typename T,
        std::size_t ... Is
    >
    constexpr std::array<T, sizeof...(Is)> create_array(T value, std::index_sequence<Is...>)
    {
        // cast Is to void to remove the warning: unused value
        return {{(static_cast<void>(Is), value)...}};
    }
}

template<
    typename T,
    int N,
    typename... CtorAgrs
>
constexpr std::array<T, N> buildArray(CtorAgrs... args)
{
    using Array = std::array<T, N>;
    return detail::create_array<T>(T{args...}, std::make_index_sequence<N>());
}


struct Foo{
    int a, b;
    constexpr Foo(int a, int b) : a(a), b(b)
    {
    }
};

int main() {
    constexpr auto array = buildArray<Foo, 10>(1, 2);

    for(const auto& f : array){
        std::cout << f.a;
        std::cout << "\n";
    }
}

or with C++-20 simply:

template<
    typename T,
    int N,
    typename... CtorAgrs
>
constexpr std::array<T, N> buildArray(CtorAgrs&&... args)
{
    auto doBuildArray = [&]<std::size_t ... Is>(std::index_sequence<Is...>)
    ->  std::array<T, N>
    {
        // cast Is to void to remove the warning: unused value
        return {{(static_cast<void>(Is), T{args...})...}};
    };

    return doBuildArray(std::make_index_sequence<N>());
}

Arrays of Objects without standard constructor using Parameter Packs

Setup

Question

1 Answers1