C++ 函數重載，函數模板和函數模板重載，選擇哪個？

重載解析

　　在C++中，對於函數重載、函數模板和函數模板重載，C++須要有一個良好的策略，去選擇調用哪個函數定義(尤爲是多個參數時)，這個過程稱爲重載解析。

　　（這個過程將會很是複雜，希望不要遇到必定要寫這種代碼的時候。）

 

大體步驟

　　Ⅰ.建立候選函數列表（其中包含與候選函數相同名稱的函數和模板函數）。

　　Ⅱ.使用候選函數列表建立可行函數列表（要求參數數目正確，爲此有一個隱式類型轉換序列，其中包括實參類型與相應的形參類型徹底匹配的狀況。例如，使用float參數的函數調用能夠將該參數轉換爲double類型，從而與double匹配，而模板函數能夠爲float類型生成一個函數實例）。

　　Ⅲ.肯定是否有最佳的可行函數（若是有則調用，沒有則報錯）。

 

　　咱們以只有一個參數的函數爲例：

 1 may('B');    // 函數調用
 2 
 3 /*如下是一系列候選函數聲明*/
 4 void may(int);                       　　　// #1
 5 float may(float, float = 3);　　　　　　　　// #2
 6 void may(char);                    　　　　// #3
 7 char * may(const char *);     　　　　　　　// #4
 8 char may(const char &);       　　　　　　　// #5
 9 template<class T> void may(const T &);    // #6
10 template<class T> void may(T *);          // #7

　　這些函數聲明都會進入函數列表（由於名稱相同），接下來考慮特徵標（參數數量與類型），不考慮返回值。其中#4和#7不可行，由於整數沒法隱式類型轉換爲指針類型。#6可用來生成具體化，其中T被替換爲char類型，此時還剩下5個可行的函數（#一、#二、#三、#五、#6）。若是此時只剩下一個，那麼任何一個均可以正確使用。

　　

　　接下來，到了擇優環節。這一步主要考量的是函數調用參數與可行的候選函數的參數匹配所須要進行的轉換。一般，從最佳到最差的順序以下：

　　　一、徹底匹配，函數優於模板。

　　　二、提高轉換（例如，char和short自動轉換爲int，float自動轉換爲double）。

　　　三、標準轉換（例如，int轉換爲char，long轉換爲double）。

　　　四、用戶定義的轉換，如類聲明中定義的轉換。

　　在剩餘的5個函數中，#1優於#2，由於char到int是提高轉換，而char到float是標準轉換（此時還剩#1，#3，#5，#6）。#三、#五、#6優於#1和#2，由於他們是徹底匹配（還剩#3，#5，#6）。#3和#5優於#6，由於#6是模板（還剩#3和#5）。

　　這時，會出現兩個問題，徹底匹配究竟是什麼？若是有兩個徹底匹配（#3和#5）該怎麼辦？一般有兩個徹底匹配是一種錯誤，但這一規則有兩個例外。

 

徹底匹配和最佳匹配

　　進行徹底匹配時，C++容許某些「可有可無的轉換」，下表列出了這些轉換——Type表示任意類型。例如，int到int &，注意，Type能夠是char &這樣的類型，所以，這些規則也包括char &到const char &的轉換。

徹底匹配容許的可有可無的轉換

從實參	到形參
Type	Type &
Type &	Type
Type[]	* Type
Type(參數列表)	Type（*）（參數列表）
Type	const Type
Type	volatile Type
Type *	const Type
Type *	volatile Type *

 　　假設有以下代碼：

1 struct blot {int a; char b[10]};
2 blot ink = {25, "spots"};
3 recycle(ink);
4 
5 // 下面的原型徹底匹配
6 void recycle(blot);          // #1 blot to blot
7 void recycle(const blot);　　 // #2 blot to const blot
8 void recycle(blot &);　　　　　// #3 blot to blot &
9 void recycle(const blot &);　// #4 blot to const blot &

 　　若是有多個徹底匹配的原型，則沒法完成重載解析過程，若是沒有最最佳的可行函數，編譯器將報錯。

