c – std :: is_base_of的可能实现的说明

1. template <typename Base> std::true_type is_base_of_test_func( Base* );

当参数是Base或从Base派生时,此重载具有最高优先级

2. template <typename Base> std::false_type is_base_of_test_func( void* );

此重载将匹配任何类型,具有最低优先级

3. template <typename Base,typename Derived>
using pre_is_base_of = decltype( is_base_of_test_func<Base>( std::declval<Derived*>() ) );

pre_is_base_of将成为通过调用is_base_of_test_func并返回Derived指针返回的类型.如果Derived派生自Base,它将返回std :: true_type,否则将选择void *重载并返回std :: false_type.现在我们已将函数调用结果转换为类型.

4. template <typename Base,typename = void>
struct pre_is_base_of2 : public std::true_type {};

一般情况下,这将是一个true_type.由于第3个模板参数是默认的,因此这将是未创建其他特化时定义的类的版本.

5. template<typename ...> using void_t = void;

这是一种更简单的enable_if方法. void_t< X>如果X是合法类型,则只会是一种类型.

6. template <typename Base,typename Derived>
struct pre_is_base_of2<Base,Derived>{};

如果void_t是合法类型(即pre_is_base_of< Base>(Derived *)是一个有效的表达式,这将是pre_is_base_of2的特化,它将评估为调用上述测试函数的decltype.仅当pre_is_base_of&lt时才会选择它; Base,Derived>是有效类型(即存在对测试函数的调用)

7. template <typename Base,typename Derived>
struct is_base_of : public std::conditional_t<std::is_class<Base>::value && std::is_class<Derived>::value,
pre_is_base_of2<Base,
std::false_type>
{
};

基本上这是说：

IF Base and Value are classes AND void_t<decltype(is_base_of_test_func<Base>(Derived*))> is a type
THEN
    select the type of pre_is_base_of2<Base,void_t<...is the expression legal?...>>
ELSE
    select false_type

更新：

希望这个小小的演示程序能够提供一些清晰度：

#include <type_traits>
#include <iostream>

template<class...> using void_t = void;

// this expands in any case where no second type is provided
template<class T,typename = void> struct does_he_take_sugar : std::false_type {};

// the specialisation can only be valid when void_t<expr> evaluates to a type.
// i.e. when T has a member function called take_sugar
template<class T> struct does_he_take_sugar<T,void_t<decltype(std::declval<T>().take_sugar())>> : std::true_type {};


struct X {
    int take_sugar();
};

struct Y {
    int does_not();
};

int main()
{

    // X::take_sugar is a function therefore void_t<decltype(...X)> will evaluate to void
    std::cout << does_he_take_sugar<X>::value << std::endl;

    // Y::take_sugar is not a function therefore void_t<decltype(...Y)> will not evaluate at all
    std::cout << does_he_take_sugar<Y>::value << std::endl;

    // int::take_sugar is not even valid c++ void_t<decltype(...int)> will not evaluate at all
    std::cout << does_he_take_sugar<int>::value << std::endl;
}