!!! C++11/14 Boost探秘--类型特征萃取
为了方便查看结果，后面测试全部返回true。
概述
type_traits库提供一组特征类，可以在编译器确定类型或者说是元数据是否拥有某特征，是否支持原生数组，是否是证书，是否重载某运算符，检查是否同一类型，还有添加或移除const，volatitle等
元数据类型
简单数据类型检查
is_integral : 检查T是否为bool，char，int等整形
is_floating_point : 检查T是否为浮点型
is_void : 检查T是否为void类新型
std:: cout << (std::is_integral<const char>::value) << "\n";
std::cout << (!std::is_integral<void*>::value) << "\n";
其他类型检查
- is_array
- is_class
- is_enum
- is_union
- is_pointer
- is_function
- is_lvalue_reference
- is_rvalue_reference
std::cout << (std::is_array<int[]>::value) << "\n";
std::cout << (std::is_class<std::string>::value) << "\n";
std::cout << (std::is_class<class Demo>::value) << "\n";
std::cout << (std::is_pointer<int*>::value) << "\n";
std::cout << (std::is_function<void(int)>::value) << "\n";
std::cout << (std::is_lvalue_reference<float&>::value) << "\n";
std::cout << (std::is_rvalue_reference<float&&>::value) << "\n";
成员指针检查
- is_member_opject_pointer : 成员变量指针
- is_menber_function_pointer : 成员函数指针
class Demo
{
int x;
double y;
void z() {};
std::function<void()> f = std::bind(&Demo::z,this);
};
std::cout << (std::is_member_object_pointer<int Demo::*>::value) << "\n";
std::cout << (std::is_member_object_pointer < std::function<void()> Demo::*>::value) << "\n";
std::cout << (std::is_member_function_pointer<void(Demo::*)()>::value) << "\n";
复合类型检查
- is_reference : 左右引用
- is_arithmetic : 算术类型（is_integral||is_float_pointer）
- is_fundamental : 基本类型(is_arithmetic || is_void)
- is_compound : 复合类型(!is_fundamental),std::string是复合类型
- is_member_pointer : 成员函数或成员变量
- is_scalar : 标量类型，算数类型，枚举，指针，成员指针
- is_object 实体对象类型，引用，void和函数之外
元数据属性
基本修饰词
- is_const
- is_volatile
- is_signed
- is_unsigned
数组属性
- rank : 如果是数组，返回维度，否则返回0
- extent : 如果是数组，返回第N维度的值，否则返回0
std::cout << (std::rank<int[2][3]>::value == 2) << "\n";
std::cout << (std::extent<int[2][3], 1>::value == 3) << "\n";
类相关属性
- is_pod :
是否为POD类型，is_fundamental::value==true成立的都是POD类型，复合类型的POD没有构造函数，虚构函数，虚函数，内存是连续的 - is_empty : 空类
- is_abstract : 抽象类（纯虚函数）
- is_polymorphic : 多态类（虚函数）
- is_final : final类
操作符重载属性
- has_greater : 重载operator>
- has_less
- has_equal_to
- has_plus : operator+
- has_minus
- has_pre_increment : operator++
元数据关系检查
- is_same ： 是否相同
- is_convertible : 是否能隐式转换
- is_base_of : B是D基类或者相同
- is_virtual_base_of : B是D虚基类，非c++11/14标准
元数据运算
添加和删除各种修饰符，输入一个类型，输出一个新的类型type，可以随意处理c++类型
元数据“加法”
- add_const : 返回T const
- add_volatile : 返回T volatile
- add_cv : 返回T const volatile
- add_pointer : 返回T*
- add_lvalue_reference : 对象或者函数类型返回左值引用，通常是T&，否则是T
- add_lvalue_reference : 对象和函数返回右值引用，通常T&&，否则T
typedef std::add_const<int>::type md1;
std::cout << (std::is_same<md1, int const>::value) << "\n";
typedef std::add_volatile<int const>::type md2;
std::cout << (std::is_same<md2, int const volatile>::value) << "\n";
typedef std::add_pointer<int>::type md3;
std::cout << (std::is_same<md3, int *>::value) << "\n";
typedef std::add_lvalue_reference<md3>::type md4;
std::cout << (std::is_same<md4, int *&>::value) << "\n";
typedef std::add_rvalue_reference<void>::type md5;
std::cout << (std::is_void<md5>::value) << "\n";
元数据“删除”
- remove_const
- remove_volatile
- remove_cv
- remove_pointer
- remove_reference
typedef int const **& rmd1;
typedef std::remove_pointer<rmd1>::type rmd2;
std::cout << (std::is_same<rmd1, rmd2>::value) << "\n"; //该变量是双指针引用，需要先移除引用
typedef std::remove_reference<rmd2>::type rmd3;
std::cout << (std::is_same<rmd3, int const **>::value) << "\n";
typedef std::remove_pointer<std::remove_pointer<rmd3>::type>::type rmd4;
std::cout << (std::is_same<rmd4, int const>::value) << "\n";
typedef std::remove_const<rmd4>::type rmd5;
std::cout << (std::is_same<rmd5, int>::value) << "\n";
处理算术类型
- make_signed : 返回T的有符号证书类型，cv修饰不变
- make_unsigned
处理数组类型
- remove_extend : 删除最高层维度
- remove_all_extents : 删除所有维度，返回0维普通类型
typedef std::remove_extent<int[1][2][5][7]>::type re1;
std::cout << (std::is_same<re1, int[2][5][7]>::value) << "\n";
typedef std::remove_all_extents<int[1][5][7]>::type re2;
std::cout << (std::is_same<re2, int>::value) << "\n";
“？：”和共同类型
- conditional ： 类似于“？：”，类似于mpl::if_C
- common_type : 求多个类型的公共类型（类似于数字的最小公倍数）
typedef std::common_type<int, char>::type ct1;
std::cout << (std::is_same<ct1, int>::value) << "\n";
typedef std::common_type<int, double>::type ct2;
std::cout << (std::is_same<ct2, double>::value) << "\n";
//typedef std::common_type::type ct3;//编译错误
实现原理
inregral_constant
很多值元函数都是用了元函数转发技术，把元参数转发给integral_constant计算，该类也是很多类的的public基类。
源码:
template<typename T, T val>
struct integral_constant
{
static const T value = val;
typedef T value_type;
typedef integral_constant<T, val> type;
constexpr operator value_type() const _NOEXCEPT
{
return (value);
}
constexpr value_type operator()() const _NOEXCEPT
{
return(value);
}
};
type_traits库中提供了以下两个针对bool元数据特化的无参元函数true_type和false_type,看起来像SGI stl中实现的__true_type和__false_type:
typedef integral_constant<bool, true> true_type;
typedef integral_constant<bool, false> false_type;
is_integral
is_integral使用了模板特化技术，对非整数的类型元函数的::value返回false,否则特化地返回true,代码如下:
template<typename T> struct is_integral :public false_type {};
template<> struct is_integral<bool> :public true_type {};
template<> struct is_integral<char> :public true_type {};
template<> struct is_integral<unsigned int> :public true_type {};
template<> struct is_integral<signed int> :public true_type {};
is_same的实现
template<typename T, typename U> struct myis_same :public false_type {};
template<typename T> struct myis_same<T,T> :public true_type {};
is_void实现
template<typename T> struct is_void : is_same<void, typename std::remove_cv<T>::type> {};
is_float_pointer实现
template<typename T >
struct is_floating_point : integral_constant<bool, (is_same<float, typename std::remove_cv<T>::type>::value
|| is_same<double, typename std::remove_cv<T>::type>::value
|| is_same<long double, typename std::remove_cv<T>::type>::value)>{};
is_array实现
template<typename T> struct is_array :public false_type {};
template<typename T> struct is_array<T[]> :public true_type {};
template<typename T,std::size_t N> struct is_array<T[N]> :public true_type {};
is_pointer实现
template<typename T> struct is_pointer_helper :public false_type {};
template<typename T> struct is_pointer_helper<T*> :public true_type {};
template<typename T> struct is_pointer :public is_pointer_helper<typename std::remove_cv<T>::type> {};
is_member_pointer实现
template<typename T> struct is_member_pointer_helper :public false_type {};
template<typename T,class U> struct is_member_pointer_helper<T (U::*)> :public true_type {};
template<typename T> struct is_member_pointer :public is_member_pointer_helper<typename std::remove_cv<T>::type> {};
测试：
std::cout << (expr::is_member_pointer<int demo1::*>::value ? "is member pointer\n" : "is not member pointer\n");
std::cout << (expr::is_member_pointer<int(demo2::*)>::value ? "is member pointer\n" : "is not member pointer\n");
输出：
is member pointer
is member pointer
并不是判断类T中是否真的有返回值为int的函数，或者是否有int型变量，而是只是判断T这个写法是否是成员函数指针、指向成员变量指针类型。
is_class实现
template<typename T> char check(int T::*) {}; //T是class，struct，返回一个大小的char
struct two { char c[2]; };
template<typename T> two check(...) {}; //T是非class ，struct返回两个大小的char
//is_union，排除union体
template<typename T> struct is_class :public integral_constant<bool, sizeof(check<T>(0)) == 1 && !std::is_union<T>::value>{};
is_base_of实现
template<typename Based,typename Derived,bool = (is_class<Based>::value && is_class<Derived>::value)>
class is_base_of
{
template<typename T>
static char helper(Derived, T) {};
static int helper(Based, int) {};
struct Conv
{
operator Derived();
operator Based() const;
};
public:
static const bool value = sizeof(helper(Conv(),0)) == 1;
};
template<typename Based,typename Derived>
class is_base_of<Based,Derived,false>
{
public:
static const bool value = is_same<Based, Derived>::value;
};
- operator Devied() 是类型转换操作符，将类类型值转变为其他类型值的转换，在保留字 operator
之后跟着转换的目标类型，详细参考类型强制转换成员函数; - 当 Base 不是Devied 的超类时，那 operator Devied() 和 operator Base() const
则不是重载关系了；接下来，两个函数类型转换函数都可以匹配 helper(Conv(), 0) ，因为 operator Devied()
满足 static char helper(Devied, T); operator Base() const 满足 static int
helper(Base, int)；但是由于优先匹配非模板的函数的规则，在这里会匹配 static int helper(Base,
int)；Conv()会转换成Base，helper(Conv(), 0) 返回的类型是int，最后 sizeof(int) != 1 。 - 当 Base 是Devied 的超类时，那 operator Devied() 和 operator Base() const 则是重载
关系。那由于 Conv() 不是const类型，只能调用 operator Devied() 做类型转换，最后只能匹配 static
char helper(Devied, T); 返回的类型是char，最后 sizeof(char) == 1 。