传递大小限制为可扩展大小集的 std::array 参数

Question

如何最好地实现接受两个 std::array<int, [size]> 参数的单个函数，每个参数的大小 受编译时已知的一组相应值的约束？

该函数只能接受大小从给定集合 (enum/macro/etc) 派生的数组
允许的数组集"sizes"将来可能会改变并且可能很大（有效地排除函数重载）
函数本身应该保持不变，无论允许数组的集合如何变化"sizes"

问题“Passing a std::array of unknown size to a function”虽然相似，但似乎并不直接适用。

以下在 C++14 中有效，但似乎不必要地冗余和混乱：

#include <type_traits>
#include <array>

// Add legal/allowable sizes for std::array<> "types" here
// Note: Not married to this; perhaps preprocessor instead?
enum class SizesForArrayX : size_t { Three = 3, Four, Forty = 40 };
enum class SizesForArrayY : size_t { Two = 2, Three, EleventyTwelve = 122 };

// Messy, compile-time, value getter for the above enum classes
template <typename S>
constexpr size_t GetSizeValue(const S size)
{ return static_cast<std::underlying_type_t<S>>(size); }

// An example of the function in question; is Template Argument Deduction
//  possible here?
// Note: only arrays of "legal"/"allowable" sizes should be passable
template <SizesForArrayX SX, SizesForArrayY SY>
void PickyArrayHandler(
    const std::array<int, GetSizeValue(SX)>& x,
    const std::array<int, GetSizeValue(SY)>& y)
{
    // Do whatever
    for (auto& i : x) i = 42;
    for (auto& i : y) while (i --> -41) i = i;
}

调用上面：

int main()
{
    // Declare & (value-)initialize some arrays
    std::array<int, GetSizeValue(SizesForArrayX::Forty)> x{};
    std::array<int, GetSizeValue(SizesForArrayY::Two>) y{};

    //PickyArrayHandler(x, y); // <- Doesn't work; C2672, C2783

    // This works & handles arrays of any "allowable" size but the required
    //  template params are repetitions of the array declarations; ick
    PickyArrayHandler<SizesForArrayX::Forty, SizesForArrayY::Two>(x, y);
}

...这是丑陋的、不优雅的、编译速度慢的，并且 要求声明的数组大小匹配显式 "size" 传递给 到 PickyArrayHandler 函数模板.

对于上面的具体示例：PickyArrayHandler模板是否有办法推导出传递的数组的大小？
一般来说：是否有更好的不同方法？

Answer 1

转了一圈，使这个简化的工作正常：也许它有帮助：

enum SizesForArrayX : size_t { Three = 3, Four, Forty = 40 };
enum SizesForArrayY : size_t { Two = 2, EleventyTwelve = 122 };

template <size_t TX, size_t TY>
void PickyArrayHandler(
    const std::array<int, TX>& x,
    const std::array<int, TY>& y)
{
    // Do whatever
}

int main()
{
    // Declare & (value-)initialize some arrays
    std::array<int, SizesForArrayX::Forty> x{};
    std::array<int, SizesForArrayY::Two> y{};

    PickyArrayHandler(x, y); 

    return 0;
}

Answer 2

不幸的是，您的枚举不是连续的，因此您不能简单地迭代枚举，您必须单独处理所有情况。由于大小在编译时已知，因此您可以 static_assert 它。

#include <array>

enum SizesForArrayX : size_t { Three = 3, Four, Forty = 40 };
enum SizesForArrayY : size_t { Two = 2, EleventyTwelve = 122 };

template <size_t TX, size_t TY>
void PickyArrayHandler(const std::array<int, TX> &x,
                       const std::array<int, TY> &y)
{
    static_assert(TX == Three || TX == Four || TX == Forty,
                  "Size mismatch for x");
    static_assert(TY == Two || TY == EleventyTwelve, "Size mismatch for y");
    // Do whatever
}

