c++ - 在编译时将两个或多个不同大小的数组合并为一个数组

Question

我无法找到关于如何在现代 C++ 的编译时组合两个或多个数组的答案。

#include <array>
#include <cstdint>

const std::array<std::uint8_t, 1> one_elem = {1};
const std::array<std::uint8_t, 2> two_elem = {2, 3};
const std::array<std::uint8_t, 3> all = {one_elem, two_elem}; 
// expected: all == {1, 2, 3}

我会很高兴任何有点容易阅读的东西，例如

std::uint8_t one_elem[] = {1};
std::uint8_t two_elem[] = {2, 3};
std::uint8_t all[] = {one_elem, two_elem}; // cannot be that hard

有办法吗？我该怎么做才能解决这个问题？

Answer 1

如果你使用的是 C++17，你可以这样做:

template <typename T, std::size_t N1, std::size_t N2>
constexpr std::array<T, N1 + N2> concat(std::array<T, N1> lhs, std::array<T, N2> rhs)
{
    std::array<T, N1 + N2> result{};
    std::size_t index = 0;

    for (auto& el : lhs) {
        result[index] = std::move(el);
        ++index;
    }
    for (auto& el : rhs) {
        result[index] = std::move(el);
        ++index;
    }

    return result;
}

constexpr std::array<std::uint8_t, 1> one_elem = {1};
constexpr std::array<std::uint8_t, 2> two_elem = {2, 3};
constexpr std::array<std::uint8_t, 3> all = concat(one_elem, two_elem);

它在 C++14 中不起作用，因为 std::array 在 C++17 之前不是 constexpr 友好的。但是，如果您不关心最终结果是 constexpr，您可以简单地将每个变量标记为 const，这样就可以了:

const std::array<std::uint8_t, 1> one_elem = {1};
const std::array<std::uint8_t, 2> two_elem = {2, 3};
const std::array<std::uint8_t, 3> all = concat(one_elem, two_elem);

编译器几乎肯定会优化 concat。

如果您需要 C++14 解决方案，我们必须通过 std::array 的构造函数来创建它，所以它不是那么好:

#include <array>
#include <cstdint>
#include <cstddef>
#include <type_traits>

// We need to have two parameter packs in order to
// unpack both arrays. The easiest way I could think of for
// doing so is by using a parameter pack on a template class
template <std::size_t... I1s>
struct ConcatHelper
{
    template <typename T, std::size_t... I2s>
    static constexpr std::array<T, sizeof...(I1s) + sizeof...(I2s)>
    concat(std::array<T, sizeof...(I1s)> const& lhs,
           std::array<T, sizeof...(I2s)> const& rhs,
           std::index_sequence<I2s...>)
    {
        return { lhs[I1s]... , rhs[I2s]... };
    }
};

// Makes it easier to get the correct ConcatHelper if we know a
// std::index_sequence. There is no implementation for this function,
// since we are only getting its type via decltype()
template <std::size_t... I1s>
ConcatHelper<I1s...> get_helper_type(std::index_sequence<I1s...>);

template <typename T, std::size_t N1, std::size_t N2>
constexpr std::array<T, N1 + N2> concat(std::array<T, N1> const& lhs, std::array<T, N2> const& rhs)
{
    return decltype(get_helper_type(std::make_index_sequence<N1>{}))::concat(lhs, rhs, std::make_index_sequence<N2>{});
}

constexpr std::array<std::uint8_t, 1> one_elem = {1};
constexpr std::array<std::uint8_t, 2> two_elem = {2, 3};
constexpr std::array<std::uint8_t, 3> all = concat(one_elem, two_elem);