整型映射和類型映射（節選自《Modern C++ Design》）

函數無法偏特化，但是卻有重載。單從功能而言，重載是一個與偏特化相同的技術。

   1: struct T1{};

   2: struct T2{};

   3: struct T3{};

   4:  

   5: void fun(T1 &fn);

   6: void fun(T2 &fn);

   7: void fun(T3 &fn);

在這種情況下，編譯器需要對每個函數進行檢查，如果某個函數或某個函數的一部分未使用，就會引起編譯器報錯。在這種情況下，就可利用模板技術來解決。

   1: template<int V>

   2: struct Int2Type

   3: {

   4:     enum { VALUE = v };

   5: };

   6:  

   7: template<typename T>

   8: struct Type2Type

   9: {    

  10:     typedef T Type;

  11: };

現在就能如下使用了

   1: DoSome(arg, Int2Type<1>()); 

   2: DoSome(arg, Int2Type<0>()); 

   3: DoSomeEx(arg, Int2Type<int>()); 

   4: DoSomeEx(arg, Int2Type()); 

 

一般而言，符合下列兩個條件便可使用Int2Type技術：

1）.有必要根據某個編譯期常熟調用一個或數個不同的函數

2）.有必要在編譯器實施分派

 

使用Create創建一個新對象

   1: template<typename T, typename U>

   2: T *Create(const U &arg, T)

   3: {

   4:     return new T(arg);

   5: }

現在需要爲創建Widget對象，使用重載來解決

   1: template<typename T, typename U>

   2: T *Create(const U &arg, T)

   3: {

   4:     return new T(arg);

   5: }

   6: template<typename U>

   7: Widget *Create(const U &arg, Widget)

   8: {

   9:     return new Widget(arg);

  10: }

但是這種方案會造成複雜對象Widget的構造，所以只需要傳遞型別T的信息到Create函數中即可

   1: template<typename T, typename U>

   2: T *Create(const U &arg, Type2Type)

   3: {

   4:     return new T(arg);

   5: }

   6:  

   7: string *str = Create("Hello", Type2Type);

   8: Widget *pW = Create(100, Type2Type);

但是，我到覺得這樣寫會增加客戶程序的負擔，利用宏倒是可以減少輸入代碼量，但是本人極度討厭自定製的宏。