Casting Basics - Use C++ casts in your VC++.NET programs

Demonstrates and compares the various casting operators available. Also suggests when to use and what to use!

Prologue

If someone were to ask me to name the single most exciting feature of C++,
I'd reply saying that it was the ability to perform casts from one type to
another. Of course this is purely a whimsical and highly irrational love I have
for casts and is not a reflection of any great technical pondering I might have
committed on casts and their usefulness. I mentally squeal with delight every
time I see code that looks something similar to ((CNishApp*)AfxGetApp())->CustomFunc()
or (LPSTR)(LPCTSTR)m_str. This was all quite well when I was using VC++ 6 but
when I started moving some of my old applications to VC++.NET, it was a little
disconcerting to see all those compiler warnings about how my C style casts were
now deprecated.

That's when I took a look at the new C++ casting operators that were
available and quickly discovered that, they were a much safer and smarter way
for doing casts. This article will run through the various casting operators
that are available and will suggest when and where you might want to use each of
these casting operators. The entire article has been written from a managed
extensions context and therefore I only discuss managed classes in this article.
This has some interesting corollaries which I mention later in the article.

Dangers of C-style casts

The single biggest problem with C-style casts is that they are absolutely and
totally unsafe. No compile time or run time checks are made and you are left
with full freedom to dig your own grave, as deep as you want to. There is
nothing to stop you from casting a base class pointer that points to a base
class object to a derived class pointer, which means that when you make your
derived class method calls, catastrophe results most assuredly.

Another problem is that you never know what kind of cast you are trying to
achieve. All casts you can do look the same as far as syntax goes. Obviously
this can be a pain in the neck when you are debugging. In addition some people
use the functional style casts where they do int(x) instead of
(int)x and this results in further obfuscation of the code, because
C/C++ code is just about always sprinkled with functions and their accompanying
brackets.

The C++ casting operators

There are five casting operators provided which serve to replace the old
C-style casts. Each has a specific purpose and intended usage which I explain
later down the article. Before that I'd like to touch on the subject of
polymorphic classes. Any class that has virtual functions is a polymorphic
class. Now this marks a major distinction among classes in the old unmanaged
world. But in the new managed world of C++ coding, every class is polymorphic,
because all managed classes derive implicitly from System::Object
which has virtual methods of its own. Thus this renders every __gc
class as a polymorphic class. This allows us to exclusively use the safer dynamic_cast instead of static_cast just about
everywhere, which was not possible in unmanaged C++.

static_cast

dynamic_cast

const_cast

reinterpret_cast

__try_cast(managed extensions only)

static_cast

The static_cast operator relies only on compile time
information. Run time checks are not done to ensure a safe cast. You can do both
downcasts and upcasts using static_cast, but there are
dangers involved which I demonstrate later down the article. The syntax
for using the static_cast operator is shown below :-

T t = static_cast<T>(expression);

An example usage would be something like :-

CMainFrame* pMF = static_cast<CMainFrame*>(AfxGetMainWnd());

dynamic_cast

The dynamic_cast operator relies both on compile time
and run time information. When you attempt to do a cast using the dynamic_cast operator, a run time check is made to see if this is a safe
cast, and if the cast is unsafe then this the cast returns NULL.
Thus by checking for NULL, we can determine whether the
cast attempt was successful or not. The syntax is :-

const_cast

The const_cast operator is used to remove the
const, volatile, and
__unaligned attributes) from a class.
__unaligned is a Microsoft extension to C++ and I am not quite sure of
what it's purpose is. You can use const_cast only to cast between types that
differ only in their const-ness or volatility. The syntax for use is similar to
the other casts :-

reinterpret_cast

To be really honest I have no clue why they have this one because as far as I
see it, its just as bad as the old C style casts except that it advertises it's
lack of safety quite explicitly. You can use the reinterpret_cast operator to convert from one type to any other type.
It's syntax is :-

T t = reinterpret_cast<T>(expression);

Basically the only safe place to use it would be where we cast from Type-1 to
Type-2 and later we cast back Type-2 to Type-1. Now we have the exact object
back as when we started this reinterpret_cast business.

__try_cast

__try_cast is a managed extension keyword not
available in unmanaged C++. It's essentially similar to dynamic_cast except that it throws an exception on failure whereas
dynamic_cast returns NULL. The
syntax is :-

T t = __try_cast<T>(expression);

