C++ type_traits （tcy)

1.1.概述	
    type_traits提供编译期间计算、查询、判断、转换和选择的帮助类	
	
1.2.作用：	
	1）获取修改变量数据类型；获取函数返回类型；
	2）判断数据类型，修改类型属性
	3）重载相同参数不同的返回类型；
	4）根据条件选择不同的数据类型；
	5）编译器类型检查
 
1.3.定义：	
    template <class T, T v>	
    struct integral_constant {	
          static constexpr T value = v;	
          typedef T value_type;	
          typedef integral_constant<T,v> type;	
          constexpr operator T() { return v; }	
    };	
 	
1.4.说明：	
    编译器匹配重载函数通常匹配所有重载函数，如匹配一个失败接着匹配其他重载函数，	
    选择最精确一个去执行，整个过程不会报错；除法都不匹配则报错。	
        	
    std::enable_if 根据条件选择重载函数，只对满足条件的函数有效。	
    可作用于返回值、模板定义、类模板特化、参数类型限定	
        	
    std::conditional根据条件返回不同类型	

2.1.定义编译期常量方法：	
    1）定义静态变量:（C++11前）	
        template<typename Type>	
        struct CompileTimeContents{static const int value = 1;};	
      	
    2）定义枚举变量：（C++11前）	
        template<typename Type>	
        struct CompileTimeContents{enum {value = 1};};	
        	
    3）C++11中可通过std::integral_constant 模版类派生：	
        template<typename Type>	
        struct CompileTimeContents ：std::integral_constant<int, 1> {};	
        	
        CompileTimeContents<type_name>::value;//获取该常量	

2.2.判断类型:	
	
1）判断数据类型：	
	assert(is_const<const int>::value==true);         //判断const类型
	
	assert(is_array<int[3]>::value==true);	          //判断是否为数组类型
	assert(is_array<int[](int x,int y)->int{return x+y}>::value==true);
	
	int add(int a, int b) { return a + b; }
	assert(is_function<int(int,int)>::value == true); //判断是否为函数类型
	assert(is_function<decltype(add)>::value == true);//lambda表达式不是函数
	
	int x = 0; int& r_x = x;                          //判断是否为引用类型
	assert(is_reference<int&>::value == true);
	assert(is_reference<decltype(r_x)>::value == true);

2）判断类型间关系：	
	assert(is_same<int, int>::value==true);           //判断类型是否相同
	assert(is_same<int, unsigned int>::value==false);
	
	struct A {};struct B : A {};	
	
    assert(is_base_of<int,int>::value==false);	     //判断Base类型是否为Derivedl类型的基类
    assert(is_base_of<A,A>::value==true);	
    assert(is_base_of<A,B>::value==true);	
    assert(is_base_of<A,const A>::value==true);	
    assert(is_base_of<A&,B&>::value==false);	
    assert(is_base_of<B,A>::value==false);
	
	//is_convertible 判断前面模板参数类型能否转换为后面模板参数类型
    class A {};
    class B : public A {};
    class C {};
    class D { public: operator C() { return c; }  C c; };
    class E { public: template<class T> E(T&&) { } };
 
    assert(is_convertible<B*, A*>::value==true);
    assert(is_convertible<A*, B*>::value==false);
    assert(is_convertible<B*, C*>::value==false);
    assert(is_convertible<D, C>::value==true);
    assert(is_convertible<A, E>::value==true); //< B, C, D, etc

2.3.根据条件选择类型	
	//conditional在编译期根据条件选择两类型中的一个，类似常用条件表达式
	conditional<(true == true),int, char> ::type a;//等价int a;
	typedef std::conditional<true, int , char>::type A;

