enum types and casting
Hello. Just now I learnt that enums can be very usefully used as types, and was experimenting some with it. The following questions arose.
1. Are enums allowed as types only in C++ and not in C? gcc rejects using an enum as a type whereas g++ accepts it.
2.
Consider:
enum BODY { SUN, MOON, STAR } ;
enum PLANET { EARTH, VENUS, MARS, PLUTO } ;
int main ( void )
{
BODY body ;
// body = 1 ; // gives error
// body = EARTH ; // gives error
body = (BODY) 1 ; // does not give error. expected.
body = (BODY) EARTH ; // does not give error. expected.
body = 3 ; // does not give error. unexpected.
body = (BODY) PLUTO ; // does not give error. unexpected.
}
When the target enum of the cast contains no name that has the same integer value as the value being casted, how does g++ accept the cast? Is this expected behaviour or a bug?
Thanks as always.
Shriramana Sharma.
P.S: Oops, silly me, Pluto isn't a planet any more...
Quoted 1 line · Shriramana Sharma
1. Are enums allowed as types only in C++ and not in C?
They are part of ANSI C.
Quoted 1 line
gcc rejects using an enum as a type whereas g++ accepts it.
Not really. You need to say "enum BODY body".
Quoted 3 lines
When the target enum of the cast contains no name that has the same integer value as the value being casted, how does g++ accept the cast? Is this expected behaviour or a bug?
You are doing C style casts here, which you shouldn't. The compiler will warn you at best, but in the end he will handle everything as raw bytes.
Leslie
Signature · 2 lines
Personal homepage: https://viridian.dnsalias.net/~sky/homepage/ gpg --keyserver pgp.mit.edu --recv-keys DD4EBF83
Quoted 5 lines · Shriramana Sharma
Hello. Just now I learnt that enums can be very usefully used as types, and was experimenting some with it. The following questions arose.
1. Are enums allowed as types only in C++ and not in C? gcc rejects using an enum as a type whereas g++ accepts it.
As Leslie pointed out, you will have to declare variables of type enumwith the enum keyword.
Quoted 18 lines
2.
Consider:
enum BODY { SUN, MOON, STAR } ;
enum PLANET { EARTH, VENUS, MARS, PLUTO } ;int main ( void )
{
BODY body ;
// body = 1 ; // gives error
// body = EARTH ; // gives error
body = (BODY) 1 ; // does not give error. expected.
body = (BODY) EARTH ; // does not give error. expected.
body = 3 ; // does not give error. unexpected.
body = (BODY) PLUTO ; // does not give error. unexpected.
}
Quoted 3 lines
When the target enum of the cast contains no name that has the same integer value as the value being casted, how does g++ accept the cast? Is this expected behaviour or a bug?
From the historical perspective, enums are implicitly converted to an integral value whenever needed. And there __always__ is an integral value to represent any enum value. That's why assignments of integers to variables of type enum are perfectly legal. So, for example, when you compare two enum values, they are both converted to an integer.
However, assignment of an int to an enum variable leads to undefined behavior if the enum is not large enough to store the integral value. So, allowing the assignment of any integer, without casting, to a variable of enum type, would be worse than the opposite.
To convert an integral type to an enumeration, use the following semantic:
enum TEST { zero = 0, one, two };
int i1 = 2;
test t1 = static_cast<TEST> (i1); // t1 == two
The same is true for casts between different enum types.
\Steve
--
Steve Grägert <[email protected]>
Jabber xmpp://[email protected]
-
To unsubscribe from this list: send the line "unsubscribe linux-c-programming" in the body of a message to [email protected]
More majordomo info at http://vger.kernel.org/majordomo-info.html
Quoted 5 lines · Steve Graegert
To convert an integral type to an enumeration, use the following semantic:
enum TEST { zero = 0, one, two };
int i1 = 2;
test t1 = static_cast<TEST> (i1); // t1 == two
Steve,
I tried this as follows:
enum BODY { SUN, MOON, STAR } ;
enum PLANET { EARTH, VENUS, MARS, PLUTO } ;
int main ( void )
{
BODY body ;
body = static_cast < BODY > ( 3 ) ; // does not give error. body = static_cast < BODY > ( PLUTO ) ; // does not give error.
}
but it still does not throw an error even though the enum being casted *to* does not contain an identifier equivalent to the value actually being casted, whether a primitive integer or an identifier belonging to another enum.
Don't you think this is a GCC bug?
Shriramana.