我无法理解C ++标准中转换函数模板参数推导规则的含义。 该标准规定（[temp.deduct.conv]第1节，N4594中的第14.8.2.3.1节）： 
 
 
 
 通过将转换函数模板（称为P）的返回类型与作为转换结果所需的类型（称为A;参见8.5,13.3.1.5和13.3.1.6确定该类型）如14.8.2.5所述。 
 
 
 其中14.8.2.5（[temp.deduct.type]）是描述通用模板参数演绎的部分（尽管最常见的情况是函数调用模板参数演绎[temp.deduct.call]）似乎不再指向那里;它曾经？）。 然而，下一个条款让我感到困惑（第2条）： 
 
 
 
 如果P是一个引用类型，则用P引用的类型代替P，用于类型推导以及本节其余部分对P的进一步引用或转换。 
 
 
 对我来说，这似乎意味着template <class T> operator T()和template <class T> operator T&()是相同的（并且指定两者都会导致不明确性）。 但是在我使用过的任何编译器中情况并非如此！ 例如： 
 
struct any1 { template <typename T> operator T() { } };

struct any2 { template <typename T> operator T&() { } };

void f1(int) { }
void f2(int&) { }
void f3(int const&) { }

int main() {
  f1(any1());
  // f2(any1()); compile time error
  f3(any1());

  f1(any2());
  f2(any2());
  f3(any2());
}
 
 现场演示 
 
 但如果引用被忽略， any1和any2应该有相同的行为，对吧？ 显然他们不这样做，因为f2(any1())不能用gcc或clang编译，而f2(any2())可以同时编译。 
 
 接下来的条款（第3条，特别是3.3）进一步混淆了事情： 
 
 
 
 如果A不是引用类型：[...]如果P是一个cv限定类型，则P类型的顶级cv限定符在类型推导中将被忽略。 
 
 
 这与关于删除引用的第2条一起似乎暗示下面的代码不应该被编译，因为含糊不清： 
 
struct any3 {
  template <typename T> operator T&() { }
  template <typename T> operator T const&() { }
};

void f1(int) { }

int main() {
  f1(any3());
}
 
 现场演示 
 
 然而，这对gcc和clang都可以正常工作。 
 
 我错过了什么？ 
 
 编辑 
 
 我应该澄清一下，clang和gcc编译器处理这个问题的方式正是我对C ++的一般（相对高级的）理解所期待的。 一些评论者要求澄清我的困惑是什么（并且暗示，为什么我应该关心）。 我的困惑与试图理解标准的含义完全相关。 我需要清楚地了解这一点，因为我正在提交一份代码，这些代码严重依赖这项工作，并且使用它符合标准。 

I'm having trouble understanding the implications of the conversion function template argument deduction rules in the C++ standard. The standard states that ([temp.deduct.conv] clause 1, §14.8.2.3.1 in N4594):
 
 
 
Template argument deduction is done by comparing the return type of the conversion function template (call it P) with the type that is required as the result of the conversion (call it A; see 8.5, 13.3.1.5, and 13.3.1.6 for the determination of that type) as described in 14.8.2.5.
 
 
where 14.8.2.5 ([temp.deduct.type]) is the section that describes general template argument deduction (though the most common case, function call template argument deduction [temp.deduct.call], no longer seems to point there; did it ever?). The next clause is what confuses me, though (clause 2):
 
 
 
If P is a reference type, the type referred to by P is used in place of P for type deduction and for any further references to or transformations of P in the remainder of this section.
 
 
To me, this seems to imply that template <class T> operator T() and template <class T> operator T&() are the same (and specifying both would result in an ambiguity). But that isn't the case in any compiler I've used! For instance:
 
struct any1 { template <typename T> operator T() { } };

struct any2 { template <typename T> operator T&() { } };

void f1(int) { }
void f2(int&) { }
void f3(int const&) { }

int main() {
  f1(any1());
  // f2(any1()); compile time error
  f3(any1());

  f1(any2());
  f2(any2());
  f3(any2());
}
 
Live Demo
 
But if references are ignored, any1 and any2 should have the same behavior, right? Clearly they don't, since f2(any1()) doesn't compile with either gcc or clang, while f2(any2()) compiles fine with both.
 
The next clause (clause 3, particularly 3.3) confuses things even further:
 
 
 
If A is not a reference type: [...] If P is a cv-qualified type, the top level cv-qualifiers of P’s type are ignored for type deduction.
 
 
This, along with clause 2 about the removal of references, would seem to imply that the following code should not compile because of an ambiguity:
 
struct any3 {
  template <typename T> operator T&() { }
  template <typename T> operator T const&() { }
};

void f1(int) { }

int main() {
  f1(any3());
}
 
Live Demo
 
And yet this works fine with both gcc and clang.
 
What am I missing?
 
Edit
 
I should clarify that the way the clang and gcc compilers handle this is exactly what I would expect from a general (relatively advanced) understanding of C++. Some commenters have asked for clarification on what my confusion is (and, implicitly, why I should care). My confusion here is entirely related to trying to understand the implications of the standard. I need a clear understanding of this because I am submitting a paper with code that relies heavily on this working and on my use of it being standards-compliant.

原文：https://stackoverflow.com/questions/39150553