The exception that gets thrown is
System::InvalidCastException and you better use a try-catch
block if you are using __try_cast unless you want to
see your program break in between, though that might actually be a good thing
when you are still developing it. A sample use is shown below :-

When to use and what?

Well, we've seen 5 different casting operators and they are supposed to be
replacements for the old C-style casts. It might be a little baffling to choose
the correct cast operator when you are coding. To be really honest, till
recently I had no clue when to use what! Anyway I have created certain imaginary
casting scenarios and used each of the cast operators to try and do the casts
[where permitted by the compiler] and I have made an attempt to demonstrate when
and why some cast operators are not suitable and when they are suitable. Of
course the recommendations are strictly my own and I do not claim that they
might be the most suitable options, but then I intend to keep updating the
article with valuable input from C++ gurus who happen to come across this
article.

Test classes

These are the test classes and enums that I have used in my experiments.

Downcasting

Downcasting is when you convert from a base class pointer to a derived class
pointer. I have written a function called
BaseToChild which does various kinds of downcasting based on the
CastType enumeration parameter passed to it. Obviously I cannot use const_cast here because we are casting across unlike types.

Unsafe downcasting

Base *pBase1 = new Base();
Child *pChild1 = NULL;

I have
pBase1 which holds a
Base object and I am now going to attempt to downcast it to a
Child object. Obviously this is unsafe and something which I really
shouldn't be doing. I called
BaseToChild four times, once for each type of cast (const_cast
not usable here).

I only show the sample code for dynamic_cast, but the code for the other three casts are very much
similar. I summarize my results in the table below.

Cast

Result

Notes

dynamic_cast

Failure

Fails and returns
NULL

static_cast

Success

Unsafe cast made

reinterpret_cast

Success

Unsafe cast made

__try_cast

Failure

Fails and throws an exception

Safe downcasting

Base *pBase1 = new Child();
Child *pChild1 = NULL;

Alright now we have the Base object holding a Child object. Now it's
perfectly safe to downcast to the derived class. Again I called
BaseToChild four times, once for each type of cast except const_cast. The table below shows the results I got.

Cast

Result

Notes

dynamic_cast

Success

Safe cast

static_cast

Success

Safe cast

reinterpret_cast

Success

Safe cast

__try_cast

Success

Safe cast

Recommendation for downcasting

If you are absolutely sure that the cast is going to be safe, you can use any
of the four cast operators above, but I'd suggest that you use static_cast because that'd be the most efficient way of casting. If you
are even a microscopic percentage unsure as to the safety of your cast, you must
simply *avoid* static_cast and reinterpret_cast both of which are quite dangerous here. You may use
either dynamic_cast or __try_cast depending on whether you like to check for
NULL or you like to have an exception raised and handled.

Upcasting

Upcasting is when you cast from a derived class to one of the parent classes
in the inheritance chain. Usually upcasting is pretty much safe except in
certain rare situations that are actually a result of bad coding rather than
anything else. I demonstrate both scenarios below. Just like I had a function
for downcasting, I also have one for upcasting called
ChildToBase. Just as previously, I cannot use const_cast here because we are casting across unlike types.

Unsafe upcasting

Here I have intentionally created a
Base2 object and cast it to a
Child object using reinterpret_cast. This is a totally unsafe cast, but I have done this to
demonstrate what happens when you do an unsafe upcast. I show my results in the
table below :-

Cast

Result

Notes

dynamic_cast

Failure

Fails and returns
NULL

static_cast

Success

Unsafe cast made

reinterpret_cast

Success

Unsafe cast made

__try_cast

Failure

Fails and throws an exception

Recommendations for upcasting

In most situations upcasting should be quite safe except when you have a bad
derived class pointer (bad in the sense that it points to the wrong object).
Therefore my recommendation for upcasting is to use static_cast which should be the most efficient. If your upcasts are
unsafe it's probably time for you to sit down and figure out what's going wrong
in your code rather than using dynamic_cast or __try_cast. In addition keep in kind that upcasting would probably be
implicitly done in most situations.

const_cast usage

Consider the code below :-

const Base *pB = new Base();
/* won't compile */
pB->dummy = 100;

You'll get a compiler error, because you are trying to modify a const object. Using const_cast, you can quickly overcome this problematic situation.

const_cast<Base*>(pB)->dummy = 100;
/* should show 100 on the console */
Console::WriteLine(pB->dummy);

