concatenation of multiple std::array objects using variadic templates

Question

I need a function fulfilling the following functionality:

template<typename T, std::size_t SIZE_L, std::size_t ...SIZE_R>
std::array<T, SIZE_L> concat(const std::array<T, SIZE_R...>&);

This is supposed to concatenate all passed arrays on the RHS into a single array. The sum of SIZE_R should be identical to SIZE_L -- and if possible one should not need to specify SIZE_L by hand.

The element type of this array will be always double.

But you can do: std::array<NonDefaultConstructible, 2> arr{{ NonDefaultConstructible(42), NonDefaultConstructible(51) }};... — Jarod42
– Jarod42, Commented Feb 22, 2021 at 13:50

Jarod42 · Accepted Answer · 2021-02-22 13:56:00Z

4

With default constructible T, you might do (C++17):

template<typename T, std::size_t ...Ns>
std::array<T, (... + Ns)> concat(const std::array<T, Ns>&... arrs)
{
    std::array<T, (... + Ns)> res;
    std::size_t offset = 0;
    
    ((std::copy(arrs.begin(), arrs.end(), res.begin() + offset),
      offset += arrs.size()),
     ...);
    return res;
}

Demo

answered Feb 22, 2021 at 13:56

Jarod42

227k15 gold badges214 silver badges349 bronze badges

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

2 Comments

Jarod42 Over a year ago

@FrankPuck: Concatenation would require some copies... (My version does extra default construction though).

Jarod42 Over a year ago

range-v3 has a concat view, but then, result would no longer be contiguous.

aschepler · Accepted Answer · 2021-02-22 14:37:11Z

3

If needed, here's a version that can deal with a type which can't be default-constructed (try it online):

#include <array>
#include <type_traits>
#include <utility>
#include <tuple>

namespace array_concat_helper {

template <std::size_t Idx, typename SizeSeq, typename Enable=void>
struct indices
{
    static constexpr std::size_t tuple_index = 0;
    static constexpr std::size_t elem_index = Idx;
};

template <std::size_t Idx, std::size_t FirstN, std::size_t ...Ns>
struct indices<Idx, std::index_sequence<FirstN, Ns...>,
    std::enable_if_t<(Idx >= FirstN)>>
{
    static constexpr std::size_t tuple_index =
    1 + indices<Idx-FirstN, std::index_sequence<Ns...>>::tuple_index;
    static constexpr std::size_t elem_index =
    indices<Idx-FirstN, std::index_sequence<Ns...>>::elem_index;
};

template <typename T, std::size_t ...Ns, std::size_t ...Is>
std::array<T, (... + Ns)> concat(
    std::index_sequence<Is...>,
    const std::array<T, Ns>&... arrs)
{
    auto arr_tuple = std::tie(arrs...);
    return {{
        std::get<indices<Is, std::index_sequence<Ns...>>::tuple_index>
        (arr_tuple)
        [indices<Is, std::index_sequence<Ns...>>::elem_index]...
    }};
}

} // end namespace array_concat_helper

template<typename T, std::size_t ...Ns>
std::array<T, (... + Ns)> concat(const std::array<T, Ns>&... arrs)
{
    return array_concat_helper::concat(
        std::make_index_sequence<(... + Ns)>{}, arrs...);
}

answered Feb 22, 2021 at 14:37

aschepler

72.5k11 gold badges113 silver badges173 bronze badges

3 Comments

Surt Over a year ago

Nice, can it make coffee and use movable sources too?

aschepler Over a year ago

@Surt Not this version. But hmm, if we took the arrays as forwarding references and just used typename C::value_type and std::tuple_size, then we could mix and match lvalue and rvalue arrays with perfect forwarding...

Jarod42 Over a year ago

Sad of the complexity induced by handling no default constructible types :-/

Collectives™ on Stack Overflow

concatenation of multiple std::array objects using variadic templates

2 Answers 2

2 Comments

3 Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

2 Comments

3 Comments

Your Answer

Sign up or log in

Post as a guest

Related