reinterpret_cast and enumerations

[Christopher Benson-Manica]

enum foo {a,b,c,d};

int main()
{
unsigned int bar=reinterpret_cast< unsigned int >( a );
return bar;
}

g++ rejects the code based on the reinterpret_cast, so I presume it is
not legal. Why not? And why should g++ accept the code when
static_cast is used instead (as it does)?

--
Christopher Benson-Manica | I *should* know what I'm talking about - if I
ataru(at)cyberspace.org | don't, I need to know. Flames welcome.

[Victor Bazarov]

Christopher Benson-Manica wrote:

enum foo {a,b,c,d};

int main()
{
unsigned int bar=reinterpret_cast< unsigned int >( a );
return bar;
}

g++ rejects the code based on the reinterpret_cast, so I presume it is
not legal. Why not?
You will have to ask in comp.std.c++. The Standard lists conversions that
are allowed to be performed by reinterpret_cast and all others are not
allowed. Why that is so, is not explained in the Standard, and here, in
comp.lang.c++ the answer to your 'why' question is "because the Standard
says so".
And why should g++ accept the code when
static_cast is used instead (as it does)?

Because static_cast has different set of restrictions and they are not the
same as reinterpret_cast.

V

[Tom Widmer]

On Tue, 2 Nov 2004 17:19:33 +0000 (UTC), Christopher Benson-Manica
<at***@nospam.cyberspace.org> wrote:

enum foo {a,b,c,d};

int main()
{
unsigned int bar=reinterpret_cast< unsigned int >( a );
return bar;
}

g++ rejects the code based on the reinterpret_cast, so I presume it is
not legal. Why not? And why should g++ accept the code when
static_cast is used instead (as it does)?

reinterpret_cast can't perform conversions between integral types,
that's what static_cast is for. The point of the new C++ style casts
is to provide different casts for different jobs.

Tom

[Bob Hairgrove]

On Tue, 2 Nov 2004 17:19:33 +0000 (UTC), Christopher Benson-Manica
<at***@nospam.cyberspace.org> wrote:

enum foo {a,b,c,d};

int main()
{
unsigned int bar=reinterpret_cast< unsigned int >( a );
return bar;
}

g++ rejects the code based on the reinterpret_cast, so I presume it is
not legal. Why not? And why should g++ accept the code when
static_cast is used instead (as it does)?

It is totally unnecessary to cast here since the conversion is done
automatically. Only to avoid comparing signed and unsigned values
should there be a need to cast.

In general, static_cast is used to cast between value types;
reinterpret_cast is usually used for casting unrelated types. Others
have pointed out that the standard defines different rules for the two
kinds of cast.

--
Bob Hairgrove
No**********@Home.com

[Siemel Naran]

"Bob Hairgrove" <in*****@bigfoot.com> wrote in message

In general, static_cast is used to cast between value types;
reinterpret_cast is usually used for casting unrelated types. Others
have pointed out that the standard defines different rules for the two
kinds of cast.

Is it true to say that reinterpret_cast is used to cast between unrelated
pointer/reference types. Whereas static_cast is used to cast between
integer types, between float types, between parent/child pointers.

[Ron Natalie]

Bob Hairgrove wrote:

In general, static_cast is used to cast between value types;
reinterpret_cast is usually used for casting unrelated types. Others
have pointed out that the standard defines different rules for the two
kinds of cast.

My way of describing static_cast is that it supports two functions:
1. Forcing a conversion that could happen anyway:
double d = 4.5;
cout << d - static_cast<int>(d);
the double->int conversion is defined, so I'm just making it happen
explciitly.

2. Inverting a conversion that I am certain is valid.
struct Base { };
struct Derived : Base { };
Derived d;
Base* bp = &d; // defined implicit conversion.
Derived* dp = static_cast<Derived*>(dp); // well-behaved inverse of defined conversion