Another useful application of const_cast comes in const member functions.
When you mark a class member as const, you are telling the compiler that this
function is a read-only function that will not modify the object. This means
your this pointer is now a const Class * const instead of just
Class * const. Now suppose that for some reason you want to modify some
member from this member function. You can use const_cast as shown below. Of course you might also want to rethink your
design if you are having to un-const all your const member functions.

void A::abc() const
{
const_cast<A* const>(this)->m_total++;
}

reinterpret_cast usage

As I already mentioned earlier, this is the most unsafe of all the C++ cast
operators and it's probably best to avoid using it. But then when porting old
code, you might want to convert the old style casts to reinterpret_cast. In my example,
Base2 and
Base are two managed classes that do not share an inheritance chain
except for deriving automatically from
System::Object. Assume that for whatever reason, we need to cast a
Base2 object into a
Base object and later cast it back to a
Base2 object.

Just like dynamic_cast this compiles fine too, but
throws an exception at run-time. That leaves us just reinterpret_cast now.

/* This is a sort of blind man's cast */
pB1 = reinterpret_cast<Base*>(pB2);

Oh boy! That compiled and also ran fine. No errors. pB1
which was declared as a Base object now holds a
Base2 object. To test this, we can try to re-cast it
back using dynamic_cast.

/* Now we cast it back */
Base2* pDest = dynamic_cast<Base2*>(pB1);
if(pDest)
{
Console::WriteLine("Original pointer has been obtained");
}

Well, as you might have understood by now, it's safest to avoid using
reinterpret_cast, but it does have it's uses and
without it, we'd still have had to use C-style casts when porting old code.

Conclusion

Well, the magic of casts haven't died yet, and casts live through the C++
cast operators and continue to enthrall C/C++ lovers all over the world. I am
not sure that everything I have suggested in the article is nice and proper. But
I trust that I'll get the required critical feedback to correct any erroneous
statements and recommendations I might have made.

Share

About the Author

Nish is a real nice guy who has been writing code since 1990 when he first got his hands on an 8088 with 640 KB RAM. Originally from sunny Trivandrum in India, he has been living in various places over the past few years and often thinks it’s time he settled down somewhere.

Nish has been a Microsoft Visual C++ MVP since October, 2002 - awfully nice of Microsoft, he thinks. He maintains an MVP tips and tricks web site - www.voidnish.com where you can find a consolidated list of his articles, writings and ideas on VC++, MFC, .NET and C++/CLI. Oh, and you might want to check out his blog on C++/CLI, MFC, .NET and a lot of other stuff - blog.voidnish.com.

Comments and Discussions

I hate it when people say they can never find a use for reinterpret_cast or that they don't know why it's there. The very simple explanation is that it's there to support legacy code and C/C++ interoperability (this coming from Bjorn himself). Well designed C++ programs should almost never need to reinterpret a pointer type. Actually, I can comfortably say that user-mode programs written in C++ should never need to use reinterpret_cast.

Back to my point, I'm developing software now that makes use of two well known libraries both written in C: Lua and libcurl. The issue comes when building wrapper classes in C++ around these libraries. Sometimes you need to provide non-static member data to these libraries and the only way to do so effectively is to reinterpret_cast void pointers, particularly when providing callback functions which generally need to be defined as static member functions.

Following is an example of using libcurl within a class. This class is very much stripped down for simplicity and to illustrate my point:

Now without going into the details of how to work with libcurl itself and ignoring the fact that this class is utterly useless in its present form in a real-world application, suffice it to say that the function progress() is used as a callback function and its prototype is defined by libcurl (C/C++ interoperability). Because it's static we can't use non-static class members. Granted I could just define mProgrss as static because it's a POD but what if I wanted to pass a pointer to a non-POD data type? I wouldn't be able to do it. This is exactly why reinterpret_cast is provided.

Sorry for the hard title your article is awsome
I just wanna ask about the unsafety you mentioned many times (such as in the tables following the codes testing your ChildToBase And BaseToChild Functions)

How did you make sure about the unsafe cases that they are unsafe?
Many thanks and nice work

I have loaded a class for menu from a link in CButtonST article of Davide Calabro. The code were writen and tested on VC++ 6.0. Because new my project were developed on VC++.NET using managed C++, so when I add the menu class into my project, the compiler display "warnings C4312: 'type cast' : conversion from 'UINT' to 'HMENU' of greater size" at the code lines that cast UINT to HMENU as following:

....
m_SubMenus.Add((HMENU)(nID));
...

The parameter type of Add(...) function was HMENU. I have used all new casting methods that you have described, but the problem was not solved.
Do you have any suggestions?
Thanks.