int main()
{
    // Declare & (value-)initialize some arrays
    std::array<int, SizesForArrayX::Forty> x{};
    std::array<int, SizesForArrayY::Two> y{};

    PickyArrayHandler(x, y);
    PickyArrayHandler(std::array<int, 4>{}, std::array<int, 2>{});
  //PickyArrayHandler(std::array<int, 1>{}, std::array<int, 5>{}); // BOOM!
}

Answer 3

就我个人而言，我只是将允许的大小手动输入到 PickyArrayHandler 内的 static_assert 中。如果这不是一个选项，因为这些大小将用于程序的其他部分并且您遵守 DRY 原则，那么我会使用预处理器。

#define FOREACH_ALLOWABLE_X(SEP_MACRO) \
    SEP_MACRO(3)    \
    SEP_MACRO(4)    \
    SEP_MACRO(40)   \

#define FOREACH_ALLOWABLE_Y(SEP_MACRO) \
    SEP_MACRO(2)    \
    SEP_MACRO(3)    \
    SEP_MACRO(122)  \


#define COMMA_SEP(NUM) NUM,
#define LOGIC_OR_SEP_X(NUM) N1 == NUM ||
#define LOGIC_OR_SEP_Y(NUM) N2 == NUM ||
#define END_LOGIC_OR false

// some arrays with your sizes incase you want to do runtime checking
namespace allowable_sizes
{
    size_t x[] {FOREACH_ALLOWABLE_X(COMMA_SEP)};
    size_t y[] {FOREACH_ALLOWABLE_Y(COMMA_SEP)};
}

template <size_t N1, size_t N2>
void PickyArrayHandler(const std::array<int, N1>& x, const std::array<int, N2>& y)
{
    static_assert(FOREACH_ALLOWABLE_X(LOGIC_OR_SEP_X) END_LOGIC_OR);
    static_assert(FOREACH_ALLOWABLE_Y(LOGIC_OR_SEP_Y) END_LOGIC_OR);

    // do whatever
}

#undef FOREACH_ALLOWABLE_X
#undef FOREACH_ALLOWABLE_Y
#undef COMMA_SEP
#undef LOGIC_OR_SEP_X
#undef LOGIC_OR_SEP_Y
#undef END_LOGIC_OR

一些 C++ 纯粹主义者可能会对它皱眉，但它完成了工作。

Answer 4

由于您似乎对如何定义有效大小并不挑剔，因此您可以使用类型特征

#include <array>

template <size_t N> struct valid_size1 { enum { value = false }; };
template <size_t N> struct valid_size2 { enum { value = false }; };

template <> struct valid_size1<3> { enum { value = true }; };
template <> struct valid_size1<4> { enum { value = true }; };
template <> struct valid_size1<40> { enum { value = true }; };

template <> struct valid_size2<2> { enum { value = true }; };
template <> struct valid_size2<122> { enum { value = true }; };

template <size_t TX, size_t TY>
void PickyArrayHandler(const std::array<int, TX> &x,
                       const std::array<int, TY> &y)
{
  static_assert(valid_size1<TX>::value, "Size 1 is invalid");
  static_assert(valid_size2<TY>::value, "Size 2 is invalid");
    // Do whatever
}

int main()
{
    // Declare & (value-)initialize some arrays
    std::array<int, 40> x{};
    std::array<int, 2> y{};

    PickyArrayHandler(x, y);
    PickyArrayHandler(std::array<int, 4>{}, std::array<int, 2>{});
    // PickyArrayHandler(std::array<int, 1>{}, std::array<int, 5>{}); // BOOM!
}

这是一个使用数组的解决方案：

#include <iostream>
#include <array>

constexpr size_t valid_1[] = { 3, 4, 40 };
constexpr size_t valid_2[] = { 2, 122 };

template <size_t V, size_t I=0> 
struct is_valid1 { static constexpr bool value = V==valid_1[I] || is_valid1<V,I+1>::value; };

