Question

我正在使用参数包，并且出现了一些我无法解释的行为（以我的理解，这应该是有效的）。

我有一个采用一种类型的模板化结构，并使用两个参数包（http://coliru.stacked-crooked.com/a/0cb6c6fef7b09e6f）进行了专业化处理：

    #include <type_traits>
    template<class, int> struct dummy{};
    template<class...> struct multiple{};

    template<class T, class = std::true_type>
    struct exactly_one_not_0 : std::false_type {};

    template<class...LTs, class...RTs, class T, int V>
    struct exactly_one_not_0
    <
        multiple
        <
            dummy<LTs, 0>...,
            dummy<T, V>,
            dummy<RTs, 0>...
        >,
        std::bool_constant<V>
    > : std::true_type
    {};

    template<class T>
    constexpr bool exactly_one_not_0_v = exactly_one_not_0<T>::value;

    using d0 = dummy<int,0>;
    using d1 = dummy<int,1>;

    static_assert(exactly_one_not_0_v<multiple<d1>>);
    static_assert(exactly_one_not_0_v<multiple<d1,d0>>);
    static_assert(exactly_one_not_0_v<multiple<d0,d1>>);
    static_assert(exactly_one_not_0_v<multiple<d0,d1,d0>>);

    static_assert(!exactly_one_not_0_v<multiple<>>);
    static_assert(!exactly_one_not_0_v<multiple<d0>>);
    static_assert(!exactly_one_not_0_v<multiple<d0,d0>>);
    static_assert(!exactly_one_not_0_v<multiple<d1,d1>>);
    static_assert(!exactly_one_not_0_v<multiple<d0,d1,d1>>);
    static_assert(!exactly_one_not_0_v<multiple<d1,d0,d1>>);
    static_assert(!exactly_one_not_0_v<multiple<d1,d1,d0>>);

前四个断言失败。为什么？专业化应该能够抓住这些情况。

相比之下，以下代码可以正常工作（http://coliru.stacked-crooked.com/a/871ee1cc28f5ddc9）：

    #include <iostream>
    template<class T>
    struct multi_pack
    {
          static void f() {std::cout << "base case\n";}
    };

    template<class...Ts1, class...Ts2>
    struct multi_pack<std::pair<std::tuple<Ts1...>, std::tuple<Ts2...>>>
    {
        using T = std::pair<std::tuple<Ts1...>, std::tuple<Ts2...>>;
        static void f() {std::cout << "special case\n";}
    };

您知道第一个示例为何失败而第二个示例可行吗？

Answer 1

在第二种情况下，您要求编译器匹配单独类型中的包（有一对Ts1和Ts2的元组）。绝对是明确的。

在您的第一个示例中，两个包都在同一参数包中使用，并用第三种类型分隔。我理解为什么您希望它能起作用，但是显然编译器（gcc和clang）都拒绝完全匹配带前缀的包。

在您的特定情况下，实际上在某些情况下是模棱两可的：由于V是参数，因此它也可能为0，从而使其与d0的序列匹配是模棱两可的。无论如何，我尝试过即使使用常数1也不能解决问题。您必须自己删除前缀。

#include <type_traits>
template<class, int> struct dummy{};
template<class...> struct multiple{};

template<class T, class = void> // <-- was this supposed to be an enabler?
struct exactly_one_not_0 : std::false_type {};

template<class Ts, class...RTs, int V>
struct exactly_one_not_0
<
    multiple
    <
        dummy<Ts, V>,
        dummy<RTs, 0>...
    >,
    std::enable_if_t<V!=0>
> : std::bool_constant<V>
{};

template<class LT, class...RDummies>
struct exactly_one_not_0
<
    multiple
    <
        dummy<LT, 0>,
        RDummies...
    >
> : exactly_one_not_0<multiple<RDummies...>>
{};

template<class T>
constexpr bool exactly_one_not_0_v = exactly_one_not_0<T>::value;

using d0 = dummy<int,0>;
using d1 = dummy<int,1>;

static_assert(exactly_one_not_0_v<multiple<d1>>);
static_assert(exactly_one_not_0_v<multiple<d1,d0>>);
static_assert(exactly_one_not_0_v<multiple<d0,d1>>);
static_assert(exactly_one_not_0_v<multiple<d0,d1,d0>>);

static_assert(!exactly_one_not_0_v<multiple<>>);
static_assert(!exactly_one_not_0_v<multiple<d0>>);
static_assert(!exactly_one_not_0_v<multiple<d0,d0>>);
static_assert(!exactly_one_not_0_v<multiple<d1,d1>>);
static_assert(!exactly_one_not_0_v<multiple<d0,d1,d1>>);
static_assert(!exactly_one_not_0_v<multiple<d1,d0,d1>>);
static_assert(!exactly_one_not_0_v<multiple<d1,d1,d0>>);

int main()
{
    return 0;
}

为了不实例化多个multiple，您可能还希望将其剥离掉

template<class T>
struct exactly_one_not_0 : std::false_type {};

template<class Enable, class... Ts> // <-- was this supposed to be an enabler?
struct exactly_one_not_0_impl : std::false_type {};

template<class... Ts>
struct exactly_one_not_0<multiple<Ts...>>
    : exactly_one_not_0_impl<void, Ts...>
{};

template<class Ts, class...RTs, int V>
struct exactly_one_not_0_impl
<
    std::enable_if_t<V!=0>,
    dummy<Ts, V>,
    dummy<RTs, 0>...
> : std::bool_constant<V>
{};

template<class LT, class...RDummies>
struct exactly_one_not_0_impl
<
    void,
    dummy<LT, 0>,
    RDummies...
> : exactly_one_not_0_impl<void, RDummies...>
{};

专业化的C ++多个模板参数包

1 个答案: