Re: Which casting conversion to use for void*?
On 5/9/2011 11:34 AM, Joshua Maurice wrote:
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 this
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
This is not actually true. There are certain, very rare conditions in
which a C-style cast does not match any of the available new-style casts
and is absolutely necessary for the specific cast needed. Correctly
casting to a protected/private base class for example; although it's
extremely rare that you'd want to do this, when you do a C-style cast is
necessary.
, 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.
Although my example uses a C-Style cast, it would fall afoul of error
when applying Qi's rule, "use static_cast until the compiler complains,
then use reinterpret_cast." The author of the code in question probably
thought they where doing a static cast, and it's only because a static
cast would not work there that a reinterpret cast is the actual result.
--
http://crazycpp.wordpress.com