template <size_t V, size_t I=0> 
struct is_valid2 { static constexpr bool value = V==valid_2[I] || is_valid2<V,I+1>::value; };

template <size_t V>
struct is_valid1<V, sizeof(valid_1)/sizeof(valid_1[0])>
{static constexpr bool value = false; };

template <size_t V>
struct is_valid2<V, sizeof(valid_2)/sizeof(valid_2[0])>
{static constexpr bool value = false; };

template <size_t TX, size_t TY>
void PickyArrayHandler(const std::array<int, TX> &x,
                       const std::array<int, TY> &y)
{
  static_assert(is_valid1<TX>::value, "Size 1 is invalid");
  static_assert(is_valid2<TY>::value, "Size 2 is invalid");
    // Do whatever
}

Answer 5

我认为解决此问题的最佳方法是编写自定义类型特征：

template <std::underlying_type_t<SizesForArrayX> SX>
struct is_size_x {
    static constexpr bool value = false;
};

template <>
struct is_size_x<static_cast<std::underlying_type_t<SizesForArrayX>>(SizesForArrayX::Forty)>{

    static constexpr bool value = true;
};

我将它们放在 enum class 声明的正下方，这样可以很容易地检查您是否得到了它们。比我聪明的人可能会想出一种方法甚至可以使用可变 templates 来做到这一点，所以你只需要一个专业化。

虽然乏味，但如果您有一小部分值，这应该足够快并且易于放入单元测试。这种方法的另一个好处是，如果您有多个函数需要这些特殊尺寸之一，则不必 copy/paste static_assert 左右。

有了类型特征，你的函数就变得微不足道了：

template <std::size_t SX, std::size_t SY>
void PickyArrayHandler(
    std::array<int, SX>& x,
    std::array<int, SY>& y)
{
    static_assert(is_size_x<SX>::value, "Invalid size SX");
    static_assert(is_size_y<SY>::value, "Invalid size SY");
    // Do whatever
    for (auto& i : x) i = 42;
    for (auto& i : y) while (i --> -41) i = i;
}

最后，您可以创建一个类型别名以避免首先创建无效的 array：

template <typename T, SizesForArrayX SIZE>
using XArray =
    std::array<T, static_cast<std::underlying_type_t<SizesForArrayX>>(SIZE)>;

template <typename T, SizesForArrayY SIZE>
using YArray =
    std::array<T, static_cast<std::underlying_type_t<SizesForArrayY>>(SIZE)>;

这将阻止您声明 array 如果它不是批准的尺寸：

XArray<int, SizesForArrayX::Forty> x{};
YArray<int, SizesForArrayY::Two> y{};

Answer 6

您可以使用类似 is_of_size 的模板来检查数组的大小，然后在其中一个大小不匹配时使用它来禁用模板，例如：

#include <array>
#include <type_traits>

// Forward template declaration without definition.
template <class T, T N, T... Sizes>
struct is_one_of;

// Specialization when there is a single value: Ends of the recursion,
// the size was not found, so we inherit from std::false_type.
template <class T, T N>
struct is_one_of<T, N>: public std::false_type {};

// Generic case definition: We inherit from std::integral_constant<bool, X>, where X
// is true if N == Size or if N is in Sizes... (via recursion).
template <class T, T N, T Size, T... Sizes>
struct is_one_of<T, N, Size, Sizes... >: 
    public std::integral_constant<
        bool, N == Size || is_one_of<T, N, Sizes... >::value> {};

// Alias variable template, for simpler usage.
template <class T, T N, T... Sizes>
constexpr bool is_one_of_v = is_one_of<T, N, Sizes... >::value;

template <std::size_t N1, std::size_t N2,
          std::enable_if_t<
                (is_one_of_v<std::size_t, N1, 3, 4, 40> 
                && is_one_of_v<std::size_t, N2, 2, 3, 122>), int> = 0>
void PickyArrayHandler(
    const std::array<int, N1>& x,
    const std::array<int, N2>& y)
{
}

那么你可以简单地：

