我有以下代码：
#include <iostream>
template <typename T>
void f(T& x)
{
std::cout << "f(T& )" << std::endl;
}
template <typename T>
void f(const T& x)
{
std::cout << "f(const T& )" << std::endl;
}
int main()
{
int a = 0;
const float b = 1.1;
f(a); // call f(T&)
f(b); // call f(const T&)
}
输出结果为：
f(T& )
f(const T& )
error: redefinition of 'f'。对我来说，看起来f(T&)可以同样适用于两种调用，为什么const版本在f(b)中被明确地调用？给定两个竞争的重载函数，标准要求编译器选择最匹配的函数。(如果没有唯一最佳的重载函数，或者唯一最佳的重载函数无法访问，则程序是非法的。)
在这种情况下，规则由§13.3.3.2 [over.ics.rank]/p3提供:
如果标准转换序列S1比标准转换序列S2更好，则标准转换序列S1是更好的转换序列。条件如下：
[...]
S1和S2是引用绑定(8.5.3)，并且这些引用所引用的类型除了顶层cv限定符外相同，而且由S2初始化的引用所引用的类型比S1初始化的引用所引用的类型更具有cv限定符。
这是标准中提供的示例:
int f(const int &);
int f(int &);
int g(const int &);
int g(int);
int i;
int j = f(i); // calls f(int &)
int k = g(i); // ambiguous
在您的情况下，const T& 比 T& 更具有cv限定符，因此根据标准，f(T&) 比 f(const T&) 更适合，并且会被重载解析所选中。
const和非const成员函数重载，分别采用隐式的const引用和非const引用对象参数。您不希望在非const对象上调用此类成员函数时产生歧义，否则您将打败允许这些重载的初衷。 - T.C.void foo(T t);与void foo(const T t);是相同的函数。 - juanchopanzaf(T&) vs. f(T const&)
The two functions are different, in that the first signature states that any variable passed by reference may be modified by the function. So the const float cannot be passed to the first function, and the second is the only viable choice for the compiler. A nonconst variable could be passed to both, so the compiler has to chose the better fit, if there is one. The standard says, that in order to call the second function, the compiler would have to add a const to any nonconst variable, while for the first function this is not necessary. Adding const is an implicit conversion, and it is a "worse" converison (read that as more conversion steps) than adding nothing. Therefore the standard demands that the compiler picks the first function when passing nonconst variables.
In case you wonder: literals and temporaries can not be bound to nonconst references, so f(4), f("meow") and f(someFunc()) will all call the second function.
f(T) vs. f(const T)
They look different, but aren't in terms of overload resolution or function signature. Both of them are call by value, or for the compiler: pass a copy of the argument into the function. The only difference is in a function definition, that you require the variable to be constant in the function body. Any function declaration does not affect the variable definition in the function definition's signature:
void f(int); //a declaration
void f(int i); //redeclaration of the same function
void f(int const); //still the same function redeclared
void f(int const i2); //yes... a redeclaration
void f(int const i) { //at last a function definition and the copy of the argument used in the function body is required to be const
//...
}
void f(int i) { //there is only one f, so this is a redefinition!
//...
}
This is not an "ambuguos call type error", because for the compiler there is only one function and no ambiguity. The error is simply that you did defin the same funciton twice. For that reason, it is preferred in many style guides that function declarations have no top-level const, and compilers will often ignore them and not mention them in error or warning messages.
f(b)，其中b是一个const float时，它将调用f()的const变体。 - Alex