5

代码是：

#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* ------------------------ ---

吨

------------------------- 字符 [2]---------- --

普通的

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

4

1 回答 1

4

看来 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 定义的规范形式的转换序列，不包括任何左值转换；恒等转换序列被认为是任何非恒等转换序列的子序列）...

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

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

于 2012-08-01T04:04:10.730 回答