c++ - 尝试根据类中 typedef 的存在来专门化模板函数

Question

我希望能够根据结构中存在的类型来自定义结构的处理(无需为每个自定义结构编写任何额外代码)，例如:

struct Normal_t
{
};

struct Custom_t
{
    using my_custom_type = bool;
};

看起来我应该可以做这样的事情，但它不起作用:

template <class T, typename Enabler = void>
struct has_custom_type
{
    bool operator()() { return false; }
};

template <class T>
struct has_custom_type<T, typename T::my_custom_type>
{
    bool operator()() { return true; }
};

bool b_normal = has_custom_type<Normal_t>()();  // returns false
bool b_custom = has_custom_type<Custom_t>()();  // returns false, INCORRECT? should return true?

我不明白的是，标准库使用了一些类似但看起来更复杂的类型特征。例如，这有效:

template<bool test, class T = void>
struct my_enable_if
{
};

template<class T>
struct my_enable_if<true, T>
{
    using type = T;
};

template <class T, class Enabler = void>
struct foo
{
    bool operator()() { return false; }
};

template <class T>
struct foo<T, typename my_enable_if<std::is_integral<T>::value>::type>
{
    bool operator()() { return true; }
};

bool foo_float = foo<float>()();    // returns false
bool foo_int = foo<int>()();        // returns true

在这两种情况下，特化都是基于结构中类型的存在而发生的，在一种情况下是 typename T::my_custom_type在另一个typename my_enable_if<std::is_integral<T>::value>::type .为什么第二个版本有效而​​第一个版本无效？

我使用 ... 参数包语法想出了这个解决方法，但我真的很想知道是否有一种方法可以在不使用参数包语法的情况下使用普通模板特化来做到这一点，如果没有，为什么.

template<typename ...Args>                              
bool has_custom_type_2(Args&& ...args)      { return false; }   

template<class T, std::size_t = sizeof(T::my_custom_type)>  
bool has_custom_type_2(T&)                  { return true; }

template<class T, std::size_t = sizeof(T::my_custom_type)>  
bool has_custom_type_2(T&&)                 { return true; }    /* Need this T&& version to handle has_custom_type_2(SomeClass()) where the parameter is an rvalue */

bool b2_normal = has_custom_type_2(Normal_t()); // returns false
bool b2_custom = has_custom_type_2(Custom_t()); // returns true - CORRECT!

Answer 1

问题是您为 Enabler 指定了默认的 void 类型，但是 T::my_custom_type 不是 void。要么使用 bool 作为默认类型，要么使用始终返回 void 的 std::void_t:

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

template <class T>
struct has_custom_type<T, std::void_t<typename T::my_custom_type>> : std::true_type { };

This answer解释为什么类型应该匹配。