問題提出：有一個模板函數，函數在處理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用，可以判斷出更多的情況