PickyArrayHandler(std::array<int, 3>{}, std::array<int, 122>{}); // OK
PickyArrayHandler(std::array<int, 2>{}, std::array<int, 3>{}); // NOK

在 C++17 中，您可以（我认为）将 is_one_of 替换为：

template <auto N, auto... Sizes>
struct is_one_of;

...并自动推导出 std::size_t.

在 C++20 中，您可以使用概念来获得更清晰的错误消息 ;)

Answer 7

对无效大小使用 static_assert 不是一个好的解决方案，因为它不能很好地与 SFINAE 配合使用；即，像 std::is_invocable and the detection idiom 这样的 TMP 设施将 return 对实际上总是产生错误的调用的误报。更好的方法是使用 SFINAE 从重载集中删除无效大小，结果类似于以下内容：

template<std::size_t SX, std::size_t SY,
         typename = std::enable_if_t<IsValidArrayXSize<SX>{} && IsValidArrayYSize<SY>{}>>
void PickyArrayHandler(std::array<int, SX> const& x, std::array<int, SY> const& y) {
    // Do whatever
}

首先我们需要声明我们的有效尺寸；我在这里看不到更强类型的任何好处，因此对于整数的编译时列表，std::integer_sequence 工作得很好并且非常轻量级：

using SizesForArrayX = std::index_sequence<3, 4, 40>;
using SizesForArrayY = std::index_sequence<2, 3, 122>;

现在 IsValidArraySize 特征...直接的途径是利用 C++14 的宽松-constexpr 规则并执行简单的线性搜索：

#include <initializer_list>

namespace detail {
    template<std::size_t... VSs>
    constexpr bool idx_seq_contains(std::index_sequence<VSs...>, std::size_t const s) {
        for (auto const vs : {VSs...}) {
            if (vs == s) {
                return true;
            }
        }
        return false;
    }
} // namespace detail

template<std::size_t S>
using IsValidArrayXSize
  = std::integral_constant<bool, detail::idx_seq_contains(SizesForArrayX{}, S)>;
template<std::size_t S>
using IsValidArrayYSize
  = std::integral_constant<bool, detail::idx_seq_contains(SizesForArrayY{}, S)>;

Online Demo

然而，如果编译时间是一个问题，我怀疑以下会更好，如果可能不太清楚的话：

namespace detail {
    template<bool... Bs>
    using bool_sequence = std::integer_sequence<bool, Bs...>;

    template<typename, std::size_t>
    struct idx_seq_contains;

    template<std::size_t... VSs, std::size_t S>
    struct idx_seq_contains<std::index_sequence<VSs...>, S>
      : std::integral_constant<bool, !std::is_same<bool_sequence<(VSs == S)...>,
                                                   bool_sequence<(VSs, false)...>>{}>
    { };
} // namespace detail

template<std::size_t S>
using IsValidArrayXSize = detail::idx_seq_contains<SizesForArrayX, S>;
template<std::size_t S>
using IsValidArrayYSize = detail::idx_seq_contains<SizesForArrayY, S>;

Online Demo

无论选择哪种实施方式，以这种方式使用 SFINAE 都会产生非常好的错误消息——例如对于 PickyArrayHandler(std::array<int, 5>{}, std::array<int, 3>{});，当前的 Clang 7.0 ToT 会产生以下结果，告诉您哪个数组的大小无效：

error: no matching function for call to 'PickyArrayHandler'
    PickyArrayHandler(std::array<int, 5>{}, std::array<int, 3>{});
    ^~~~~~~~~~~~~~~~~

note: candidate template ignored: requirement 'IsValidArrayXSize<5UL>{}' was not satisfied [with SX = 5, SY = 3]
    void PickyArrayHandler(std::array<int, SX> const& x, std::array<int, SY> const& y) {
         ^

传递大小限制为可扩展大小集的 std::array 参数

Passing std::array argument with size restricted to expandable set of sizes

c++

templates

stdarray

c++14