为什么 const 的数组优先绑定到 const T& 参数而不是 T&& 参数？

Question

重载带有“T&&”参数的函数模板通常是个坏主意，因为它可以绑定到任何东西，但假设我们还是这样做了：

template<typename T>
void func(const T& param)
{
  std::cout << "const T&\n";
}

template<typename T>
void func(T&& param)
{
  std::cout << "T&&\n";
}

我的理解是 const T& 重载将被调用为 const 左值的参数，T&& 重载将被调用用于所有其他参数类型。但是考虑一下当我们使用 const 和非 const 内容的数组调用 func 时会发生什么：

int main()
{
  int array[5] = {};
  const int constArray[5] = {};

  func(array);             // calls T&& overload
  func(constArray);        // calls const T& overload
}

VC10、VC11 和 gcc 4.7 同意显示的结果。我的问题是为什么第二个调用会调用 const T& 重载。简单的答案是 constArray 有一个 const ，但我认为这太简单了。推导出的类型 T（无论选择的模板如何）是“5 个 const int 的数组”，因此 const T& 重载中的 param 的类型将是“对 5 个 const ints 的 const 数组的引用”。但是名为 constArray 的数组本身并未声明为 const。那么为什么对func(constArray) 的调用不调用T&& 重载，从而为param 生成“引用5 个常量整数数组”的类型？

这个问题的动机是与c++ template function argument deduce and function resolution 上的问题相关的讨论，但我认为该线程在其他问题上偏离了方向，并没有澄清我现在在这里提出的问题。

Answer 1

在函数参数列表中（以及其他任何地方），数组类型上的 cv 限定符被改组以限定数组元素类型。例如，使用T = int [5]，const T & 将转换为int const (&) [5]。

3.9.3 CV 限定符 [basic.type.qualiifier]

2 - [...] 应用于数组类型的任何 cv 限定符都会影响数组元素类型，而不是数组类型 (8.3.4)。

因此，使用int const [5] 类型的参数调用func 可以推断为调用以下任一：

void func<int [5]>(int const (&) [5])
void func<int const (&) [5]>(int const (& &&) [5])
// where the above collapses to
// 'void func<int const (&) [5]>(int const (&) [5])'

两种重载都是可行的，但首选前者：

令 T1 为const T & 模板，T2 为T && 模板；也就是说，它们的参数类型是 T1 := const T & 和 T2 := T &&。然后转换后的参数类型 (14.5.6.2:3) 可以写成 A1 := const C &, A2 := D && 合成类型 C, D。

现在，我们尝试将 T1 与 T2 (14.8.2.4:2) 排序，首先使用 A1 作为参数模板，P2 作为参数模板。我们删除引用 (14.8.2.4:5) 给 A1 -> const C 和 T2 -> T，然后删除 cv-qualification (14.8.2.4:7) 给 A1 -> C 和 T2 -> @987654338 @。模板T 可以推导出为C (14.8.2.4:8) 所以A1 至少和P2 一样专业；相反，A2 -> D -> D, P1 -> const T -> T, 和 T 可以推导出为 D，所以 A2 至少和 P1 一样特化.

这通常意味着没有一个比另一个更专业；但是，因为 P 和 A 类型是引用类型，所以适用 14.8.2.4:9，并且由于 A1 是左值引用而 P2 不是，因此 T1 被认为比 T2 更专业。 （引用类型之间的联系也可以通过同一子句下的 cv 限定来打破。）

Answer 2

您混淆了右值引用（如int&&）和通用引用（由模板参数构成，如template <typename T> ... T&&）。

右值引用确实不绑定到左值。但是通用引用绑定到任何东西。问题只是谁更适合。

你的类型是int const [5]。现在让我们看看：

• 反对T const &：匹配T = int[5]。

• 反对T &&：匹配T = int const (&)[5]。

前者是更好的匹配，在以下意义上：两个模板产生相同的重载。但是T = int[5] 比T = int const (&)[5]更专业。您可以看到这一点，因为 T = int const (&)[5] 可以实现为 T = U const & 和 U = int[5]。

请注意，要将左值绑定到通用引用，必须将类型本身推导出为引用类型。

（显然array不匹配const T &，因为它不是const，只能匹配T&&，推导出T = int (&)[5]）。