你可以创建constexpr函数：

template <std::size_t N, typename... Ts>
static constexpr bool first_are_integral()
{
    constexpr std::array<bool, sizeof...(Ts)> bools{std::is_integral_v<Ts>...};

    for (std::size_t i = 0; i != N; ++i) {
        if (!bools[i]) {
            return false;
        }
    }
    return true;
    // C++20
    // return std::all_of(std::begin(bools), std::begin(bools) + N, [](bool b){ return b; });
}

字符串
然后

template <class... Args,
          std::enable_if_t<first_are_integral<N, Args...>(), int> = 0
>
A(Args...){ /*...*/ }

型
Demo
或者，std::index_sequence是一种拥有索引和类型的方法（来自元组）

template <typename Seq, typename Tuple>
struct first_are_integral_impl;

template <std::size_t...Is, typename Tuple>
struct first_are_integral_impl<std::index_sequence<Is...>, Tuple>
{
    constexpr static bool value =
        (std::is_integral_v<std::tuple_element_t<Is, Tuple>> && ...);
};

template <std::size_t N, typename Tuple>
constexpr bool first_are_integral_v =
    first_are_integral_impl<std::make_index_sequence<N>, Tuple>::value;

型
Demo的

您可以创建一个辅助模板：

template <std::size_t N, typename... T>
inline constexpr bool conjunction_n_v = [] {
    std::size_t i = 0;
    return ((i++ >= N || T::value) && ...);
}();

// ...

static_assert( conjunction_n_v<1, std::is_integral<int>, std::is_integral<float>>);
static_assert(!conjunction_n_v<2, std::is_integral<int>, std::is_integral<float>>);

字符串

• 见live example at Compiler Explorer*。

这有点像std::conjunction，但不会短路模板示例化。

替代方案

如果示例化是贪婪的，那么我们也可以使用一组bool：

template <std::size_t N, bool... B>
inline constexpr bool first_n_true_v = [] {
    std::size_t i = 0;
    return ((i++ >= N || B) && ...);
}();

型

保持std::conjunction短循环示例化

为了提高编译速度，也只是出于必要，std::conjunction短路并且不示例化所有给定类型的事实是有用的。这可以使用经典的递归模板来实现：

template <std::size_t N, typename... T>
struct conjunction_n : std::false_type {};

template <std::size_t N, typename Head, typename... Tail>
struct conjunction_n<N, Head, Tail...>
  : std::conjunction<std::disjunction<std::bool_constant<N == 0>, Head>,
      conjunction_n<N - 1, Tail...>>
{};

template <std::size_t N, typename... T>
inline constexpr bool conjunction_n_v = conjunction_n<N, T...>::value;

型