I know you said you had read a lot of stuff but I found a good description that I like so I will send it here. Note that as a performance issue only dynamic is slower than Static but they both work different and are made for different purposes. Here is the descriptions of the casts: static_cast static_cast is used to perform a cast between related types. Any of the basic types (char, double, int, etc) can be converted using this cast. It can also be used to up-cast or downcast classes in the same inheritance tree (however, review dynamic_cast for reasons why you might not want to do this). It correctly performs any necessary pointer movement in order to point at the correct location within the object for that static type. Consider that static almost always means something performed at compile time that results in a hard coded manipulation of the object into a new type. dynamic_cast dynamic_cast will perform a run-time cast of a polymorphic type. This means that it is a safer but slower cast to objects sharing an inheritance tree. This is usually used for a down cast that checks for the validity of the cast before continuing. When a dynamic cast is performed the system checks whether the object of cast is actually of the type being cast to. Review the following: class A {}; class B : public A {}; class C : public A {}; .... A * b = new B; A * c = new C; .... C * bad = static_cast<C>(b); // also the result of a c style cast. In this case the compiler happily performs the necessary conversion between the related types B* and C* but the cast is obviously not valid. Later something could blow up because B and C don't have the same alignment properties. See the following: C * bad = dynamic_cast<C>(b); If (bad)...ok. In this case a dynamic, or run-time cast was used. The result of this cast is a null pointer because b is not a C* and the cast is not valid. This can now be checked and validated so that the program doesn't just crash because someone didn't account for some situation when a B* could be passed into a function that did this cast. When this cast is performed on a reference it results in a bad_cast exception instead of a null pointer. const_cast This is rarely necessary. If you need a const cast you should review why and take the problem to the program manager for review. Do not cast away constness without this review process. Const cast is used to cast away constness or volatility. We do not use volatility currently in pipe-flo so I will focus on constness. Const cast should NEVER be used unless you are casting TO const. The following is an example: const char * x = "hello"; char * y = const_cast<char*>(x); The goal of the above code is probably to change the text pointed to by x. This results in undefined behavior and must not be done. Sometimes one might be tempted to cast away constness in order to call a non-const function that you are sure won't change anything. The correct way to fix this problem is to make the function const. There are a few cases when it is appropriate to change values internal to a class in a const function (this also must be reviewed by the program manager) and you can do this by making that variable "mutable". One situation that const_cast is allowed without review is casting into const: class Obj { ... void f() const { do stuff without changing anything}; void f() { do something that changes stuff; const_cast<const Obj*>(this)->f(); } }; That uses the const version of f() instead of rewriting the same code. This is of questionable design but not invalid so is allowed. reinterpret_cast This cast is used to cast between totally unrelated types. For instance, you may have a C function that accepts char* as input and you want to pass in an array of integers instead (often seen in binary file output). This would be done as follows: void cf(const char * input, size_t size); .... int x[] = {5, 11, 23 }; cf(reinterpret_cast<char*>(x), sizeof(int) * 3); Notice that a const cast is not necessary because you can always add const without a cast. The above code formally results in undefined behavior but is necessary when dealing with C code that doesn't have the strong typing and templates available in C++. You can always perform a cast from one type to another and back (assuming that the size of the destination type is large enough to hold the entire value of the source) and this will result in defined behavior. For instance, passing data into a C callback (any win32 dlg proc) you will often want to cast some pointer to the LPARAM type: reinterpret_cast<LPARAM>(an_integer) Later you can cast back: reinterpret_cast<int>(lParam); This is valid and defined code since the LPARAM type is large enough to store any int value. -----Original Message----- From: programmingblind-bounce@xxxxxxxxxxxxx [mailto:programmingblind-bounce@xxxxxxxxxxxxx] On Behalf Of jaffar Sent: Friday, October 19, 2007 9:39 AM To: programmingblind@xxxxxxxxxxxxx Subject: static and dynamic casting Hi All. I need some help here. I need to know when to, or when not to use static or dynamic casting in my program. I have read a few c++ books on the subject, but i am still finding it a problem to determine when to avoid or to use dynamic and static casting. Also, I would like to find out if by using one or the other, how much it will afect my software in terms of performance. Cheers and thanks for the help. __________ View the list's information and change your settings at //www.freelists.org/list/programmingblind __________ View the list's information and change your settings at //www.freelists.org/list/programmingblind