带着媳妇儿奔小康
问题提出：有一个模板函数，函数在处理int型和double型时需要进行特殊的处理，那么怎么在编译期知道传入的参数的数据类型是int型还是double型呢？
如：
#include
template
void typecheck(type data)
{
//do something check data type
//std::cout<< out put the type
}
这里就需要用到c++11的type_traits头文件了，type_traits头文件定义了很多类型检查相关的方法，上面的例子具体用到了其中两个结构：
std::is_same 判断类型是否一致
位于头文件
这个结构体作用很简单，就是两个一样的类型会返回true
bool isint = std::is_same::value; //为true
下面是官方的例子：
#include
#include
#include
void print_separator()
{
std::cout << "-----\n";
}
int main()
{
std::cout << std::boolalpha;
std::cout << std::is_same::value << '\n'; // true
std::cout << std::is_same::value << '\n'; // false
std::cout << std::is_same::value << '\n'; // false
print_separator();
std::cout << std::is_same::value << "\n"; // true
std::cout << std::is_same::value << "\n"; // false
std::cout << std::is_same::value << "\n"; // true
print_separator();
// unlike other types 'char' is not 'unsigned' and not 'signed'
std::cout << std::is_same::value << "\n"; // true
std::cout << std::is_same::value << "\n"; // false
std::cout << std::is_same::value << "\n"; // false
}
通过std::is_same即可判断两个类型是否一样，特别在模板里面，在不清楚模板的参数时，此功能可以对一些特定的参数类型进行特殊的处理。
这里说个题外话，大家是否通过std::is_same发现，char既不是unsigned char也不是signed char，char就是char，这和int是signed int的缩写是不一样的，char的表达范围可能等同于signed char，也可能等同于unsigned char，取决于编译器，一般是等同于signed char，但这个仅仅是范围等同，就像32位上int和long范围是一样的，但不是同一个类型。
因为用途不同，char用于表达字符，理论上不应该关心其正负的实现，而signed char 和 unsigned char 用于表达数值，或可移植的char。
回到正文，std::is_same可以判断两种类似是否一样，那么用在模板里就是利器了，本位一开始提到的那个问题就可以这样写：
#include
template
typecheck(type data)
{
if(std::is_same::value)
{
std::cout<<"int type";
//do something int
}
else
{
//.........
}
}
视乎很美好，再看一个示例：
// is_same example
#include
#include
#include
typedef int integer_type;
struct a { int x,y; };
struct b { int x,y; };
typedef a c;
int main() {
std::cout << std::boolalpha;
std::cout << "is_same:" << std::endl;
std::cout << "int, const int: " << std::is_same::value << std::endl;//false
std::cout << "int, int&: " << std::is_same::value << std::endl;//false
std::cout << "int, const int&: " << std::is_same::value << std::endl;//false
std::cout << "int, integer_type: " << std::is_same::value << std::endl;//true
std::cout << "a, b: " << std::is_same::value << std::endl;//false
std::cout << "a, c: " << std::is_same::value << std::endl;//true
std::cout << "signed char, std::int8_t: " << std::is_same::value << std::endl;//true
return 0;
}
输出：
is_same: int, const int: false int, int&: false int, const int&: false int, integer_type: true a, b: false a, c: true signed char, std::int8_t: true
发现std::is_same的判断是很严格的
但是有时候在编辑模板的时候又发现用std::is_same的判断太过严格，还是之前的例子：
#include
#include
#include
template
void typecheck(type data);
int _tmain(int argc, _tchar* argv[])
{
int a = 1;
const int& b = a;
int& c = a;
int d[12];
const int& e = d[7];
typecheck(a);//int type
typecheck(b);//int type
typecheck(c);//int type
typecheck(d[7]);//int type
typecheck(e);//int type
typecheck(8);//int type
system("pause");
return 0;
}
template
void typecheck(type data)
{
if(std::is_same::value)
{
std::cout<<"int type"<::value)
{
std::cout<<"string type"<输出：
int type
int type
int type
int type
int type
int type
测试后发现，虽然变量b,c使用引用，但std::is_same还是能识别出来的，但是！！
如果我显示的指定模板参数类型时情况有不一样了：
#include
#include
#include
template
void typecheck(type data);
int _tmain(int argc, _tchar* argv[])
{
int a = 1;
const int& b = a;
int& c = a;
int d[12];
typecheck(a); //int type
typecheck(b);//other type
typecheck(c); //other type
typecheck(d[7]);//other type
typecheck(8); //int type
system("pause");
return 0;
}
template
void typecheck(type data)
{
if(std::is_same::value)
{
std::cout<<"int type"<::value)
{
std::cout<<"string type"<输出：
int type
other type
other type
other type
int type
瞬间结果就不一样了，这很好了解，从上面可知道，std::is_same对int和const int\int &\const int&等都是区别对待的，但在写模板函数时，经常会强制指定常引用进行传参，以免进行数据拷贝，这时候is_same就做出了不相等的判断，但是有时候其实我们还是希望type和const type& 是能认为是一样的，这时就需要std::decay进行退化处理
std::decay 退化类型的修饰
std::decay就是对一个类型进行退化处理，他的实现如下:
template< class t >
struct decay {
private:
typedef typename std::remove_reference::type u;
public:
typedef typename std::conditional<
std::is_array::value,
typename std::remove_extent::type*,
typename std::conditional<
std::is_function::value,
typename std::add_pointer::type,
typename std::remove_cv::type
>::type
>::type type;
};
看着比较抽象，其实就是把各种引用啊什么的修饰去掉，把cosnt int&退化为int，这样就能通过std::is_same正确识别出加了引用的类型了
上面的例子改为：
#include "stdafx.h"
#include
#include
#include
template
void typecheck(type data);
int _tmain(int argc, _tchar* argv[])
{
int a = 1;
const int& b = a;
int& c = a;
int d[12];
typecheck(a);//int type
typecheck(b);//int type
typecheck(c);//int type
typecheck(d[7]);//int type
typecheck(8);//int type
system("pause");
return 0;
}
template
void typecheck(type data)
{
if(std::is_same::type,int>::value)
{
std::cout<<"int type"<在cppref有个更加详细的例子：
#include
#include
template
struct decay_equiv :
std::is_same::type, u>::type
{};
int main()
{
std::cout << std::boolalpha
<< decay_equiv::value << '\n'
<< decay_equiv::value << '\n'
<< decay_equiv::value << '\n'
<< decay_equiv::value << '\n'
<< decay_equiv::value << '\n'
<< decay_equiv::value << '\n';
}
输出:
true
true
true
true
true
true
总结：
在模板里可以通过std::is_same判断模板的类型，从而实现对不同类型的区别对待 在堆类型要求不是非常严格的情况下，可以使用std::decay把类型退化为基本形态，结合std::is_same用，可以判断出更多的情况
