c++ - 在 switch 语句的条件下同时具有模板和非模板转换运算符的类

Question

问题最初出现在this question .考虑以下代码:

class Var
{
public:

    operator int () const
    { return 0; }

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

};

int main()
{
    Var v;
    switch (v)
    { }
}

没有 operator int() const { return 0; }，g++ 和 clang reject代码。

然而，上面的代码，使用operator int()，是accepted by clang 但是rejected通过 g++ 并出现以下错误:

main.cpp:17:14: error: default type conversion can't deduce template argument for 'template<class T> Var::operator T() const'
     switch (v)
              ^

哪个编译器是正确的？

Answer 1

我相信 clang 在这里是正确的。

从draft C++ standard可以看出6.4.2 switch 语句，这涉及上下文隐式转换。第 2 段说(*强调我的 future ):

The condition shall be of integral type, enumeration type, or class type. If of class type, the condition is contextually implicitly converted (Clause 4) to an integral or enumeration type.

我们可以看到我们需要使用的部分是 4 Standard conversions 段落 5 涵盖了这些情况，它说:

Certain language constructs require conversion to a value having one of a specified set of types appropriate to the construct. An expression e of class type E appearing in such a context is said to be contextually implicitly converted to a specified type T and is well-formed if and only if e can be implicitly converted to a type T that is determined as follows: E is searched for conversion functions whose return type is cv T or reference to cv T such that T is allowed by the context. There shall be exactly one such T.

这没有引用 8.5 节，它通过特别引用 13.3 节来允许重载解析，而不允许我们不能使用的重载解析:

template <typename T>
operator T () const

因此没有歧义。

请注意，这与 4 段不同，后者涵盖了 if、while 等上下文中的bool 转换。 .. 并说(强调我的):

Certain language constructs require that an expression be converted to a Boolean value. An expression e appearing in such a context is said to be contextually converted to bool and is well-formed if and only if the declaration bool t(e); is well-formed, for some invented temporary variable t (8.5).

它特别允许重载解析并直接引用涵盖此内容的 13.3 部分。这是允许的，因为我们有一个特定的目标类型 bool 可以转换为我们在 switch 情况下没有的目标类型。

为什么

我们可以通过查看 N3323: A Proposal to Tweak Certain C++ Contextual Conversions, v3 来解决这个问题它涵盖了这个问题。很难引用整篇论文，所以我会尝试引用足够多的上下文。它说:

The context in which a C++ expression appears often influences how the expression is evaluated, and therefore may impose requirements on the expression to ensure such evaluation is possible. [...]

In four cases, the FDIS (N3290) uses different language to specify an analogous contextdependent conversion. In those four contexts, when an operand is of class type, that type must have a “single non-explicit conversion function” to a suitable (context-specific) type. [...]

并包括:

[stmt.switch]/2: “The condition shall be of integral type, enumeration type, or of a class type for which a single non-explicit conversion function to integral or enumeration type exists (12.3).”

并说:

The principal issue, in each of the four contexts cited in the Introduction, seems to lie in their common helpful but very strict requirement that limits a class to only one conversion operator [...]

Another concern is the scope of the qualifier “single” in the current wording. Must there be but a single conversion function in the class, or may there be several so long as a single one is appropriate to the context?

The current language seems unclear on this point. It is also unclear whether a conversion operator that produces a reference to an appropriate type is an appropriate conversion operator. (A question on this point was posted to the Core reflector on 2011-02-21, but has gone unanswered as of this writing.) Current compiler practice seems to admit such operators, but the current language seems not to.

并提议:

To address all these concerns, we recommend instead to use the proven approach typified by the term contextually converted to bool as defined in [conv]/3. We therefore propose a modest addition to [conv]/3 to define contextual conversion to other specified types, and then appeal to this new definition.

新语言如下；

Certain other language constructs require similar conversion, but to a value having one of a specified set of types appropriate to the construct. An expression e of class type E appearing in such a context is said to be contextually implicitly converted to a specified type T and is well-formed if and only if e can be implicitly converted to a type T that is determined as follows: E is searched for conversion functions whose return type is cv T or reference to cv T such that T is allowed by the context. There shall be exactly one such T.

备注N3486: C++ Editor's Report, October 2012向我们展示 N3323 何时被纳入标准草案。

更新

提交了 gcc bug report .