不知道為什么，我最近越來越覺得C++太難了，也許是因為我也陷入到扣語言細節的泥沼了吧。不過換個角度來講，C++之所以這么有吸引力，也多虧了它有這么多復雜的細節，正是因為這些細節不斷被發掘，才更加引得C++程序員激情四射、奮不顧身。比如說模板元編程，C++模板在設計之初根本沒有想到模板元編程這回事，更沒想到C++模板系統是圖靈完備的，結果1994年Erwin Unruh提數了可以使用模板在編譯器進行某些計算后，無數的大牛人便前仆后繼，將模板編程發揮到了極致。
我想我也是屬于那種沒事找抽的人，要不然我為什么會抱著《C++ Templates》這本書看呢？奈何我能力有限，兼且經驗不足，使用C++的時候少，使用模板的時候更少，所以對于書中的內容，要么就是看了不是很懂，要么就是看了也不知道它有什么用。但是也不是完全沒有收獲，對于以前兩個百思不得其解的問題，也還算是靈光一閃、豁然貫通了。
其中一個是Trait，這是我以前在使用STL和ATL庫的時候遇到過的，雖然想不透其中的奧妙，但是不影響我寫程序。另外一個是模板元編程，只聽說過，如雷灌耳，但是卻從來沒有見過，也想象不出它的原理，《C++ Templates》終于讓我看到了它的廬山真面目。
先來說說Trait，這是一個在C++ Template編程中經常用到的一個設計機制，我在使用STL庫中的basic_string時見到過，其定義如下：
template?<
???class?CharType,
???class?Traits=char_traits<CharType>,?
???class?Allocator=allocator<CharType>?
>
class?basic_string
其中就有一個模板參數為Traits，而它的默認值為char_traits<CharType>，這里的char_traits<>就是一個trait類，它可以提供關于CharType的特征信息。我們常用的string類的定義如下：
typedef?basic_string<char>?string
如果我們把它的默認模板參數帶入，就可以看到string的形式是這樣的：
basic_string<?char,?char_traits<char>,?allocator<char>?> 到這里，我就迷糊了，我在想，為什么char_trait<>就能夠取得char的類型信息？為什么basic_string<>就不行？難道說加上trait這幾個字，模板類就有了三頭六臂不成？
另外一個見到Trait的地方就是
ATL 3.0中的窗口類，這是我很早以前翻譯的一篇文章，其中也使用到了Trait，在定義窗口樣式的時候，其代碼如下：
class?CMyWindow:?public?CWindowImpl<
???CMyWindow,
???CWindow,
???CWinTraits<WS_OVERLAPPEDWINDOW|WS_VISIBLE,0>?
>
{
}; 當時我就想了，為什么不直接把“
WS_OVERLAPPEDWINDOW|WS_VISIBLE,0”當成模板參數傳遞給CWindowImpl<>算了，還非要CWinTraits<>來摻和一把？
直到現在，我終于知道，原來一直錯的就是我。我不該把char_traits<>看成是一個模板類，不該認為傳給它一個char它就可以讀出char的特征信息，傳給它一個int它就能讀出int的特征信息。它當然不可能具備這么高級的功能，更不可能加上traits幾個字就一下子掙脫了C++語言的束縛。
那么不把它看成一個模板類，應該怎么看呢？應該把char_traits<char>看成一個整體，說專業點，那叫模板特化，說通俗點，就是原來這里面的特征信息都是編寫它的人自己定義的，如果你要讓basic_string能夠處理int，double之類的信息，你還得自己寫一個char_traits<int>和一個char_traits<double>。CWinTraits<...>也同樣是這個道理。
為了說得更清楚點，我這里舉個小例子。什么例子呢？就寫個計算平均值的模板函數吧，如下：
template?<typename?T>
T?average(T?const*?begin,?T?const*?end)
{
????T?total?=?T();
????int?count?=?0;
????while?(begin?!=?end){
????????total?+=?*?begin;
????????++begin;
????????++count;
????}
????return?total/count;
}
下面是使用這個函數的代碼，如果我們計算的類型是int，結果是正確的，如下：
int?main(){
????int?numbers[]?=?{1,2,3,4,5};
????std::cout?<<?average(&numbers[0],&numbers[5])?<<?std::endl;
}
該程序運行的結果是3，非常正確，將數據類型換成float，double也沒有問題。但是，如果是char類型，就不一定了。代碼如下：
int?main(){
????char?characters[]?=?"traits";
????std::cout?<<?static_cast<int>(average(&characters[0],&characters[6]))?<<?std::endl;
}
運行結果為 -17，不信大家可以自己運行試一下。為什么是個負數呢？
原因是因為char類型能表示的范圍只有-127到+128，幾個字母一加，就溢出了。為了得到正確的結果，我們希望能有一種機制，來指定運算的時候用什么作為返回類型，這時候，traits就可以閃亮登場了。前面已經說過，要把trait<...>看成一個整體，所以應該為每一個數據類型都定義一個trait。在這個例子中，我們主要是為了對每一個運算的類型指定合適的返回類型，任務比較簡單，所以，代碼可以這樣寫：
template?<typename?T>
class?TypeTraits;
template?<>
class?TypeTraits<char>{
public:
????typedef?int?ReturnType;
}
template?<>
class?TypeTraits<short>{
public:
????typedef?int?ReturnType;
}
template?<>
class?TypeTraits<int>{
public:
????typedef?int?ReturnType;
}
template?<>
class?TypeTraits<float>{
public:
????typedef?double?ReturnType;
}
函數可以改成這樣：
template?<typename?T,typename?Traits>
typename?Traits::ReturnType?average(T?const*?begin,?T?const*?end)
{
????typedef?typename?Traits::ReturnType?ReturnType;
????ReturnType?total?=?ReturnType();
????int?count?=?0;
????while?(begin?!=?end){
????????total?+=?*?begin;
????????++begin;
????????++count;
????}
????return?total/count;
}
使用該函數的代碼是這樣：
int?main(){
????int?numbers[]?=?{1,2,3,4,5};
????std::cout?<<?average<int,TypeTraits<int>?>(&numbers[0],&numbers[5])?<<?std::endl;
????char?characters[]?=?"traits";
????std::cout?<<?average<char,TypeTraits<char>?>(&characters[0],&characters[6])?<<?std::endl;
}
這時候，一切都正常了。只可惜模板函數不支持默認模板參數，要不然，這里的代碼可以更簡潔。
再來說說Template Mataprogram，中文叫模板元編程。我之能聽說它，并對它不甚向往，主要是因為它有這樣幾個特點：
1、它編的程序不是運行的時候執行的，而是在編譯的時候由編譯器執行的；
2、它能夠牽著編譯器的鼻子走，靠的完全是符合標準的模板語法，不需要使用編譯器的任何API；
3、它居然是圖靈完備的，也就是說它什么事都能干。
牛吧？C++提供了一個模板機制，這些大牛們居然可以用模板把編譯器耍得團團轉，居然能在程序還沒運行的時候就什么都能干。反正我是崇拜得五體投地。直到最近看書，才找到了它的奧秘所在，當然了，只限于基本原理。
那么，這個基本原理是怎樣的呢？其實就是靠的模板的實例化，和使用枚舉值或靜態常量。具體來說是這樣：當編譯器遇到enum的定義的時候，就會對該enum進行求值，這個求值是在編譯期進行的，而如果該enum對應的表達式是一個模板類的成員，則會實例化該模板類，而實例化模板類的時候，又是遞歸進行的，這樣，就可以在遞歸的過程中作我們想做的任何事（理論上可以做任何事，但是以我的水平，也就只能算算加減乘除）。看起來是不是不好理解？沒關系，下面看一個例子，計算N的階乘：
template?<int?N>
class?Factorial
{
public:
????enum?{?result?=?N?*?Factorial<N-1>::result?};
};
這下該明白了吧，為了得到Factorial<N>::result的值，就會實例化Factorial<N>，然后又會實例化Factorial<N-1>，依次類推，一直遞歸下去。那么什么時候結束呢？所以還需要一個特化版本：
template<>
class?Factorial<1>
{
public:
????enum?{?result?=?1?};
}
下面寫幾行代碼測試一下，如下：
int?main()
{
????std::cout?<<?Factorial<10>::result?<<?std::endl;
????return?0;
}
OK，事情就這么簡單。大家都知道，遞歸可以代替循環，就只是對內存的消耗大一些，所以遞歸的層次不能太多。解決了循環的問題，那么分支結構如何解決呢？
不用擔心，看看下面這樣的模板定義：
template?<bool?C,?typename?Ta,?typename?Tb>
class?IfThenElse;
template?<typename?Ta,?typename?Tb>
class?IfThenElse<true,?Ta,?Tb>{
public:
????typedef?Ta?ResultT;
};
template?<typename?Ta,?typename?Tb>
class?IfThenElse<false,?Ta,?Tb>{
public:
????typedef?Tb?ResultT;
};
一個模板類加上兩個局部特化版本就解決了問題，如果第一個模板參數是true，則選擇Ta作為結果，否則就選擇Tb作為結果。
雖然C++為我們提供了模板元編程的能力，雖然我現在知道了它的基本實現機制，但是我依然想不到究竟什么時候需要用到模板元編程，聽說要開發高可用性的第三方庫少了它不行，也聽說Boost庫中到處可以見到它的身影，但僅僅只是聽說而已，我自己是想不到，也做不到。
當然了，學習C++也并不是非要把這些語言的細節都啃透，除非是確實非用它不可。對于我來說，那些高質量的庫，我只要會用就可以了，而且只有當確實需要的時候再去用這些庫。因此，我還是保持簡單的事情簡單化，繼續寫我的簡單代碼吧。