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＆amp;，const T＆amp;）和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中的部分编号似乎没有变化，因此相同的注释适用于那里）指定了如何选择使用哪个函数，我将尝试解释它（相对）简单的术语，因为标准是干读。

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

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

然后，根据可行函数，根据最小隐式转换序列的思想选择最佳拟合函数（参见C ++ 03的13.3.3 Best viable function）。

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

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

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

“成本”可以在下表中的Rank列中看到。完全匹配的成本低于促销，其成本低于转化成本。

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定义的规范形式的转换序列，不包括任何左值变换;身份转换序列被认为是任何非同一性转换序列的子序列）...

模板版本的转换实际上是非模板版本的正确子集（限定转换）（限定AND数组到指针转换），并且适当的子集被视为具有降低成本。

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

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

1 个答案: