Because an object of enum
type may be initialized only by another object of that enum
type or by one of its enumerators (§ 19.3, p. 833), an integral value that happens to have the same value as an enumerator cannot be used to call a function expecting an enum
argument:
// unscoped enumeration; the underlying type is machine dependent
enum Tokens {INLINE = 128, VIRTUAL = 129};
void ff(Tokens);
void ff(int);
int main() {
Tokens curTok = INLINE;
ff(128); // exactly matches ff(int)
ff(INLINE); // exactly matches ff(Tokens)
ff(curTok); // exactly matches ff(Tokens)
return 0;
}
Although we cannot pass an integral value to an enum
parameter, we can pass an object or enumerator of an unscoped enumeration to a parameter of integral type. When we do so, the enum
value promotes to int
or to a larger integral type. The actual promotion type depends on the underlying type of the enumeration:
void newf(unsigned char);
void newf(int);
unsigned char uc = VIRTUAL;
newf(VIRTUAL); // calls newf(int)
newf(uc); // calls newf(unsigned char)
The enum Tokens
has only two enumerators, the larger of which has the value 129
. That value can be represented by the type unsigned char
, and many compilers will use unsigned char
as the underlying type for Tokens
. Regardless of its underlying type, objects and the enumerators of Tokens
are promoted to int
. Enumerators and values of an enum
type are not promoted to unsigned char
, even if the values of the enumerators would fit.