为什么隐式转换不适用于模板化函数参数？

Question

我遇到了一些模板问题，我已将其范围缩小到以下示例 (C++17)：

template <typename T> struct item {
  operator item<const T> () const { return item<const T>(); }
};

void conversionToConstRefWorks (const item<const int> &) { }

template <typename T> 
void butNotWhenTemplated (const item<const T> &) { }

int main () {

  item<int> i;
  item<const int> ci;

  // these all compile fine:
  conversionToConstRefWorks(ci);
  conversionToConstRefWorks(i);
  butNotWhenTemplated(ci);

  // but this one fails:
  butNotWhenTemplated(i); 

}

在那个例子中：

• item<T> 具有到 item<const T> 的隐式转换运算符，并且
• 转换似乎在 conversionToConstRefWorks() 中有效，但是
• butNotWhenTemplated() 中似乎错过了转换，其中 item<const int> 可以很好地传递，但传递 item<int> 无法编译。

该示例的编译失败 (GCC 9.3)：

g++ --std=c++17 -W -Wall -pedantic -Wno-unused-variable    const_interop.cpp   -o const_interop
const_interop.cpp: In function ‘int main()’:
const_interop.cpp:54:24: error: no matching function for call to ‘butNotWhenTemplated(item<int>&)’
   54 |   butNotWhenTemplated(i);
      |                        ^
const_interop.cpp:40:6: note: candidate: ‘template<class T> void butNotWhenTemplated(const item<const T>&)’
   40 | void butNotWhenTemplated (const item<const T> &) {
      |      ^~~~~~~~~~~~~~~~~~~
const_interop.cpp:40:6: note:   template argument deduction/substitution failed:
const_interop.cpp:54:24: note:   types ‘const T’ and ‘int’ have incompatible cv-qualifiers
   54 |   butNotWhenTemplated(i);
      |                        ^

根本错误似乎是：

类型“const T”和“int”具有不兼容的 cv 限定符

我理解字面意义上的意思，但我不明白为什么会这样。我的期望是在调用butNotWhenTemplated(i) 时应用item<int> :: operator item<const int> () const 转换运算符，就像在调用conversionToConstRefWorks(i) 时应用它一样，并且int 将被选择用于T。

我的主要问题是：为什么不编译？

我的另一个问题是：由于本文范围之外的原因，butNotWhenTemplated 必须是一个模板，并且必须为所有item 参数指定<const T>，并且我不能在调用时显式指定模板参数它。有没有办法在这些限制条件下完成这项工作？

Here it is on ideone (GCC 8.3)。

Answer 1

item<int> i;
template <typename T> void butNotWhenTemplated (const item<const T> &) { }
butNotWhenTemplated(i); 

根据template argument substitution 规则，找不到T 与item<const T> 匹配item<int>。在考虑任何转换（内置或用户定义）之前，这会以硬错误方式失败。

类型推导不考虑隐式转换（除了上面列出的类型调整）：这是重载解析的工作，稍后会发生。但是，如果参与模板实参推导的所有参数推导成功，并且所有未推导的模板实参都被显式指定或默认，则剩余的函数参数将与相应的函数实参进行比较。

Answer 2

试试这个重载：

template <typename T>
void butNotWhenTemplated(const item<const T>&) { }

template <typename T>
void butNotWhenTemplated(const item<T>& x) {
    butNotWhenTemplated<const T>(x);
}

附录：

您试图通过引用传递给 const，但隐式转换会创建对象的副本，即使在非模板情况下也是如此。您可能想在这里重新考虑您的设计。