Re: Which casting conversion to use for void*?
On May 9, 9:21 am, Noah Roberts <d...@email.me> wrote:
On 5/8/2011 11:31 PM, Qi wrote:
On 2011-5-9 6:44, Nephi Immortal wrote:
Which should I use correct casting conversion after I create void
variables?
For example:
void *memory = malloc( 0x1000 );
char *pString = static_cast< char*>( memory );
or
char *pString = reinterpret_cast< char*>( memory );
After I deallocate the memory, I will convert from char* back to
void* prior free( void* ) function.
*static_cast* until compiler complains. Then use reinterpret_cast.
static_cast is type safe cast, reinterpret_cast not.
I can't say I recommend this procedure. It can easily lead people to
cast when they don't have to. For example, I found code like this in a
project I worked on:
// whatnot.h
struct A
struct B
struct whatnot
{
A* a;
void fun(B* b) { a = (B*)b; }
};
// B.h
#include "A.h"
struct B : A {....};
Of course, it's quite silly to do an upcast like this. It's even worse
to do a C-style cast. What's even worse than that about it is that thi=
s
particular cast will be a reinterpret_cast.
The reason of course that it was done is almost certainly that the
compiler complained about unrelated types and recommended a reinterpret
or C-style cast (the MS compiler does this). A more appropriate
solution of course is to include the appropriate headers and/or move the
body of f() into a cpp file.
So, it's not really a well recommended practice in my opinion to plug in
reinterpret_cast when the compiler starts to bitch. This cast should
really be reserved for very special cases and, in fact, with almost all
modern C++ it's completely unnecessary.
I thank you for that example, which is quite similar to the one that I
like to use.
However, let me possibly take a slightly different stance though. In C+
+ code, you should never use the C-style cast for casting with class
types. In all cases, the C-style cast is equivalent to either a
static_cast or a reinterpret_cast, and as you have pointed out, it can
be quite "ambiguous", or hard to tell for a human reader, which it is
when working with class types. It's error prone. That's why I suggest
writing what you mean and write either the static_cast or the
reinterpret_cast.
Having said that, reinterpret_cast is almost never needed, so I don't
"like" when I see it. However, sometimes you do need it, and I much
prefer to see a reinterpret_cast over a C-style which is in effect
doing a reinterpret_cast on class types.