【无标题】

当有偏特化版本时，编译器到底是如何进行推导的。

1、泛化版本为什么要用两个参数

判断是不是个类型，直接用特化判断不行了吗，比如

template<typename T>
struct IsWstring : std::false_type
{};

template<>
struct IsWstring<std::wstring> : std::true_type
{};

 原因呢，应该这个模板，不止用来判断单单类型这一项，而是有更复杂的逻辑：判断一个类型里是否定义有某个类型。所以，既需要定义一个类型，又需要一个额外的约束：此类型中定义了一个具体的类型。

template<bool _Test,
    class _Ty = double>
struct enable_if123;
 
template<class _Ty>
struct enable_if123<true, _Ty>
{	// type is _Ty for _Test
    using type = _Ty;
};
struct XXX
{
    static bool no_destroy()
    {
        return true;
    }
};
 
 
int main()
{
    
    XXX o1;
    enable_if123<true>::type t1 = o1; //故意赋值一个对象，看看打印出什么提示
}

struct NoInnerType
{
	int m_i;
};

struct HaveInnerType
{
	using type = int; //类型别名
	void myfunc() {}
};


//泛化版本
template <typename T, typename U = std::void_t<> >
struct HasTypeMem : std::false_type  //struct 默认是public ,class默认是private继承
{
};
//特化版本
template <typename T>
struct HasTypeMem<T, std::void_t<typename T::type> > : std::true_type
{
};


int main()
{
	std::cout << HasTypeMem<NoInnerType>::value << std::endl;  //0
	std::cout << HasTypeMem<HaveInnerType>::value << std::endl;  //1
	//std::add_rvalue_reference
    std::cout << "Hello World!\n";
}

template<typename T>
struct my_is_pair : std::false_type 
{
};
 
template<typename T, typename U>
struct my_is_pair<std::pair<T, U>> : std::true_type 
{
};
 
template<typename T>
void fun_pair(T a, std::enable_if_t<my_is_pair<T>::value>* = 0)
{
 
}
 
 
std::pair<double, double> pairdata;
fun_pair(pairdata);
————————————————

                            版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
                        
原文链接：https://blog.csdn.net/tumu_C/article/details/134600259