2.4.类型转换	
    //对参数属性修改：cv属性添加或移除、引用添加或移除、数组维度修改	
    typedef const volatile char cvchar;	
    std::remove_cv<cvchar>::type a;                       // char a	
    std::remove_cv<char* const>::type b;                  // char* b	
    std::remove_cv<const char*>::type c;                  // const char* c (no changes)	
	
    assert(is_const<decltype(a)>::value==false);          // not const	
    assert(is_volatile<decltype(a)>::value==false);       // not volatile	
	
	assert(is_same<const int, add_const<int>::type>::value==true);      //添加const
	assert(is_same<int, remove_const<const int>::type>::value==true);   //移除const
	
	assert(is_same<int&, add_lvalue_reference<int>::type>::value==true);//添加引用
	assert(is_same<int&&, add_rvalue_reference<int>::type>::value ==true);
	
	assert(is_same<int, int>::value==true);
	assert(is_same<int, int &>::value==false);
	assert(is_same<int, int &&>::value==false);
 
	assert(is_same<int, std::remove_reference<int>::type>==true);       //移除引用
	assert(is_same<int, std::remove_reference<int &>::type==true);
	assert(is_same<int, std::remove_reference<int &&>::type==true);
 
	typedef common_type<unsigned char, short, int>::type NumericType;   //取公共类型
	assert(is_same<int, NumericType>::value==true);

2.5.获取函数返回值类型	
 
	//获取函数返回值类型使用decltype：T必须有构造函数
	template<typename T, typename Arg>
	auto Func(T a, Arg arg)->decltype(f(arg)){  return f(arg);}
	
    //类型没有模板参数或类型无构造函数，不能通过decltype来获取类型，用declval	
	class A{A() = delete;public:int operator()(int i){return i;}};
	decltype(std::declval<A>()(std::declval<int>())) i = 4;//int i;
	
    //另一解决途径：std::result_of	<traits>
	std::result_of<A(int)>::type i = 4;                   //C++20删除
	std::invoke_result<A,int>::type i=4;                  //C++17

2.6.type_traits std::decay(朽化)
	用途：
		利用std::decay可以方便的获得函数指针
		
	说明：
	对于普通类型移除引用和cv符(const和volatile)，规则如下：	
		1）移除T类型的引用得到类型U，U为remove_reference < T > ::type	
		2）如is_array < U > ::value==true修改类型为 remove_reference< U >::type*	
		3）如is_function < U > ::value==true修改类型为add_pointer< U >::type	
		4）否则，修改类型为remove_cv< U >::type	
		
	实例：	
		typedef std::decay<int>::type Normal;        // int	
		typedef std::decay<int&>::type Ref;          // int	
		typedef std::decay<int&&>::type RefRef;      // int	
		typedef std::decay<const int&>::type const;  // int	
		typedef std::decay<int[2]>::type Array;      // int*	
		typedef std::decay<int(int)>::type FunPtr;   // int(*)(int) 函数指针	

2.7.std::enable_if根据条件禁用或启用某些类型	
用途：
	利用SFINAE(substitude failuer is not an error)特性，根据条件选择重载函数
	
说明：
	enable_if 根据限定条件选择重载函数，只对满足条件的函数有效。
	可作用于返回值、模板定义、类模板特化、参数类型限定

实例1.1：函数参数限定-T=int执行此函数，其他编译错误	
	#include <iostream>	
	#include <type_traits>	
	
	using namespace std;
 
	template <class T>	
	typename std::enable_if<std::is_integral<T>::value, bool>::type	
	is_odd(T i) { return bool(i % 2); }	

实例1.2：对模板参数限定-模板特化时模板参数只能是int类型	
	template < class T,	
	class = typename std::enable_if<std::is_integral<T>::value>::type>	
		bool is_even(T i) { return !bool(i % 2); }
	 
	// 通过编译期检查输入模板参数是否有效，来提前显示编译错误 
	int main() {	
		short int i = 1;    // code does not compile if type of i is not integral
		
		std::cout << std::boolalpha;
		std::cout << "i is odd: " << is_odd(i) << std::endl;
		std::cout << "i is even: " << is_even(i) << std::endl;
	}	

实例2.1：对函数返回值限定
	typename std::endable_if<std::is_arithmetic<T>::value, T>::type foo(T t)	
	{    return t;}	
		
	auto numberic = foo(1);    // 返回整数1	
	auto str = foo("test");    // 编译失败	

实例2.2：函数重载，通过enable_if和条件判断式，将入参分为两类(数字和非数字)		
	template<class T>	
	typename std::enable_if<std::is_arithmetic<T>::value, int>::type fool(T t)	
	{	
		cout<< t << endl;	
		return 0;	
	}	
		
	template<class T>	
	typename std::enable_if<!std::is_arithmetic<T>::value, int>::type fool(T& t) foo(T t)	
	{	
		cout << t << endl;	
		return 1;	
	}	

3.简表