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

Question

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

• 该函数必须只接受具有从给定集合（enum / macro / etc）
派生的大小的数组
• 允许的数组＆＃34;尺寸＆＃34;可能会在未来发生变化并且可能很大（有效地排除功能超载）
• 无论对允许数组＆＃34;尺寸＆＃34;
的更改如何，函数本身都应保持固定

问题＆＃34; Passing a std::array of unknown size to a function＆＃34;虽然相似，但似乎没有直接适用。

以下适用于C ++ 14，但似乎是不必要的冗余＆amp;凌乱：

#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);
}

......丑陋，不优雅，编译速度慢，要求声明的数组大小与显式＆＃34;大小相匹配＆＃34;传递到PickyArrayHandler功能模板。

1. 对于上面的具体示例： PickyArrayHandler模板是否有办法推断出传递数组的大小？

2. 一般来说：有不同的，更好的方法吗？

Answer 1

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

#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 2

勉强扭转了一下，让这个减少了一个工作：也许它有所帮助：

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 3

不幸的是，你的枚举不是连续的，所以你不能简单地遍历枚举，你必须单独处理所有情况。由于这些大小在编译时是已知的，因此您可以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 4

就个人而言，我只需手动将允许的尺寸输入static_assert PickyArrayHandler内。如果这不是一个选项，因为尺寸将用于你的程序的其他部分，并且你正在遵守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 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声明下，这样就可以很容易地检查出来了。有人比我更聪明可能找到一种方法甚至可以用变量template做到这一点所以你只需要一个专业化。

虽然乏味，但如果你有一小部分值，这应该足够快，并且很容易进行单元测试。这种方法的另一个好处是，如果你有多个需要其中一种特殊尺寸的功能，你就不必复制/粘贴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不是批准的尺寸，则会阻止您声明{<1}}：

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和the detection idiom等TMP设施将为实际上总是产生错误的呼叫返回误报。更好的方法是使用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) {
         ^