Universal aggregate initialization by variadic templates - c++

Question

This is an interesting problem I'm thinking about a time ago.
Given a struct with an underlying aggregate:
#include <array>
template <typename T, size_t N>
struct A
{
constexpr A() = default;
template <typename ... Ts>
constexpr A(const T& value, const Ts& ... values); // magic
std::array<T, N> arr; // aggregate
};
How would you implement variadic template constructor A(const T& value, const Ts& ... values) to
accept both values of type T and another A<T, N>
properly initialize the underlying aggregate based on the values represented by the passed arguments
respect the capacity of the aggregate
support C++14 constexpr rules and do not introduce any runtime overhead
Satisfying the above requirements, it is possible to do the following:
int main()
{
A<int, 3> x(1, 2, 3);
A<int, 2> y(1, 2);
A<int, 6> a(x, 1, 2, 3);
A<int, 6> b(1, x, 2, 3);
A<int, 6> c(1, 2, x, 3);
A<int, 6> d(1, 2, 3, x);
A<int, 6> e(x, x);
A<int, 6> f(y, y, y);
return 0;
}

Answer 1

Here's one approach that works, but could almost certainly be improved on.
We have a constructor for A that takes a parameter pack, converts each element into a tuple, concatenates the tuples together to make for one large tuple, and then simply uses aggregate initialization from that big tuple. All of the following can be constexpr, I just omitted it for brevity.
First we do the conversion:
template <class... Us>
A(Us const&... us)
: A(std::tuple_cat(as_tuple(us)...))
{ }
With:
// single argument
template <class U>
auto as_tuple(U const& u) {
return std::forward_as_tuple(u);
}
// aggregate argument
template <size_t M>
auto as_tuple(A<T, M> const& a) {
return as_tuple(a, std::make_index_sequence<M>{});
}
template <size_t M, size_t... Is>
auto as_tuple(A<T, M> const& a, std::index_sequence<Is...> ) {
return std::forward_as_tuple(std::get<Is>(a.arr)...);
}
And then we just initialize from there:
template <class... Us, class = std::enable_if_t<(sizeof...(Us) <= N)>>
A(std::tuple<Us...> const& t)
: A(t, std::index_sequence_for<Us...>{})
{ }
template <class... Us, size_t... Is>
A(std::tuple<Us...> const& t, std::index_sequence<Is...> )
: arr{{std::get<Is>(t)...}}
{ }
Demo

Answer 2

The answer by #Barry is certainly correct and acceptable. But it requires some C++14 library additions (which you could probably also write yourself in C++11), and overall requires some good tuple- and meta-programming fu.
Let's view multiple arguments a "range of ranges", where a range is just a pointer and a size. Scalar arguments are just a size-1 range, and A<T, N> arguments are size-N ranges.
template<class T>
struct Range
{
T const* data_;
std::size_t size_;
constexpr T const* begin() const noexcept { return data_; }
constexpr T const* end() const noexcept { return data_ + size_; }
constexpr std::size_t size() const noexcept { return size_; }
};
template<class T>
constexpr Range<T> as_range(T const& t)
{
return { &t, 1 };
}
template<class T, std::size_t N>
struct A;
template<class T, std::size_t N>
constexpr Range<T> as_range(A<T, N> const& a)
{
return { a.arr, N };
}
You can then simply do a double loop over all elements of all ranges
template <typename T, size_t N>
struct A
{
T arr[N]; // aggregate
constexpr A() = default;
template <typename U, typename... Us>
constexpr A(U const u, Us const&... us)
:
arr{}
{
Range<T> rngs[1 + sizeof...(Us)] { as_range(u), as_range(us)... };
auto i = 0;
for (auto const& r : rngs)
for (auto const& elem : r)
arr[i++] = elem;
assert(i == N);
}
};
Live Example working at compile-time (requires GCC >= 6.0 or Clang >= 3.4)
template <class T, size_t N>
void print(A<T, N> const& a) {
for (T const& t : a.arr) {
std::cout << t << ' ';
}
std::cout << '\n';
}
int main()
{
constexpr A<int, 3> x(1, 2, 3);
constexpr A<int, 2> y(1, 2);
constexpr A<int, 6> a(x, 1, 2, 3);
constexpr A<int, 6> b(1, x, 2, 3);
constexpr A<int, 6> c(1, 2, x, 3);
constexpr A<int, 6> d(1, 2, 3, x);
constexpr A<int, 6> e(x, x);
constexpr A<int, 6> f(y, y, y);
print(a); // 1 2 3 1 2 3
print(b); // 1 1 2 3 2 3
print(c); // 1 2 1 2 3 3
print(d); // 1 2 3 1 2 3
print(e); // 1 2 3 1 2 3
print(f); // 1 2 1 2 1 2
}