Quick cast style question

[Christopher Benson-Manica]

If you had an unsigned int that needed to be cast to a const myClass*,
would you use

const myClass* a=reinterpret_c ast<const myClass*>(my_va l);

or

const myClass* a=(const myClass*)myVal;

?

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

[Leor Zolman]

On Fri, 30 Apr 2004 21:05:43 +0000 (UTC), Christopher Benson-Manica
<at***@nospam.c yberspace.org> wrote:

If you had an unsigned int that needed to be cast to a const myClass*,
would you use

const myClass* a=reinterpret_c ast<const myClass*>(my_va l);

or

const myClass* a=(const myClass*)myVal;
Personally, I'd use the reinterpret_cas t, since the compiler will diagnose
attempts to use it in a situation where one of the other new-style casts
would be the right one. So the former is saying "do the cast if in fact we
are truly requiring reinterpret, and the others wouldn't do, else tell me
I've screwed up", while the latter says "just shut up and do it."
-leor
?

--
Leor Zolman --- BD Software --- www.bdsoft.com
On-Site Training in C/C++, Java, Perl and Unix
C++ users: download BD Software's free STL Error Message Decryptor at:
www.bdsoft.com/tools/stlfilt.html

[Karthik]

Christopher Benson-Manica wrote:

If you had an unsigned int that needed to be cast to a const myClass*,
would you use

const myClass* a=reinterpret_c ast<const myClass*>(my_va l);

or

const myClass* a=(const myClass*)myVal;

?

Somehow I am always sceptic with the usage of reinterpret_cas t here.
I would go for static_cast or dynamic_cast , as necessary. Using
reinterpret_cas t is dangerous and would probably tie you to a specific
implementation.

--
Karthik
Humans please 'removeme_' for my real email.

[bartek]

Christopher Benson-Manica <at***@nospam.c yberspace.org> wrote in
news:c6******** **@chessie.cirr .com:

If you had an unsigned int that needed to be cast to a const myClass*,
would you use

const myClass* a=reinterpret_c ast<const myClass*>(my_va l);

or

const myClass* a=(const myClass*)myVal;

C-style casts were provided for compatibility with old code. In C++ you
should only use the 'new'-style casts, as they show your intents clear in
the code. 'reinterpret_ca st' is there to show that something drastic is
going on.

Code editors should highlight it in bloody red... or even flashing bloody
red.

Cheers.
--
:: bartekd [at] o2 [dot] pl

[bartek]

Karthik <re************ *******@yahoo.c om> wrote in news:4092c3bc$1
@darkstar:

Christopher Benson-Manica wrote:

If you had an unsigned int that needed to be cast to a const myClass*,
would you use

const myClass* a=reinterpret_c ast<const myClass*>(my_va l);

or

const myClass* a=(const myClass*)myVal;

?

Somehow I am always sceptic with the usage of reinterpret_cas t here.
I would go for static_cast or dynamic_cast , as necessary. Using
reinterpret_cas t is dangerous and would probably tie you to a specific
implementation.

'reinterpret_ca st' is the only option in that situation. The compiler
would refuse to compile the above code when 'static_cast' was used.
'dynamic_cast', on the other hand, only works for casting
pointers/references within an inheritance hierarchy.

Cheers.
--
:: bartekd [at] o2 [dot] pl

[Leor Zolman]

On Fri, 30 Apr 2004 14:20:39 -0700, Karthik
<re************ *******@yahoo.c om> wrote:

Christopher Benson-Manica wrote:

If you had an unsigned int that needed to be cast to a const myClass*,
would you use

const myClass* a=reinterpret_c ast<const myClass*>(my_va l);

or

const myClass* a=(const myClass*)myVal;

?

Somehow I am always sceptic with the usage of reinterpret_cas t here.
I would go for static_cast or dynamic_cast , as necessary. Using
reinterpret_ca st is dangerous and would probably tie you to a specific
implementation .

You may want to try the different forms and examine the results. In fact,
reinterpret_cas t was the correct choice here (of the different casts. I
can't speak to the appropriateness here of using a cast, versus not using
one, in the first place...)
-leor
--
Leor Zolman --- BD Software --- www.bdsoft.com
On-Site Training in C/C++, Java, Perl and Unix
C++ users: download BD Software's free STL Error Message Decryptor at:
www.bdsoft.com/tools/stlfilt.html

[jeffc]

"Christophe r Benson-Manica" <at***@nospam.c yberspace.org> wrote in message
news:c6******** **@chessie.cirr .com...

If you had an unsigned int that needed to be cast to a const myClass*,
would you use

const myClass* a=reinterpret_c ast<const myClass*>(my_va l);

or

const myClass* a=(const myClass*)myVal;

Prefer the former - it was added to C++ as an improvement over the latter.

[Christopher Benson-Manica]

Leor Zolman <le**@bdsoft.co m> spoke thus:

You may want to try the different forms and examine the results. In fact,
reinterpret_cas t was the correct choice here (of the different casts. I
can't speak to the appropriateness here of using a cast, versus not using
one, in the first place...)

Well, the design decision that makes a cast necessary in the first
place is probably of debatable merit. Given that, the cast is pretty
much required...

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

[Jake Montgomery]

bartek wrote:

Christopher Benson-Manica <at***@nospam.c yberspace.org> wrote in
news:c6******** **@chessie.cirr .com:

If you had an unsigned int that needed to be cast to a const myClass*,
would you use

const myClass* a=reinterpret_c ast<const myClass*>(my_va l);

or

const myClass* a=(const myClass*)myVal;

C-style casts were provided for compatibility with old code. In C++ you
should only use the 'new'-style casts, as they show your intents clear in
the code. 'reinterpret_ca st' is there to show that something drastic is
going on.

Code editors should highlight it in bloody red... or even flashing bloody
red.

I agree when casting classes, but I still like the old style casts when
doing numeric 'type change' cats:

int n1=5;
int n2=3;
double d1 = ((double)n1)/n2;

Where you suggesting a static_cast<> be used here? Personally, I find
that to be a bit much.

[Leor Zolman]

On Sat, 01 May 2004 21:07:13 GMT, Jake Montgomery
<ja************ ******@yahoo.co m> wrote:

I agree when casting classes, but I still like the old style casts when
doing numeric 'type change' cats:

int n1=5;
int n2=3;
double d1 = ((double)n1)/n2;

Where you suggesting a static_cast<> be used here? Personally, I find
that to be a bit much.
Well, if you don't like the new_style cast for aesthetic reasons, or if you
specifically don't want to be warned when the cast isn't doing what you
think it is supposed to do (a benefit of using new-style casts), then
consider this: You have a large app and you wish to locate all the places
you've performed a cast. Tell us how to do it, for certain, with your
old-style casting used all over the place, vs. new-style casts.

Note: assume the coders have been very sloppy with style, writing (type), (
type), ( type ), etc.; don't forget that sizeof(type) will be an imposter.

Note #2: Hope you have a tool supporting good regular expression syntax if
you want to be exhaustive with this ;-)
-leor

--
Leor Zolman --- BD Software --- www.bdsoft.com
On-Site Training in C/C++, Java, Perl and Unix
C++ users: download BD Software's free STL Error Message Decryptor at:
www.bdsoft.com/tools/stlfilt.html