　　然而，有這樣的例外規則，首先，指向非const數據的指針和引用優先於非const指針和引用，在上例中，若是隻定義了#3和#4，將選擇#3，由於ink沒有被聲明爲const，然而const和非const之間的區別只適用於指針和引用指向的數據，也就是說，若是隻定義了#1和#2，將出現二義性錯誤。

　　一個徹底匹配優於另外一個的另外一種狀況是，其中一個是非模板函數而另外一個不是，這種狀況下，非模板函數將優先於模板函數（包括顯式具體化）。

　　若是兩個徹底匹配的函數都是模板函數，則較具體的模板函數優先，這意味着顯示具體化將優於模板隱式生成的具體化。

1 struct blot {int a; char b[10]}；
2 template <class Type> void recycle(Type t);  // 模板
3 template <> void recycle<blot>(blot & t);    // 顯示具體化
4 
5 blot ink = {25, "spots"};
6 recycle(ink);    //使用顯示具體化

　　術語「最具體」並不必定意味着顯示具體化，而是指編譯器推斷使用哪一種類型時執行的轉換最少。例如：

1 struct blot {int a; char b[10]}；
2 template <class Type> void recycle(Type t);    // #1
3 template <class Type> void recycle(Type * t);  // #2
4 
5 blot ink = {25, "spots"};
6 recycle(&ink);    // 使用#2，由於轉換最少，#2被認爲是更具體的

　　用於找出最具體的模板的規則被稱爲部分排序規則。

 

部分排序規則

 1 template <typename T>
 2 void show(T arr[], int n);     // #1
 3 
 4 template <typename T>
 5 void show(T * arr[], int n);   // #2
 6 
 7 struct debts
 8 {
 9     char name[50];
10     double amount;
11 };
12 
13 ......
14 
15 int things[6] = {13,31,103,301,310,130};
16 debts mr[3] = 
17 {
18    {"aaa", 24.1},
19    {"bbb", 25.2},
20    {"ccc", 26.3}   
21 };
22 double * pd[3];
23 
24 for(int i=0; i<3; i++)
25 {
26    pd[i] = &mr[i].amount;          
27 }
28 
29 show(things, 6); // 使用#1
30 show(pd, 3);　　  // 使用#2

 　　things是一個int數組，與#1匹配，其中T被替換爲int。pd是一個double *數組，與#1匹配時，T被替換爲double *，與#2匹配時，T被替換爲double。在這兩個模板中，#2更加具體，由於它作了特定的假設，數組內容是指針，所以被使用。若是將#2從程序中刪除，那麼使用#1，將顯示出地址，而不是值。

　　總之，重載解析將尋找最匹配的函數，若是隻存在一個這樣的函數，則選擇它；若是存在多個這樣的函數，但其中只有一個非模板函數，則選擇它；入伏哦存在多個合適的函數且都爲模板函數，但其中只有一個函數比其餘函數更具體，則選擇它。其餘狀況（有多個非模板或模板函數，但沒有一個比其餘更具體，或根本不存在匹配的函數）均爲錯誤。

 

建立自定義選擇

　　在有些狀況下，能夠引導編譯器作出你但願的選擇。

 1 template<class T>
 2 T lesser(T a, T b);           // #1
 3 
 4 int lesser(int a, int b);     // #2
 5 
 6 ......
 7 
 8 int m = 20;
 9 int n = -30;
10 double x = 15.5;
11 double y = 25.9;
12 
13 lesser(m, n);                // 使用#2
14 lesser(x, y);                // 使用#1，T被轉換爲double類型
15 lesser<>(m, n);              // <>提示編譯器，使用模板函數，使用#1
16 lesser<int>(x, y);           // 顯式實例化，將使用實例化後的函數x，y被強制轉換爲int類型

 

多個參數的函數

　　將有多個參數的函數調用與有多個參數的原型進行匹配時，狀況將很是複雜。編譯器必須考慮全部參數的匹配狀況。若是找到比其餘可行函數都合適的函數，則選擇該函數。一個函數要比其餘函數都合適，其全部參數的匹配程度都必須沒必要其餘函數差，同時至少有一個參數的匹配程度比其餘函數高。