为什么这段代码在vs2005中调用不同的模板函数？

Question

代码是:

#include <iostream>
using namespace std;

// compares two objects
template <typename T> void compare(const T&, const T&){
    cout<<"T"<<endl;
};
// compares elements in two sequences
template <class U, class V> void compare(U, U, V){
    cout<<"UV"<<endl;
};
// plain functions to handle C-style character strings
void compare(const char*, const char*){
    cout<<"ordinary"<<endl;
};

int main() {

    cout<<"-------------------------char* --------------------------"<< endl;

    char* c="a";
    char* d="b";
    compare(c,d);

cout<<"------------------------- char [2]---------------------------"<< endl;

    char e[]= "a";
    char f[]="b";
    compare(e,f);

    system("pause");
}

结果是:

------------------------- char*----------------------- ---

Ť

------------------------- char [2] --------------------- -

普通

我的问题是:为什么比较(c,d)调用compare(const T&,const T&)和compare(e,f)调用普通函数,即使两个函数的参数是char*s？

Answer 1

VS2005 似乎可能错误地将e和f变量视为const char *类型。

考虑以下代码：

#include <iostream>
using namespace std;

template <typename T> void compare (const T&, const T&) {
    cout << "T:        ";
};

template <class U, class V> void compare (U, U, V) {
    cout << "UV:       ";
};

void compare (const char*, const char*) {
    cout << "ordinary: ";
};

int main (void) {
    char* c = "a";
    char* d = "b";
    compare (c,d);
    cout << "<- char *\n";

    char e[] = "a";
    char f[] = "b";
    compare (e,f);
    cout << "<- char []\n";

    const char g[] = "a";
    const char h[] = "b";
    compare (g,h);
    cout << "<- const char []\n";

    return 0;
}

其输出：

T:        <- char *
T:        <- char []
ordinary: <- const char []

C++03 的部分13.3 Overload resolution（部分编号在 C++11 中似乎没有变化，因此相同的注释也适用）指定如何选择使用哪个函数，我将尝试用（相对）简单的术语来解释它，因为该标准是相当枯燥的阅读。

基本上，候选人名单是根据函数的实际调用方式（作为类/对象的成员函数、常规（未修饰的）函数调用、通过指针调用等）构建的。

然后，根据参数计数从其中提取可行函数的列表。

然后，从可行的函数中，基于最小隐式转换序列的思想选择最佳拟合函数（参见13.3.3 Best viable functionC++03）。

本质上，从可行列表中选择函数是有“成本”的，该列表是根据每个参数所需的隐式转换设置的。选择函数的成本是该函数的每个单独参数的成本之和，编译器将选择成本最小的函数。

如果发现两个函数具有相同的成本，则标准规定编译器应将其视为错误。

因此，如果您有一个函数，其中一个参数发生隐式转换，那么它将优于必须以相同方式转换两个参数的函数。

“成本”可以在下表的排名栏中看到。精确匹配的成本低于促销，而促销的成本又低于转化。

Rank                 Conversion
----                 ----------
Exact match          No conversions required
                     Lvalue-to-rvalue conversion
                     Array-to-pointer conversion
                     Function-to-pointer conversion
                     Qualification conversion
Promotion            Integral promotions
                     Floating point promotions
Conversion           Integral conversion
                     Floating point conversions
                     Floating-integral conversions
                     Pointer conversions
                     Pointer-to-member conversions
                     Boolean conversions

F1在函数和的转换成本相同的地方F2（例如在您的情况下），F1如果满足以下条件，则被认为更好：

F1 是非模板函数，F2 是函数模板特化。

然而，这并不是故事的全部，因为模板代码和非模板代码都是完全匹配的，因此您会期望看到在所有情况下都调用非模板函数，而不仅仅是第三种情况。

标准中对此进行了进一步介绍：答案位于 部分13.3.3.2 Ranking implicit conversion sequences。该节指出，除非在某些条件下，否则相同的排名会导致歧义，其中之一是：

标准转换序列 S1 是比标准转换序列 S2 更好的转换序列，如果 (1) S1 是 S2 的真子序列（比较 13.3.3.1.1 定义的规范形式的转换序列，不包括任何左值变换；恒等转换序列被认为是任何非恒等转换序列的子序列）...

模板版本的转换实际上是非模板版本（限定和数组到指针转换）的真子集（限定转换），并且真子集被认为具有较低的成本。

因此，在前两种情况下它更喜欢模板版本。在第三种情况下，唯一的转换是非模板版本的数组到指针和模板版本的限定，因此两个方向都没有子集，并且根据我上面提到的规则，它更喜欢非模板版本，在排名表下）。