Q: What are the C++ casting operators?
A: Casting means you change the representation of a variable by changing its type to a different one. In order to type-cast a simple object to another you use the traditional type casting operator. For example, to cast a floating point number of type 'double' to an integer of type 'int':
#include <typeinfo>
Code:
int i;
double d;
i = (int) d;
or also
Code:
i = int (d);
This is quite good for basic types that have standard defined conversions, however this operators can also been indiscriminately applied on classes and pointers to classes. ANSI-C++ standard has defined four new casting operators: 'reinterpret_cast', 'static_cast', 'dynamic_cast' and 'const_cast' in order to control these types of conversions between classes...
Code:
reinterpret_cast<new_type>(expression)
Code:
static_cast<new_type>(expression)
Code:
dynamic_cast<new_type>(expression)
Code:
const_cast<new_type>(expression)
'reinterpret_cast'
'reinterpret_cast' casts a pointer to any other type of pointer. It also allows casting from pointer to an integer type and vice versa.
This operator can cast pointers between non-related classed. The operation results is a simple binary copy of the value from a pointer to the other. The content pointed does not pass any kind of check nor transformation between types.
In the case that the copy is performed from a pointer to an integer, the interpretation of its content is system dependent and therefore any implementation is non portable. A pointer casted to an integer enough large to fully contain it can be casted back to a valid pointer.
Code:
class A {};
class B {};
A * a = new A;
B * b = reinterpret_cast<B *>(a);
'reinterpret_cast' treats all pointers exactly as traditional type-casting operators do.
'static_cast'
'static_cast' allows to perform any casting that can be implicitly performed as well as also the inverse cast (even if this is not allowed implicitly).
Applied to pointers to classes, that is to say that it allows to cast a pointer of a derived class to its base class (this is a valid conversion that can be implicitly performed) and can also perform the inverse: cast a base class to its derivated class.
In this last case the base class that is being casted is not checked to determine wether this is a complete class of the destination type or not.
Code:
class Base {};
class Derived : public Base {};
Base *a = new Base;
Derived *b = static_cast<Derived *>(a);
'static_cast', aside from manipulating pointers to classes, can also be used to perform conversions explicitly defined in classes, as well as to perform standard conversions between fundamental types:
Code:
double d = 3.14159265;
int i = static_cast<int>(d);
'dynamic_cast'
'dynamic_cast' is exclusively used with pointers and references to objects. It allows any type-casting that can be implicitly performed as well as the inverse one when used with polymorphic classes, however, unlike static_cast, dynamic_cast checks, in this last case, if the operation is valid. That is to say, it checks if the casting is going to return a valid complete object of the requested type.
Checking is performed during run-time execution. If the pointer being casted is not a pointer to a valid complete object of the requested type, the value returned is a 'NULL' pointer.
Code:
class Base { virtual dummy() {} };
class Derived : public Base {};
Base* b1 = new Derived;
Base* b2 = new Base;
Derived* d1 = dynamic_cast<Derived *>(b1); // succeeds
Derived* d2 = dynamic_cast<Derived *>(b2); // fails: returns 'NULL'
If the type-casting is performed to a reference type and this casting is not possible an exception of type 'bad_cast' is thrown:
Code:
class Base { virtual dummy() {} };
class Derived : public Base { };
Base* b1 = new Derived;
Base* b2 = new Base;
Derived d1 = dynamic_cast<Derived &*>(b1); // succeeds
Derived d2 = dynamic_cast<Derived &*>(b2); // fails: exception thrown
'const_cast'
This type of casting manipulates the const attribute of the passed object, either to be set or removed:
Code:
class C {};
const C *a = new C;
C *b = const_cast<C *>(a);
Neither of the other three new cast operators can modify the constness of an object.
Note: The 'const_cast' operator can also change the 'volatile' qualifier on a type.
typeid 得到类对象或指针
typeid(*pb).name() 输出对象名
typeid(pb).name() 输出类名
---------子类向基类私有或保护继承的时，可以转化但是不能访问。 一般不进行转化。error 2443
------------------------------------------------------------------------------------
C++风格的转型运算符小结
为了改正C中丑陋的转型操作，C++中引入了四个新的转型操作符，分别是：
dynamic_cast
const_cast
static_cast
reinterpret_cast
1.dynamic_cast
这个转型操作符主要用在安全的向下转型（safe downcasting）中,也就是从基类指针/引用向派生类指针/引用的转型。例如：
Code: [View More of this Code] [View Even More of this Code] [View Less of this Code] [Select All of this Code]
class A {...};
class B:public A {...};
A* a = new B;
B* b;
b = dynamic_cast<B *> a;
当你将dynamic_cast用在指针上时，如果成功，就传回一个转型目标的指针，如果失败，则传回null指针。所以用到dynamic_cast的时候必然会导致if-then-else的程序风格，其中else就是用来检测转型失败的情况（[1]第39条）。例子如下：
Code: [View More of this Code] [View Even More of this Code] [View Less of this Code] [Select All of this Code]
#include <iostream>
using namespace std;
class A {
public:
virtual void do_sth(){
cout<<"aaa\n";
}
};
class B : public A {
public:
virtual void do_sth(){
cout<<"bbb\n";
}
};
class C : public A {
public:
virtual void do_sth(){
cout<<"ccc\n";
}
};
int main(){
A* a1 = new B;
A* a2 = new C;
B* b;
if(b = dynamic_cast<B *>(a1))//转换成功
b->do_sth();
else
cout<<"error\n";
if(b = dynamic_cast<B *>(a2))//转换失败
b->do_sth();
else
cout<<"error\n";
}
2.const_cast
此转型操作符用来将对象或指针的常量性（sonstness）转型掉。例如：
const A * a1;
A * a2 = const_cast<A *> (a1);
需要注意的是，const_cast转型并不总是成功的，当遇到转型的对象本身就是const的时候，那么将其常量性转型，结果未定义。看一下下面的例子：
Code: [View More of this Code] [View Even More of this Code] [View Less of this Code] [Select All of this Code]
// constcast.cpp from [2]
#include <iostream>
using std::cout;
void change(const int * pt, int n);
int main()
{
int pop1 = 38383;
const int pop2 = 2000;
cout << "pop1, pop2: " << pop1 << ", " << pop2 << '\n';
change(&pop1, -1);
change(&pop2, -1);
cout << "pop1, pop2: " << pop1 << ", " << pop2 << '\n';
return 0;
}
void change(const int * pt, int n)
{
int * pc;
if (n < 0)
{
pc = const_cast<int *>(pt);
*pc = 100;
}
}
输出的结果是：
pop1, pop2: 38383, 2000
pop1, pop2: 100, 2000
可见，pop2的值并没有改变（有些编译器会产生一个pop2的临时变量，并将其地址值赋给pc。在C++标准中，这种情况下的行为是不确定的[2]）。
3.static_cast
此转型操作符用于内建数据类型之间的转型。它与C的转型操作最接近。当没有其他适当的转型操作符可用时，就使用它。它可以将整型转换为枚举型，双精度型转换为整型，浮点型转换为长整型等等。例如：
Code: [View More of this Code] [View Even More of this Code] [View Less of this Code] [Select All of this Code]
int n=9;
double d = static_cast < double > (n);
上面的例子中，我们将一个变量从 int 转换到 double. 这些类型的二进制表达式是不同的。要将整数 9 转换到 双精度整数 9，static_cast需要正确地为双精度整数 d 补足比特位。其结果为 9.0 。
4.reinterpret_cast
此转型操作符的结果取决于编译器，用于修改操作数类型，非类型安全的转换符。举例如下：
Code: [View More of this Code] [View Even More of this Code] [View Less of this Code] [Select All of this Code]
int main() { // from [2]
struct dat { short a; short b;};
long value = 0xA224B118;
dat * pd = reinterpret_cast<dat *> (&value);
cout << pd->a; // display first 2 bytes of value
return 0;
}
该例中将long型转换成struct，但此代码是不可移植的，在IBM兼容机和Mac机上的运行结果完全不一样，因为他们存储字节的方式不一样。
reinterpret_cast的使用要非常的谨慎，例如将3中的例子改写如下：
Code: [View More of this Code] [View Even More of this Code] [View Less of this Code] [Select All of this Code]
int n=9;
double d = reinterpret_cast<double & > (n);
这次，与3的结果有所不同。在进行计算以后，d 包含无用值。这是因为 reinterpret_cast 仅仅是复制 n 的比特位到 d，没有进行必要的分析。
以上是我在学习这些转型操作符一个小结，如有不对之处，请各位不啬赐教。
大家有兴趣，可以去这里做一下有关这些转型操作符的练习。
注：以上例子在 VC6 + Intel C++ Compiler 8.0 下编译运行通过（别忘了打开RTTI，加参数/GR）。
参考文献：
[1] Effective C++ 中文版 Scott Meyers 侯捷译
[2] C++ Primer Plus, 4th Edition, Stephen Prata
[3] STATIC_CAST VERSUS REINTERPRET_CAST(Topica转载)
－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－
这是More Effecitve C++里的第二条对类型转换讲的很好，也很基础好懂。
Item M2：尽量使用C++风格的类型转换
仔细想想地位卑贱的类型转换功能（cast），其在程序设计中的地位就象goto语句一样令人鄙视。但是它还不是无法令人忍受，因为当在某些紧要的关头，类型转换还是必需的，这时它是一个必需品。
不过C风格的类型转换并不代表所有的类型转换功能。
一、来它们过于粗鲁，能允许你在任何类型之间进行转换。不过如果要进行更精确的类型转换，这会是一个优点。在这些类型转换中存在着巨大的不同，例如把一个指向 const对象的指针（pointer-to-const-object）转换成指向非const对象的指针（pointer-to-non-const -object）(即一个仅仅去除const的类型转换)，把一个指向基类的指针转换成指向子类的指针（即完全改变对象类型）。传统的C风格的类型转换不对上述两种转换进行区分。（这一点也不令人惊讶，因为C风格的类型转换是为C语言设计的，而不是为C++语言设计的）。
二、来C 风格的类型转换在程序语句中难以识别。在语法上，类型转换由圆括号和标识符组成，而这些可以用在C＋＋中的任何地方。这使得回答象这样一个最基本的有关类型转换的问题变得很困难：“在这个程序中是否使用了类型转换？”。这是因为人工阅读很可能忽略了类型转换的语句，而利用象grep的工具程序也不能从语句构成上区分出它们来。
C++通过引进四个新的类型转换操作符克服了C风格类型转换的缺点，这四个操作符是, static_cast, const_cast, dynamic_cast, 和reinterpret_cast。在大多数情况下，对于这些操作符你只需要知道原来你习惯于这样写，
(type) expression
而现在你总应该这样写：
static_cast<type>(expression)
例如，假设你想把一个int转换成double，以便让包含int类型变量的表达式产生出浮点数值的结果。如果用C风格的类型转换，你能这样写：
int firstNumber, secondNumber;
...
double result = ((double)firstNumber)/secondNumber；
如果用上述新的类型转换方法，你应该这样写：
double result = static_cast<double>(firstNumber)/secondNumber;
这样的类型转换不论是对人工还是对程序都很容易识别。
static_cast 在功能上基本上与C风格的类型转换一样强大，含义也一样。它也有功能上限制。例如，你不能用static_cast象用C风格的类型转换一样把 struct转换成int类型或者把double类型转换成指针类型，另外，static_cast不能从表达式中去除const属性，因为另一个新的类型转换操作符const_cast有这样的功能。
其它新的C++类型转换操作符被用在需要更多限制的地方。const_cast用于类型转换掉表达式的const或volatileness属性。通过使用const_cast，你向人们和编译器强调你通过类型转换想做的只是改变一些东西的 constness或者volatileness属性。这个含义被编译器所约束。如果你试图使用const_cast来完成修改constness 或者volatileness属性之外的事情，你的类型转换将被拒绝。下面是一些例子：
class Widget { ... };
class SpecialWidget: public Widget { ... };
void update(SpecialWidget *psw);
SpecialWidget sw; // sw 是一个非const 对象。
const SpecialWidget& csw = sw; // csw 是sw的一个引用
// 它是一个const 对象
update(&csw); // 错误!不能传递一个const SpecialWidget* 变量
// 给一个处理SpecialWidget*类型变量的函数
update(const_cast<SpecialWidget*>(&csw));
// 正确，csw的const被显示地转换掉（
// csw和sw两个变量值在update
//函数中能被更新）
update((SpecialWidget*)&csw);
// 同上，但用了一个更难识别
//的C风格的类型转换
Widget *pw = new SpecialWidget;
update(pw); // 错误！pw的类型是Widget*，但是
// update函数处理的是SpecialWidget*类型
update(const_cast<SpecialWidget*>(pw));
// 错误！const_cast仅能被用在影响
// constness or volatileness的地方上。,
// 不能用在向继承子类进行类型转换?br> 到目前为止，const_cast最普通的用途就是转换掉对象的const属性。
第二种特殊的类型转换符是dynamic_cast，它被用于安全地沿着类的继承关系向下进行类型转换。这就是说，你能用dynamic_cast把指向基类的指针或引用转换成指向其派生类或其兄弟类的指针或引用，而且你能知道转换是否成功。失败的转换将返回空指针（当对指针进行类型转换时）或者抛出异常（当对引用进行类型转换时）：
Widget *pw;
...
update(dynamic_cast<SpecialWidget*>(pw));
// 正确，传递给update函数一个指针
// 是指向变量类型为SpecialWidget的pw的指针
// 如果pw确实指向一个对象,
// 否则传递过去的将使空指针。
void updateViaRef(SpecialWidget& rsw);
updateViaRef(dynamic_cast<SpecialWidget&>(*pw));
//正确。传递给updateViaRef函数
// SpecialWidget pw 指针，如果pw
// 确实指向了某个对象
// 否则将抛出异常
dynamic_casts在帮助你浏览继承层次上是有限制的。它不能被用于缺乏虚函数的类型上（参见条款M24），也不能用它来转换掉constness：
int firstNumber, secondNumber;
...
double result = dynamic_cast<double>(firstNumber)/secondNumber;
// 错误！没有继承关系
const SpecialWidget sw;
...
update(dynamic_cast<SpecialWidget*>(&sw));
// 错误! dynamic_cast不能转换
// 掉const。
如你想在没有继承关系的类型中进行转换，你可能想到static_cast。如果是为了去除const，你总得用const_cast。
这四个类型转换符中的最后一个是reinterpret_cast。使用这个操作符的类型转换，其的转换结果几乎都是执行期定义（implementation-defined）。因此，使用reinterpret_casts的代码很难移植。
reinterpret_casts的最普通的用途就是在函数指针类型之间进行转换。例如，假设你有一个函数指针数组：
typedef void (*FuncPtr)(); // FuncPtr is 一个指向函数
// 的指针，该函数没有参数
// 返回值类型为void
FuncPtr funcPtrArray[10]; // funcPtrArray 是一个能容纳
// 10个FuncPtrs指针的数组
让我们假设你希望（因为某些莫名其妙的原因）把一个指向下面函数的指针存入funcPtrArray数组：
int doSomething();
你不能不经过类型转换而直接去做，因为doSomething函数对于funcPtrArray数组来说有一个错误的类型。在FuncPtrArray数组里的函数返回值是void类型，而doSomething函数返回值是int类型。
funcPtrArray[0] = &doSomething; // 错误！类型不匹配
reinterpret_cast可以让你迫使编译器以你的方法去看待它们：
funcPtrArray[0] = // this compiles
reinterpret_cast<FuncPtr>(&doSomething);
转换函数指针的代码是不可移植的（C++不保证所有的函数指针都被用一样的方法表示），在一些情况下这样的转换会产生不正确的结果（参见条款M31），所以你应该避免转换函数指针类型，除非你处于着背水一战和尖刀架喉的危急时刻。一把锋利的刀。一把非常锋利的刀。
如果你使用的编译器缺乏对新的类型转换方式的支持，你可以用传统的类型转换方法代替static_cast, const_cast, 以及reinterpret_cast。也可以用下面的宏替换来模拟新的类型转换语法：
#define static_cast(TYPE,EXPR) ((TYPE)(EXPR))
#define const_cast(TYPE,EXPR) ((TYPE)(EXPR))
#define reinterpret_cast(TYPE,EXPR) ((TYPE)(EXPR))
你可以象这样使用使用：
double result = static_cast(double, firstNumber)/secondNumber;
update(const_cast(SpecialWidget*, &sw));
funcPtrArray[0] = reinterpret_cast(FuncPtr, &doSomething);
这些模拟不会象真实的操作符一样安全，但是当你的编译器可以支持新的的类型转换时，它们可以简化你把代码升级的过程。
没有一个容易的方法来模拟dynamic_cast的操作，但是很多函数库提供了函数，安全地在派生类与基类之间进行类型转换。如果你没有这些函数而你有必须进行这样的类型转换，你也可以回到C风格的类型转换方法上，但是这样的话你将不能获知类型转换是否失败。当然，你也可以定义一个宏来模拟 dynamic_cast的功能，就象模拟其它的类型转换一样：
#define dynamic_cast(TYPE,EXPR) (TYPE)(EXPR)
请记住，这个模拟并不能完全实现dynamic_cast的功能，它没有办法知道转换是否失败。
我知道，是的，我知道，新的类型转换操作符不是很美观而且用键盘键入也很麻烦。如果你发现它们看上去实在令人讨厌，C风格的类型转换还可以继续使用并且合法。然而，正是因为新的类型转换符缺乏美感才能使它弥补了在含义精确性和可辨认性上的缺点。并且，使用新类型转换符的程序更容易被解析（不论是对人工还是对于工具程序），它们允许编译器检测出原来不能发现的错误。这些都是放弃C风格类型转换方法的强有力的理由。还有第三个理由：也许让类型转换符不美观和键入麻烦是一件好事。