reinterpret_cast is actually a lot safer than a C-style cast. Using it will pick up a lot of errors in your code.

(a) You can't cast away 'const' in a reinterpret_cast. Only const_cast can do that.

(b) There are limits as to what what reinterpret_cast can convert between. Interestingly, there a few things that static_cast can do that reinterpret_cast can't. (I believe that reinterpret_cast can't do downcasts, for example - I don't think it can change the binary representation of what it's pointing to, whereas a static_cast can adjust 'this' pointers).

In the worst case, a C-style cast may need to be changed to a triple combo of reinterpret_cast, static_cast and const cast!

One problem I find is that purely by habit, a lot of C-style casts remain in my code, and it's virtually impossible to find them by a text-editor search. The Digital Mars C++ compiler (free download from www.digitalmars.com) has a command-line option to generate a warning whenever it finds a C-style cast. I thoroughly recommend it.

In my 'Member Function Pointers' article,
I define two other casts:'implicit_cast', the safest of all possible casts, it succeeds only if there is an implicit conversion between the types (eg, from long to int),
and 'horrible_cast' (also called 'union_cast' by others) which simply reinterprets bits. (ie, it does what you would guess reinterpret_cast does, with no restrictions). Very, very evil.

http://www.codeproject.com/cpp/FastDelegate.asp

// implicit_cast< >
// I believe this was originally going to be in the C++ standard but
// was left out by accident. It's even milder than static_cast.
// I use it instead of static_cast<> to emphasize that I'm not doing
// anything nasty.
// Usage is identical to static_cast<>
template <class OutputClass, class InputClass>
inline OutputClass implicit_cast(InputClass input){
return input;
}

Just want to point out that I've had some serious issues with using dynamic_cast<> on invalid pointers. Instead of just failing and returning NULL, this actually corrupt memory! What I had to do was make up a hash table of valid object pointers and always look up the pointer before trying to do a dynamic_cast<>, and even then wrap the call in a try-catch block. The docs are all lies! Either that, or MS really buggered up their implementation of that cast.

swine

Check out Aephid Photokeeper, the powerful digital
photo album solution at www.aephid.com.

__unaligned does A LOT and is not "reserved for future implementations". The problem is, that for your x86 processors, there is no need since it doesn't have alignment faults. However, on processors such as the Alpha or many of your Windows CE computers, this tells the compiler to generate slower, but fault safe code.

Tim Smith

"Programmers are always surrounded by complexity; we can not avoid it... If our basic tool, the language in which we design and code our programs, is also complicated, the language itself becomes part of the problem rather that part of the solution."
Hoare - 1980 ACM Turing Award Lecture

Many operating systems will trap alignment faults and then perform corrective actions and eat the fault. However, this can beIS VERY expensive. Much cheaper to use __unaligned and not even get the OS's fault code involved.

Tim Smith

"Programmers are always surrounded by complexity; we can not avoid it... If our basic tool, the language in which we design and code our programs, is also complicated, the language itself becomes part of the problem rather that part of the solution."
Hoare - 1980 ACM Turing Award Lecture

So you say, and while I have no reason to doubt this, MSDN does not agree with you:

The list of Microsoft Extensions to the C++ language in VC++.NET clearly lists __unaligned as "reserved for future implementations". The corresponding page for VC++ 6.0 does, too. __unaligned is also not found in this list of C++ keywords (in VS.NET). It does, however, say that names with two leading underscores (__) are reserved for compiler implentations. Hence, it's not something we mortals need to bother with learning about, anyway

Agreed that this cast is not at all safe. But like the situation mentioned by Normski there could be other situations as well. So instead of using the C style cast using reinterpret_cast will help solve a lot of debugging headache. Imaging a codebase having millions of lines of code and a bug related to casting occurs. It would be very difficult to locate the bug if C style cast is used. In the case of reinterpret_cast, at least, this word "reinterpret_cast" can be searched for and that part of the code can be debugged.

reinterpret_cast is a great tool for casting from pointers to non-pointers, and back again. for example, casting between HWND and long datatypes. Another great example is when you are using the Interlocked functions (e.g. InterlockedIncrement). InterlockedIncrement expects a long*. The code below illustrates a class which expects to be used by multiple asynchronous methods.

when i get process main window hwnd from its property
and i type cast it into hwnd using
hwnd=(HWND)intptr.ToInt32();
but it does not work properly because when i use Getwindow
to get its child window it return null i dont now why becuse it have child hwnd.