static_cast vs reinterpert_cas t

[Rahul]

Hi,

I have a
class A : public B {...member functions...... data members};

and am doing the following
A *p=new A();
void *p=static_cast< void *>(p);
factory_instanc e->process(p);

Here p is passed to a function, which accepts void ptr. That function
need to cast it back
A *pp=static_cast <A *>(p);

The function is in the factory which accepts void *p only, the specific
implementations need to cast the pointer back to the expected class
and use it.

Question:Though both works fine, yet I want to know what is more
appropriate in this situation static_cast OR reinterpert_cas t

The books suggests
static_cast= "For "well-behaved" and "reasonably
well-behaved" casts,including things you might now do without a cast
reinterpret_cas t=To cast to a completely different meaning. The key
is that you'll need to cast back to the original type to use it
safely.

But I am not able to interpret the sentences in this context :-)

[Rolf Magnus]

Frederick Gotham wrote:

Rolf Magnus posted:

>size_t is unsigned and can't have negative values. size_t(-1) tells the
compiler that you want -1 converted to size_t, IOW, it's a cast.

There's an implicit conversion from int to size_t, so no cast is required.

Well, it's there, no matter if it's required or not.

When dealing with intrinsic types, the following are exactly equivalent:

short(5)

(short)5

Yes. Both are casts.

I myself prefer the latter, for two reasons:

(1) You can have types which consist of more than one word, e.g.
"unsigned short".

That's a good point.

(2) It resembles a cast.

Well, it is a cast, just like the first one.

I dislike the former because:

(1) It looks like the construction of a user-defined class type.

That's one reason why I like it. It uses built-in types more consistently
with classes by using the same syntax.
Btw: What do you do in a template, where the type might be either one?

(2) It doesn't resemble a cast at all.

Well, if you are used to the latter, because you know it from C, then you
might think like that. But basically, none of the two looks more "castish"
than the other.

(3) You can't use types which consist of more than one word.

Yes, that's a restriction that will hopefully be fixed some time.
One thing I like about it is that the value is in parenthesis, so in a
longer exression, it's easier to see which part of it is cast.

[Richard Herring]

In message <xQ************ *******@news.in digo.ie>, Frederick Gotham
<fg*******@SPAM .comwrites

>Richard Herring posted:

>> for(size_t i = len - 1; size_t(-1) != i; --i)

I'd lose the -1 altogether ;-)

for (size_t i = len; i-- != 0; )

Yes but this has re-arranged the natural order of the loop.

I like my "for" loops to have four phases:

(1) The "initialisa tion stuff" is executed first of all.

(2) The condition is tested.

(3) The body is executed.

(4) The "prepare for next iteration" stuff is executed.
Your example mixes (2) and (4), which I don't like.

It puts (4) before (3), that's all. It's just another idiom, and a very
clear one once you're used to it. The only numbers that appear in it are
0 and len, exactly the same as for the forward loop. Other solutions all
require an off-by-one representation of the index and either mix signed
and unsigned, as with the cast above, or do something even more
contorted.

--
Richard Herring

[Frederick Gotham]

Richard Herring posted:

>>Your example mixes (2) and (4), which I don't like.

It puts (4) before (3), that's all. It's just another idiom, and a very
clear one once you're used to it. The only numbers that appear in it are
0 and len, exactly the same as for the forward loop. Other solutions all
require an off-by-one representation of the index and either mix signed
and unsigned, as with the cast above, or do something even more
contorted.

Let's put it down to a difference in taste : ).
--

Frederick Gotham

[Ron Natalie]

Jim Langston wrote:

"Ron Natalie" <ro*@spamcop.ne twrote in message
news:44******** *************** @news.newshosti ng.com...

>Rolf Magnus wrote:

>>I tend to use constructor-style casts in such a situation:

for(size_t i = len - 1; size_t(-1) != i; --i)

But I think that's just because C style casts look so old-style to me
now ;-)

But a single arg function-style cast is identical in meaning to the
C-style cast. You're back to it possibly meaning static, const,
reinterpret or combinations of the above (as well as busting access
control which there is no C++-style equivelent to).

Actually, not at all. size_t(-1) tells me exactly what is going on. This
is a size_t variable that is being initialized to -1. There is no ambiguity
at all. It is not techinically a cast, I don't think.

It's is exactly the same as the c-style cast.
The definition of the "explicit type conversion (functional notation)"
says:

If the expression list is a single expression, the type conversion
expression is equivalent (in definedness, and if defined in meaning) to
the corresponding cast expression (5.4).

[Ron Natalie]

Frederick Gotham wrote:

When dealing with intrinsic types, the following are exactly equivalent:

short(5)

(short)5

They are exactly equivelent no matter WHAT type is being used.

>