模板模板类谓词不适用于部分专业化

Question

我有许多EnableIf 特征，基本上检查输入类型是否满足接口。我试图创建一个通用的 Resolve 特征，可用于将它们转换为布尔特征。

类似这样的东西 - https://wandbox.org/permlink/ydEMyErOoaOa60Jx

template <
  template <typename...> class Predicate,
  typename T,
  typename = std::void_t<>>
struct Resolve : std::false_type {};
template <template <typename...> class Predicate, typename T>
struct Resolve<Predicate, T, Predicate<T>> : std::true_type {};

现在如果你有这样的EnableIf trait

template <typename T>
using EnableIfHasFoo = std::void_t<decltype(std::declval<T>().foo())>;

您可以非常快速地创建一个布尔版本

template <typename T>
struct HasFoo : Resolve<EnableIfHasFoo, T> {};

或者类似的变量模板。

但由于某种原因，部分专业化没有按预期工作。解决无法按预期工作。在此处查看输出 - https://wandbox.org/permlink/ydEMyErOoaOa60Jx。 “手动”实现的相同功能 - https://wandbox.org/permlink/fmcFT3kLSqyiBprm

我正在求助于自己手动定义类型。是否有我遗漏的部分特化和模板模板参数的细节？

Answer 1

我找不到您的示例不起作用的确切原因。如果您想深入了解std::void_t 的详细信息，请查看interesting explanation

即使我无法深入解释它，我也想添加另一种可靠的语法，用于detection idiom。

template<
    template <typename...> class Predicate,
    typename T,
    typename = void>
struct Resolve : std::false_type {};

template <template <typename...> class Predicate, typename T>
struct Resolve<Predicate, T, std::void_t<Predicate<T>>> : std::true_type {};

template <typename T>
using EnableIfHasFoo = decltype(std::declval<T>().foo());

live on compiler explorer

Answer 2

您的方法失败的原因是第三个模板参数中的Predicate<T>> 不是非推断上下文。这会导致推导直接失败（请参阅[temp.alias]/2），而不是像在非推导上下文中那样使用从其他地方推导的模板参数。

您可以将 Predicate<T>> 包装到非推断上下文中以使其工作：

template<class T>
struct identity {
    using type = T;
};

template <template <typename...> class Predicate, typename T>
struct Resolve<Predicate, T, typename identity<Predicate<T>>::type> : std::true_type {};

Live Demo

因为在非推导上下文中，Predicate<T> 部分不会进行推导，而是使用从其他地方获得的Predicate 和T。

至于为什么通常的检测成语（见Guillaume Racicot's answer）会起作用，是因为std::void_t作为模板别名，在演绎阶段会被void替换（见[temp.alias]/2），因此没有会扣分。

这里有一些例子可以更清楚地说明：

template<class T>
using always_int = int;

template<template<class> class TT>
struct deductor {};

template<template<class> class TT, class T>
void foo(T, deductor<TT>) {}

template<template<class> class TT, class T>
void bar(T, deductor<TT>, TT<T>) {}

template<class T>
void baz(T, always_int<T>) {}

int main() {
    // ok, both T and TT are deduced
    foo(0, deductor<always_int>{});

    // ERROR, TT<T> is NOT a non-deduced context, deduction failure
    bar(0, deductor<always_int>{}, 0);

    // ok, T is deduced, always_int<T> is replaced by int so no deduction
    baz(0, 0);
}