static_cast可以用来，将指针或者引用转为相关的指针或者引用，譬如派生类转为基类，基类转为派生类，但是安全性必须由程序员自己控制。因为int*和float *是不相关的，所以它们之前的转换不能用static_cast，但可以用传统的强制进行转换，譬如(int *)
要注意的是static_cast只能对有继承关系的类，进行向下转型或者向上转型，如果是两个无关的类，用static_cast转型，编译错误
dynamic_cast在编译期间，只检查被转换类是否有虚表，如果有虚表，则在编译过程中不会出错，这是因为dynamic_cast是在运行期间检查的，如果在运行期间检查两个类之间不能转换，如果是指针则返回NULL，如果是引用则有异常。
class A{
public:
virtual void fun()
{
cout<<"a"<<endl;
}
};
class B {
public:
};
int main() {
A a;
B *b = dynamic_cast<B*>(&a);
if(b == NULL)
cout<<"NULL"<<endl;
}上述程序如果用static_cast转型，则编译出错
reinterpret_cast，不管两个类之间是否相关，就都可以转型，至于实际运行中是否正确，要看实际的平台。
对于类而言，static_const 只能用于转换指针或者引用的，不用用于转换类
class AA{
};
class BB:public AA{
};
void fun(AA &a){
BB b = static_cast<BB>(a);
}
肯定会编译出错，应该是 BB& b = static_cast<BB &>(a);
还可以用于可以隐式转换的情况的非指针或者引用，譬如：
double d=3.14159265;
int i = static_cast<int>(d);或者对象之间的转换（不是对象的指针或者引用）
对于代码：
class ad1 { public: ad1() { cerr<<"ad1 construction\n"; } ~ad1() { cerr<<"ad1 deconstruction\n"; } }; class ad2 { public: ad2() { cerr<<"ad2 construction\n"; } ~ad2() { cerr<<"ad2 deconstruction\n"; } }; class test2; class test1 { public: test1(int a):tst_var(a) { cerr<<"test1 construction with para\n"<<tst_var<<endl; } test1() { cerr<<"test1 construction\n"; } test1(test1 &t1) { cerr<<"test1 copy construction ,parameter is test1\n"; } /*test1(test2 &t2) { cerr<<"test1 copy construction ,parameter is test2\n"; }*/ ~test1() { cerr<<"test1 deconstruction\n"<<tst_var<<endl; } void testtry() const; void testtry(); virtual void calc() { cerr<<"int test1\n"<<"sum is "<<Snum<<endl; ++Snum; } void set(int num) { ptd1 = num; } void display() { cerr<<"ptdl = "<<ptd1<<endl; } protected: int ptd1; static int Snum ; private: //A &a; int tst_var; }; class test2:public test1 { public: test2():a2(),a1(),test1(6) { cerr<<"test2 construcion\n"; a = 6; } void calc() { cerr<<"int test2\n"; } void Display() { cerr<<"snum is "<<Snum<<endl; } void anotherFun() { cerr<<"test2 anothre fun "<<a<<endl; } ~test2() { cerr<<"test2 deconstruction \n"; } protected: int a; ad1 a1; ad2 a2; };
在main.cpp
test1 t1; test2 *pt2 = static_cast<test2 *>(&t1); pt2->anotherFun();
pt2->calc()
pt2->anotherFun()的确调用了test2的函数，但是由于test2的对象没有定义所以cerr<<"test2 anothre fun "<<a<<endl; a的值为随机但是pt2->calc()却调用的是test1的函数可以这样理解，成员函数其实就是普通的函数，只是多传了一个this指针。(在调用pt2->anotherFun时，t1中没有这个函数，于是把本来是t1的this指针转化为t2的指针，就调用了t2的函数；但是对于calc函数而言，t1有对应的实现，所以还是调用t1的calc)对于上面括号里的文字，要持保留意见，应该解释的不对。pt2->anotherFun,既然pt2是test2的指针，那么就应该调用test2中的函数pt2->calc,因为calc是虚函数，所以要先查pt2所指对象的虚表，因为这个对象是test1的对象，所以其虚表中就是对应test1中函数。如果在test1中calc不是虚函数的话，则pt2->calc将调用test2中的calc如果在main.cpp中是：test2 t2; test1 *rt1 = static_cast<test1 *>(&t2); rt1->calc(); rt1->anotherFun();对于rt1->calc()调用的是test2的函数，而rt1->anotherFun()却编译出错，这是因为在test1中没有anotherFun这个函数。更为详细的转换可以参考reinterpret_cast不检查任何类型，只是简单的将一个指针的值给另一个指针。http://www.vckbase.com/document/viewdoc/?id=1651本文讨论static_cast<> 和 reinterpret_cast<>。
介绍
大多程序员在学C++前都学过C，并且习惯于C风格（类型）转换。当写C++（程序）时，有时候我们在使用static_cast<>和reinterpret_cast<>时可能会有点模糊。在本文中，我将说明static_cast<>实际上做了什么，并且指出一些将会导致错误的情况。
泛型（Generic Types）
01.floatf = 12.3;02.03.float* pf = &f;04.// static cast<>05.06.// 成功编译, n = 1207.08.intn =static_cast(f);09.10.// 错误,指向的类型是无关的（译注：即指针变量pf是float类型，现在要被转换为int类型）11.//int* pn = static_cast(pf);12.13.//成功编译14.15.void* pv =static_cast(pf);16.17.//成功编译, 但是 *pn2是无意义的内存（rubbish）18.19.int* pn2 =static_cast(pv);20.// reinterpret_cast<>21.22.//错误,编译器知道你应该调用static_cast<>23.24.//int i = reinterpret_cast(f);25.26.//成功编译, 但是 *pn 实际上是无意义的内存,和 *pn2一样27.28.int* pi =reinterpret_cast(pf);简而言之，static_cast<> 将尝试转换，举例来说，如float-到-integer，而reinterpret_cast<>简单改变编译器的意图重新考虑那个对象作为另一类型。
指针类型（Pointer Types）
指针转换有点复杂，我们将在本文的剩余部分使用下面的类：
01.classCBaseX02.03.{04.05.public:06.07.intx;08.09.CBaseX() { x = 10; }10.11.voidfoo() {printf("CBaseX::foo() x=%d\n", x); }12.13.};14.classCBaseY15.16.{17.18.public:19.20.inty;21.22.int* py;23.24.CBaseY() { y = 20; py = &y; }25.26.voidbar() {printf("CBaseY::bar() y=%d, *py=%d\n", y, *py);27.}28.29.};30.classCDerived :publicCBaseX,publicCBaseY31.32.{33.34.public:35.36.intz;37.38.};情况1：两个无关的类之间的转换
01.// Convert between CBaseX* and CBaseY*02.03.// CBaseX* 和 CBaseY*之间的转换04.05.CBaseX* pX =newCBaseX();06.07.// Error, types pointed to are unrelated08.09.// 错误， 类型指向是无关的10.11.// CBaseY* pY1 = static_cast(pX);12.13.// Compile OK, but pY2 is not CBaseX14.15.// 成功编译, 但是 pY2 不是CBaseX16.17.CBaseY* pY2 =reinterpret_cast(pX);18.19.// System crash!!20.21.// 系统崩溃!!22.23.// pY2->bar();正如我们在泛型例子中所认识到的，如果你尝试转换一个对象到另一个无关的类static_cast<>将失败，而reinterpret_cast<>就总是成功“欺骗”编译器：那个对象就是那个无关类。
CBaseY* pY1 = static_cast<CBaseY*>(pX); 是错误的，因为static_cast不能转换无关的类型
情况2：转换到相关的类
01.1. CDerived* pD =newCDerived();02.03.2.printf("CDerived* pD = %x\n", (int)pD);04.05.3.06.07.4.// static_cast<> CDerived* -> CBaseY* -> CDerived*08.09.//成功编译，隐式static_cast<>转换10.11.5. CBaseY* pY1 = pD;12.13.6.printf("CBaseY* pY1 = %x\n", (int)pY1);14.15.// 成功编译, 现在 pD1 = pD16.17.7. CDerived* pD1 =static_cast(pY1);18.19.8.printf("CDerived* pD1 = %x\n", (int)pD1);20.21.9.22.23.10.// reinterpret_cast24.25.// 成功编译, 但是 pY2 不是 CBaseY*26.27.11. CBaseY* pY2 =reinterpret_cast(pD);28.29.12.printf("CBaseY* pY2 = %x\n", (int)pY2);30.31.13.32.33.14.// 无关的 static_cast<>34.35.15. CBaseY* pY3 =newCBaseY();36.37.16.printf("CBaseY* pY3 = %x\n", (int)pY3);38.39.// 成功编译,尽管 pY3 只是一个 "新 CBaseY()"40.41.17. CDerived* pD3 =static_cast(pY3);42.43.18.printf("CDerived* pD3 = %x\n", (int)pD3);01.---------------------- 输出 ---------------------------02.03.CDerived* pD = 392fb804.05.CBaseY* pY1 = 392fbc06.07.CDerived* pD1 = 392fb808.09.CBaseY* pY2 = 392fb810.11.CBaseY* pY3 = 390ff012.13.CDerived* pD3 = 390fec注意：在将CDerived*用隐式 static_cast<>转换到CBaseY*（第5行）时，结果是（指向）CDerived*（的指针向后） 偏移了4（个字节）（译注：4为int类型在内存中所占字节数）。为了知道static_cast<> 实际如何，我们不得不要来看一下CDerived的内存布局。
对于CBaseY *dy = reinterpret_cast<CBaseY *>(&pD); cout<<dy<<endl; dy->bar();
虽然指针dy实际指向的是CDerived对象的地址，在调用bar时，就像前文所讲，只是把dy这个指针传给bar函数，
printf("CBaseY::bar() y=%d, *py=%d\n", y, *py) 输出y没有问题，是个随机数，但是py是个野指针，所以输出*py时就发生崩溃CDerived的内存布局（Memory Layout）
如图所示，CDerived的内存布局包括两个对象，CBaseX 和 CBaseY，编译器也知道这一点。因此，当你将CDerived* 转换到 CBaseY*时，它给指针添加4个字节，同时当你将CBaseY*转换到CDerived*时，它给指针减去4。然而，甚至它即便不是一个CDerived你也可以这样做。
当然，这个问题只在如果你做了多继承时发生。在你将CDerived转换 到 CBaseX时static_cast<> 和 reinterpret_cast<>是没有区别的。
情况3：void*之间的向前和向后转换
因为任何指针可以被转换到void*，而void*可以被向后转换到任何指针（对于static_cast<> 和 reinterpret_cast<>转换都可以这样做），如果没有小心处理的话错误可能发生。
01.CDerived* pD =newCDerived();02.03.printf("CDerived* pD = %x\n", (int)pD);04.CBaseY* pY = pD;// 成功编译, pY = pD + 405.06.printf("CBaseY* pY = %x\n", (int)pY);07.void* pV1 = pY;//成功编译, pV1 = pY08.09.printf("void* pV1 = %x\n", (int)pV1);10.// pD2 = pY, 但是我们预期 pD2 = pY - 411.12.CDerived* pD2 =static_cast(pV1);13.14.printf("CDerived* pD2 = %x\n", (int)pD2);15.16.// 系统崩溃17.18.// pD2->bar();01.---------------------- 输出 ---------------------------02.03.CDerived* pD = 392fb804.05.CBaseY* pY = 392fbc06.07.void* pV1 = 392fbc08.09.CDerived* pD2 = 392fbc一旦我们已经转换指针为void*，我们就不能轻易将其转换回原类。在上面的例子中，从一个void* 返回CDerived*的唯一方法是将其转换为CBaseY*然后再转换为CDerived*。
但是如果我们不能确定它是CBaseY* 还是 CDerived*，这时我们不得不用dynamic_cast<> 或typeid[2]。
注释：
1. dynamic_cast<>，从另一方面来说，可以防止一个泛型CBaseY* 被转换到CDerived*。
2. dynamic_cast<>需要类成为多态，即包括“虚”函数，并因此而不能成为void*。
http://blog.csdn.net/geeeeeeee/article/details/3427920
dynamic_cast: 通常在基类和派生类之间转换时使用,run-time cast const_cast: 主要针对const和volatile的转换. static_cast: 一般的转换，no run-time check.通常，如果你不知道该用哪个，就用这个。
reinterpret_cast: 用于进行没有任何关联之间的转换，比如一个字符指针转换为一个整形数。
1）static_cast<T*>(a) 编译器在编译期处理 将地址a转换成类型T，T和a必须是指针、引用、算术类型或枚举类型。 表达式static_cast<T*>(a), a的值转换为模板中指定的类型T。在运行时转换过程中，不进行类型检查来确保转换的安全性。 static_cast它能在内置的数据类型间（譬如int 和float之间的转换，但是int *和float*不能转换）互相转换，对于类只能在有联系的指针类型间进行转换（也能用于有联系的对象）。可以在继承体系中把指针转换来、转换去，但是不能转换成继承体系外的一种类型
class A { ... }; class B { ... }; class D : public B { ... }; void f(B* pb, D* pd) { D* pd2 = static_cast<D*>(pb); // 不安全, pb可能只是B的指针 B* pb2 = static_cast<B*>(pd); // 安全的 A* pa2 = static_cast<A*>(pb); //错误A与B没有继承关系 ... }
2）dynamic_cast<T*>(a) 在运行期，会检查这个转换是否可能。 完成类层次结构中的提升。T必须是一个指针、引用或无类型的指针。a必须是决定一个指针或引用的表达式。 dynamic_cast 仅能应用于指针或者引用，不支持内置数据类型 表达式dynamic_cast<T*>(a) 将a值转换为类型为T的对象指针。如果类型T不是a的某个基类型，该操作将返回一个空指针。 它不仅仅像static_cast那样，检查转换前后的两个指针是否属于同一个继承树，它还要检查被指针引用的对象的实际类型，确定转换是否可行。 如果可以，它返回一个新指针，甚至计算出为处理多继承的需要的必要的偏移量。如果这两个指针间不能转换，转换就会失败，此时返回空指针（NULL）。 很明显，为了让dynamic_cast能正常工作，必须让编译器支持运行期类型信息（RTTI）。
3）const_cast<T*>(a) 编译器在编译期处理 去掉类型中的常量，除了const或不稳定的变址数，T和a必须是相同的类型。 表达式const_cast<T*>(a)被用于从一个类中去除以下这些属性：const, volatile, 和 __unaligned。 class A { ... }; void f() { const A *pa = new A;//const对象 A *pb;//非const对象 //pb = pa; // 这里将出错，不能将const对象指针赋值给非const对象 pb = const_cast<A*>(pa); // 现在OK了 ... } 对于本身定义时为const的类型，即使你去掉const性，在你操作这片内容时候也要小心，只能r不能w操作，否则还是会出错 const char* p = "123"; char* c = const_cast<char*>(p); c[0] = 1; //表面上通过编译去掉了const性，但是操作其地址时系统依然不允许这么做。 const_cast操作不能在不同的种类间转换。相反，它仅仅把一个它作用的表达式转换成常量。它可以使一个本来不是const类型的数据转换成const类型的，或者把const属性去掉。 尽量不要使用const_cast,如果发现调用自己的函数，竟然使用了const_cast，那就赶紧打住，重新考虑一下设计吧。
4）reinterpret_cast<T*>(a) 编译器在编译期处理 任何指针都可以转换成其它类型的指针，T必须是一个指针、引用、算术类型、指向函数的指针或指向一个类成员的指针。 表达式reinterpret_cast<T*>(a)能够用于诸如char* 到 int*，或者One_class* 到 Unrelated_class*等类似这样的转换，因此可能是不安全的。 class A { ... }; class B { ... }; void f() { A* pa = new A; void* pv = reinterpret_cast<A*>(pa); // pv 现在指向了一个类型为B的对象，这可能是不安全的 ... } 使用reinterpret_cast 的场合不多，仅在非常必要的情形下，其他类型的强制转换不能满足要求时才使用。
== =========================================== == static_cast .vs. reinterpret_cast == ================================================ reinterpret_cast是为了映射到一个完全不同类型的意思，这个关键词在我们需要把类型映射回原有类型时用到它。我们映射到的类型仅仅是为了故弄玄虚和其他目的，这是所有映射中最危险的。(这句话是C++编程思想中的原话) static_cast 和 reinterpret_cast 操作符修改了操作数类型。它们不是互逆的； static_cast 在编译时使用类型信息执行转换，在转换执行必要的检测(诸如指针越界计算, 类型检查). 其操作数相对是安全的。 另一方面；reinterpret_cast是C++里的强制类型转换符,操作符修改了操作数类型,但仅仅是重新解释了给出的对象的比特模型而没有进行二进制转换。 例子如下： int n=9; double d=static_cast < double > (n); 上面的例子中, 我们将一个变量从 int 转换到 double。这些类型的二进制表达式是不同的。 要将整数 9 转换到 双精度整数 9，static_cast 需要正确地为双精度整数 d 补足比特位。其结果为 9.0。
而reinterpret_cast 的行为却不同: int n=9; double d=reinterpret_cast<double & > (n); 这次, 结果有所不同. 在进行计算以后, d 包含无用值. 这是因为 reinterpret_cast 仅仅是复制 n 的比特位到 d, 没有进行必要的分析. 因此, 你需要谨慎使用 reinterpret_cast.
reinterpret_casts的最普通的用途就是在函数指针类型之间进行转换。 例如，假设你有一个函数指针数组： typedefvoid(*FuncPtr)();//FuncPtr is一个指向函数的指针，该函数没有参数,返回值类型为void FuncPtrfuncPtrArray[10];//funcPtrArray是一个能容纳10个FuncPtrs指针的数组
让我们假设你希望（因为某些莫名其妙的原因）把一个指向下面函数的指针存入funcPtrArray数组： int doSomething();
你不能不经过类型转换而直接去做，因为doSomething函数对于funcPtrArray数组来说有一个错误的类型。在FuncPtrArray数组里的函数返回值是void类型，而doSomething函数返回值是int类型。
funcPtrArray[0] = &doSomething;//错误！类型不匹配 reinterpret_cast可以让你迫使编译器以你的方法去看待它们： funcPtrArray[0] = reinterpret_cast<FuncPtr>(&doSomething); 转换函数指针的代码是不可移植的（C++不保证所有的函数指针都被用一样的方法表示），在一些情况下这样的转换会产生不正确的结果
'dynamic_cast'只用于对象的指针和引用从派生类指针用dynamic_cast转为基类指针CBaseY时，不做任何检测但是如果是从基类指针转为派生类指针时，会检查两个方面：1. 它会检查转换是否会返回一个被请求的有效的完整对象。不是的话返回null2. 基类指针是否有虚函数，没有的话，编译不通过
479
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
