基于值与常量引用的函数重载

Question

声明类似以下内容是否

void foo(int x)        { std::cout << "foo(int)"         << std::endl; }
void foo(const int &x) { std::cout << "foo(const int &)" << std::endl; }

有意义？呼叫者如何区分它们？我试过了

foo(9);  // Compiler complains ambiguous call.

int x = 9;
foo(x);  // Also ambiguous.

const int &y = x;
foo(y);  // Also ambiguous.

Answer 1

其目的似乎是区分临时调用（即 9）和“常规”参数传递。第一种情况可能允许函数实现采用优化，因为很明显参数将在之后被处理（这对于整数文字来说绝对毫无意义，但对于用户定义的对象可能有意义）。

然而，当前的 C++ 语言标准没有提供专门针对参数的“左/右值”进行重载的方法 - 任何作为参数传递给函数的左值都可以隐式转换为引用，因此歧义是不可避免的。

C++11 引入了一个用于类似目的的新工具 - 使用r-值引用，您可以按如下方式重载

void foo(int x)        { ... }
void foo(const int &&x) { ... }

...和foo(4)（临时的，作为参数传递的 r 值）将导致编译器在 int i = 2; 时选择第二个重载。 foo(i) 会选择第一个。

（注意：即使使用新的工具链，也无法区分示例中的情况 2 和 3！）

Answer 2

您可以使用模板来完成此操作：

template; void foo(T x) { ... }

然后您可以按值或按引用调用此模板：

int x = 123;
foo<int>(x);  // by value
foo<int const&>(x);  // by refernce

Answer 3

调用者如何区分它们？

在这种情况下无法区分。两个重载函数都具有与参数相同的类型原始数据类型。并且通过引用不计入不同类型。

Answer 4

您可以使用static_cast显式选择要调用的重载：

#include <iostream>

void foo(int x)        { std::cout << "foo(int)"         << std::endl; }
void foo(const int &x) { std::cout << "foo(const int &)" << std::endl; }

int main()
{
  int x = 0;

  auto f1 = static_cast< void(*)(int) >(foo);
  f1(x);

  auto f2 = static_cast< void(*)(const int&) >(foo);  
  f2(x);

}

但是，您应该问自己为什么首先提供这两个重载。您要么可以复印，要么不行。两者同时进行？为什么？此外，调用者必须显式选择重载，这也违背了函数重载的目的。如果您确实想要考虑提供两个函数：

void foo_copying(int x)        { std::cout << "foo(int)"         << std::endl; }
void foo_non_copying(const int &x) { std::cout << "foo(const int &)" << std::endl; }

Answer 5

不是在 C++ 中。 Erlang 和 Haskell 等函数式语言更接近，允许您根据参数值指定函数重载，但包括 C++ 在内的大多数命令式语言都需要基于方法签名进行重载；即每个参数的数量和类型以及返回值的类型。

签名中的 const 关键字定义的不是参数的类型，而是它在函数内的可变性；如果“const”参数被函数修改或通过引用传递给任何不使用 const 的函数，则会生成编译器错误。

Answer 6

编译器不能。
foo 的两种定义都可以用于 int 的所有“变体”。

在第一个 foo 中，创建了 int 的副本。复制 int 始终是可能的。

在第二个 foo 中，传递了对 const int 的引用。由于任何 int 都可以转换为 const int，因此也可以传递对其的引用。

由于这两种变体在所有情况下都有效，因此编译器无法选择。

如果您使用以下定义，事情就会变得不同：

void foo (int &x);

现在用 foo(9) 调用它将采用第一个替代方案，因为您不能将 9 作为非常量 int 引用传递。

另一个例子，如果将 int 替换为复制构造函数是私有的类，则调用者无法复制该值，并且将不会使用第一个 foo 变体。