implicit conversion from class to enumeration type in switch conditional

Question

g++ 4.9.0 accepts the following code:

enum E { foo };

struct C {
  operator E() const { return foo; }
  operator E() { return foo; }
};

int main() {
  C c;
  switch (c) {
    case foo: break;
  }
}

But clang 3.4.1 rejects it with the following diagnostic:

12 : error: multiple conversions from switch condition type 'C' to an integral or enumeration type
switch (c)
^ ~
5 : note: conversion to enumeration type 'E'
operator E() const { return foo; }
^
6 : note: conversion to enumeration type 'E'
operator E() { return foo; }
^

Which one is correct? Is it a clang bug, g++ bug, libstdc++ bug, standard defect, or other? Did I do something stupid?

In the code which triggered this question, C is std::atomic<E>, and std::atomic<T>::operator T is overloaded on the cv-qualifiers const and const volatile.

Both compilers accept E e = c;, so it seems to be something peculiar to the switch statement.

Related to [this](http://stackoverflow.com/q/25047109/1708801) — Shafik Yaghmour, Aug 05 '14 at 16:30
As dyp had noted earlier(*the comment is now gone*) the crux of the problem lies whether contextual implicit conversions are part of C++11 which is why this is related to [Classes with both template and non-template conversion operators in the condition of switch statement](http://stackoverflow.com/questions/25047109/classes-with-both-template-and-non-template-conversion-operators-in-the-conditio/25048219#25048219) which I mentioned as being related, even though the specific issue is different. — Shafik Yaghmour, Aug 07 '14 at 21:46

ecatmur · Accepted Answer · 2014-08-05T20:26:38.413

This is a difference between C++11 and C++14; clang correctly accepts it in C++14 mode (-std=c++1y) and rejects it in C++11 mode (-std=c++11), while gcc is incorrect to accept it in C++11 mode.

The behavior of switch statements was changed by paper n3323, which landed after the C++11 standard was finalized.

[stmt.switch], in C++11:

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). [...]

In n3936 (wording per n3323):

2 - 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.

Contextual implicit conversion is a variant of implicit conversion (i.e. the declaration T t = e is required to be well-formed); for contextual implicit conversion to be well-formed the class type E is allowed to have multiple conversion functions, but all those valid in the context must have the same return type modulo cv and reference qualification: [conv]

5 - [...] 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.

In a switch statement, contextual implicit conversion is to an integral or enumeration type, so C must have at least one non-explicit conversion function to cv integral or enumeration type or reference to cv integral or enumeration type, and all its conversion functions to cv integral or enumeration type or reference to cv integral or enumeration type must have that same underlying type.

A pretty nice workaround (as mentioned in n3323) is to use unary plus to coerce the argument of the switch statement to arithmetic type:

  switch (+c) {
    // ...

So does it fail in C++11 mode because there's more than one conversion? — David G, Aug 05 '14 at 17:29
@0x499602D2 yes, that's right; in C++14 it is OK because although there are two conversions they are to the same *type*, modulo *cv* and reference. — ecatmur, Aug 05 '14 at 17:33

score 5 · Answer 2 · edited May 23 '17 at 11:53

I believe clang is correct here, depending on which version of the standard is being used. I usually use N3485 as a C++11 after fixes reference but it could be argued that the change that I noted in Classes with both template and non-template conversion operators in the condition of switch statement are an addition and thus are actually part of C++1y.

So going with the contention that contextually implicit conversions is a addition then clang is correct for the draft C++11 standard. Due to section 6.4.2 The switch statement which says (emphasis mine going forward):

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).[...]

In C++1y then this should be acceptable code and running this in C++1y mode in clang seems to confirm this is indeed the case (see it live).

We can see from the draft C++1y standard section 6.4.2 The switch statement that this involves a contextually implicit conversion. Paragraph 2 says:

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.

We can see the section we need to use is 4 Standard conversions and paragraph 5 covers these cases, it says:

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.

implicit conversion from class to enumeration type in switch conditional

2 Answers2

Linked