本文共 16357 字，大约阅读时间需要 54 分钟。
static_cast可以用来，将指针或者引用转为相关的指针或者引用，譬如派生类转为基类，基类转为派生类，但是安全性必须由程序员自己控制。因为int*和float *是不相关的，所以它们之前的转换不能用static_cast，但可以用传统的强制进行转换，譬如(int *)
要注意的是static_cast只能对有继承关系的类，进行向下转型或者向上转型，如果是两个无关的类，用static_cast转型，编译错误
dynamic_cast在编译期间，只检查被转换类是否有虚表，如果有虚表，则在编译过程中不会出错，这是因为dynamic_cast是在运行期间检查的，如果在运行期间检查两个类之间不能转换，如果是指针则返回NULL，如果是引用则有异常。
class A{public: virtual void fun() { cout<<"a"< (&a); if(b == NULL) cout<<"NULL"< 上述程序如果用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 (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"< < 在main.cpp
test1 t1;test2 *pt2 = static_cast (&t1);pt2->anotherFun();
pt2->calc()
pt2->anotherFun()的确调用了test2的函数，但是由于test2的对象没有定义所以 cerr<<"test2 anothre fun "<< 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 (&t2);rt1->calc();rt1->anotherFun(); 对于rt1->calc()调用的是test2的函数，而rt1->anotherFun()却编译出错，这是因为在test1中没有anotherFun这个函数。 更为详细的转换可以参考 reinterpret_cast不检查任何类型，只是简单的将一个指针的值给另一个指针。 本文讨论static_cast<> 和 reinterpret_cast<>。 介绍 大多程序员在学C++前都学过C，并且习惯于C风格（类型）转换。当写C++（程序）时，有时候我们在使用static_cast<>和reinterpret_cast<>时可能会有点模糊。在本文中，我将说明static_cast<>实际上做了什么，并且指出一些将会导致错误的情况。 泛型（Generic Types） 01. float f = 12.3; 02. 03. float* pf = &f; 04. // static cast<> 05. 06. // 成功编译, n = 12 07. 08. int n = 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. class CBaseX 02. 03. { 04. 05. public: 06. 07. int x; 08. 09. CBaseX() { x = 10; } 10. 11. void foo() { printf("CBaseX::foo() x=%d\n", x); } 12. 13. }; 14. class CBaseY 15. 16. { 17. 18. public: 19. 20. int y; 21. 22. int* py; 23. 24. CBaseY() { y = 20; py = &y; } 25. 26. void bar() { printf("CBaseY::bar() y=%d, *py=%d\n", y, *py); 27. } 28. 29. }; 30. class CDerived : public CBaseX, public CBaseY 31. 32. { 33. 34. public: 35. 36. int z; 37. 38. }; 情况1：两个无关的类之间的转换 01. // Convert between CBaseX* and CBaseY* 02. 03. // CBaseX* 和 CBaseY*之间的转换 04. 05. CBaseX* pX = new CBaseX(); 06. 07. // Error, types pointed to are unrelated 08. 09. // 错误， 类型指向是无关的 10. 11. // CBaseY* pY1 = static_cast(pX); 12. 13. // Compile OK, but pY2 is not CBaseX 14. 15. // 成功编译, 但是 pY2 不是CBaseX 16. 17. CBaseY* pY2 = reinterpret_cast(pX); 18. 19. // System crash!! 20. 21. // 系统崩溃!! 22. 23. // pY2->bar(); 正如我们在泛型例子中所认识到的，如果你尝试转换一个对象到另一个无关的类static_cast<>将失败，而reinterpret_cast<>就总是成功“欺骗”编译器：那个对象就是那个无关类。 CBaseY* pY1 = static_cast (pX); 是错误的，因为static_cast不能转换无关的类型 情况2：转换到相关的类 01. 1. CDerived* pD = new CDerived(); 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 = pD 16. 17. 7. CDerived* pD1 = static_cast(pY1); 18. 19. 8. printf("CDerived* pD1 = %x\n", (int)pD1); 20. 21. 9. 22. 23. 10. // reinterpret_cast 24. 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 = new CBaseY(); 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 = 392fb8 04. 05. CBaseY* pY1 = 392fbc 06. 07. CDerived* pD1 = 392fb8 08. 09. CBaseY* pY2 = 392fb8 10. 11. CBaseY* pY3 = 390ff0 12. 13. CDerived* pD3 = 390fec 注意：在将CDerived*用隐式 static_cast<>转换到CBaseY*（第5行）时，结果是（指向）CDerived*（的指针向后） 偏移了4（个字节）（译注：4为int类型在内存中所占字节数）。为了知道static_cast<> 实际如何，我们不得不要来看一下CDerived的内存布局。 对于CBaseY *dy = reinterpret_cast (&pD); cout< < 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 = new CDerived(); 02. 03. printf("CDerived* pD = %x\n", (int)pD); 04. CBaseY* pY = pD; // 成功编译, pY = pD + 4 05. 06. printf("CBaseY* pY = %x\n", (int)pY); 07. void* pV1 = pY; //成功编译, pV1 = pY 08. 09. printf("void* pV1 = %x\n", (int)pV1); 10. // pD2 = pY, 但是我们预期 pD2 = pY - 4 11. 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 = 392fb8 04. 05. CBaseY* pY = 392fbc 06. 07. void* pV1 = 392fbc 08. 09. CDerived* pD2 = 392fbc 一旦我们已经转换指针为void*，我们就不能轻易将其转换回原类。在上面的例子中，从一个void* 返回CDerived*的唯一方法是将其转换为CBaseY*然后再转换为CDerived*。 但是如果我们不能确定它是CBaseY* 还是 CDerived*，这时我们不得不用dynamic_cast<> 或typeid[2]。 注释： 1. dynamic_cast<>，从另一方面来说，可以防止一个泛型CBaseY* 被转换到CDerived*。 2. dynamic_cast<>需要类成为多态，即包括“虚”函数，并因此而不能成为void*。 dynamic_cast: 通常在基类和派生类之间转换时使用,run-time castconst_cast: 主要针对const和volatile的转换. static_cast: 一般的转换，no run-time check.通常，如果你不知道该用哪个，就用这个。 reinterpret_cast: 用于进行没有任何关联之间的转换，比如一个字符指针转换为一个整形数。 1）static_cast (a)编译器在编译期处理将地址a转换成类型T，T和a必须是指针、引用、算术类型或枚举类型。表达式static_cast (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 (pb); // 不安全, pb可能只是B的指针 B* pb2 = static_cast (pd); // 安全的 A* pa2 = static_cast (pb); //错误A与B没有继承关系 ...} 2）dynamic_cast (a)在运行期，会检查这个转换是否可能。完成类层次结构中的提升。T必须是一个指针、引用或无类型的指针。a必须是决定一个指针或引用的表达式。dynamic_cast 仅能应用于指针或者引用，不支持内置数据类型表达式dynamic_cast (a) 将a值转换为类型为T的对象指针。如果类型T不是a的某个基类型，该操作将返回一个空指针。它不仅仅像static_cast那样，检查转换前后的两个指针是否属于同一个继承树，它还要检查被指针引用的对象的实际类型，确定转换是否可行。如果可以，它返回一个新指针，甚至计算出为处理多继承的需要的必要的偏移量。如果这两个指针间不能转换，转换就会失败，此时返回空指针（NULL）。很明显，为了让dynamic_cast能正常工作，必须让编译器支持运行期类型信息（RTTI）。 3）const_cast (a)编译器在编译期处理去掉类型中的常量，除了const或不稳定的变址数，T和a必须是相同的类型。表达式const_cast (a)被用于从一个类中去除以下这些属性：const, volatile, 和 __unaligned。class A { ... };void f(){ const A *pa = new A;//const对象 A *pb;//非const对象 //pb = pa; // 这里将出错，不能将const对象指针赋值给非const对象 pb = const_cast (pa); // 现在OK了 ...}对于本身定义时为const的类型，即使你去掉const性，在你操作这片内容时候也要小心，只能r不能w操作，否则还是会出错const char* p = "123"; char* c = const_cast (p); c[0] = 1; //表面上通过编译去掉了const性，但是操作其地址时系统依然不允许这么做。const_cast操作不能在不同的种类间转换。相反，它仅仅把一个它作用的表达式转换成常量。它可以使一个本来不是const类型的数据转换成const类型的，或者把const属性去掉。尽量不要使用const_cast,如果发现调用自己的函数，竟然使用了const_cast，那就赶紧打住，重新考虑一下设计吧。 4）reinterpret_cast (a)编译器在编译期处理任何指针都可以转换成其它类型的指针，T必须是一个指针、引用、算术类型、指向函数的指针或指向一个类成员的指针。表达式reinterpret_cast (a)能够用于诸如char* 到 int*，或者One_class* 到 Unrelated_class*等类似这样的转换，因此可能是不安全的。class A { ... };class B { ... };void f(){ A* pa = new A; void* pv = reinterpret_cast (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 (n);这次, 结果有所不同. 在进行计算以后, d 包含无用值. 这是因为 reinterpret_cast 仅仅是复制 n 的比特位到 d, 没有进行必要的分析. 因此, 你需要谨慎使用 reinterpret_cast. reinterpret_casts的最普通的用途就是在函数指针类型之间进行转换。例如，假设你有一个函数指针数组：typedefvoid(*FuncPtr)();//FuncPtr is一个指向函数的指针，该函数没有参数,返回值类型为voidFuncPtrfuncPtrArray[10];//funcPtrArray是一个能容纳10个FuncPtrs指针的数组 让我们假设你希望（因为某些莫名其妙的原因）把一个指向下面函数的指针存入funcPtrArray数组：int doSomething(); 你不能不经过类型转换而直接去做，因为doSomething函数对于funcPtrArray数组来说有一个错误的类型。在FuncPtrArray数组里的函数返回值是void类型，而doSomething函数返回值是int类型。 funcPtrArray[0] = &doSomething;//错误！类型不匹配reinterpret_cast可以让你迫使编译器以你的方法去看待它们：funcPtrArray[0] = reinterpret_cast (&doSomething);转换函数指针的代码是不可移植的（C++不保证所有的函数指针都被用一样的方法表示），在一些情况下这样的转换会产生不正确的结果 'dynamic_cast'只用于对象的指针和引用 从派生类指针用dynamic_cast转为基类指针CBaseY时，不做任何检测 但是如果是从基类指针转为派生类指针时，会检查两个方面：1. 它会检查转换是否会返回一个被请求的有效的完整对象。不是的话返回null 2. 基类指针是否有虚函数，没有的话，编译不通过
转载地址：http://pfeti.baihongyu.com/