C++中的Cast的用法总结

C++中的Cast

引言

在一次看More Effective C++中，有一节提到了《Prefer C++-Style Casts》。其中列举许多C++ Cast的一些好处，当然这些都是相对于C语言中的强制转换这类而言的。

所以首先来了解C++中的Cast。

一、Dynamic_Cast

我们从适用范围来了解这个操作。

（1）首先dynamic_cast能够应用于指针转换。

子类指针转换成父类指针，成功；

父类指针转换成子类指针，就分为两种情况：

      <a>父类指针p如果真的指向子类对象，那么转换时成功的；

      <b>反之，失败，dynamic_cast返回NULL。

（2）其次dynamic_cast能够应用与引用之间的转换（与指针类似）。

子类引用转换成父类引用，成功；

父类引用转换成子类引用，就分为两种情况：

       <a>父类引用ob，如果真的指向子类对象，那么转换时成功的；

      <b>反之，失败，dynamic_cast，会抛出bad_cast异常

（3）其他将null指针，转换成任何类型的指针；将任何类型的指针转换成void*类型的指针。

 

参考代码：

[cpp]  view plain copy print ?

1. class CBase  
2. {  
3. protected:  
4.     int m_data;  
5. public:  
6.     virtual void fun(){}  
7. };  
8. class CSub1 : publicCBase  
9. {  
10. protected:  
11.     intm_data_a;  
12. };  
13. class CSub2 : publicCBase  
14. {  
15. protected:  
16.     longm_data_b;  
17. };  
18. //  
19. void test_dynamic_cast()  
20. {  
21.     CBase * pb = newCBase();  
22.     CSub1 * p1 = newCSub1();  
23.    
24.     charstrTrue[] = "true";  
25.     charstrFalse[] = "false";  
26.     //cast a class toits base class  
27.     CBase * p = dynamic_cast<CBase*>(p1);  
28.     cout<<"dynamic_cast<CBase *>(p1); is ok? "<< ((p != NULL) ? "true" : "false")<<endl;  
29.     //cast a class toits derived class  
30.     CSub1 * pSub1 = dynamic_cast<CSub1*>(pb);  
31.     cout<<"dynamic_cast<CSub1 *>(pb); is ok? "<< ((pSub1 != NULL)? "true" : "false") <<endl;  
32.    
33.     delete pb;  
34.     delete p1;  
35.     //  
36.     try  
37.     {  
38.         CBase obb;  
39.         CSub1 obsub1;  
40.         CBase & ob1 = dynamic_cast<CBase &>(obsub1);  
41.         CSub1 & ob2 = dynamic_cast<CSub1 &>(obb);  
42.     }  
43.     catch(bad_cast e)  
44.     {  
45.          
46.     }  
47.      
48. }  

二、Static_Cast

Static_cast可以转换相关联的类，可以从子类转换成父类。也能从父类转向子类，但是如果转换的父类指针（或者父类引用）所指向的对象是完整的，那么是没有问题；但是如果所指向的对象并不完整，那么会出现runtime错误。

Static_cast相对于dynamic_cast而言，除了能转换指针和引用，还能应用于任何能够隐式转换的情况。比如下面的情况。

[cpp]  view plain copy print ?

1. void test_static_cast()  
2. {  
3.     float f =1.012;  
4.     int i = static_cast<int>(f);  
5. }  

三、Reinterpret_Cast

reinterpret_cast和上面讲到的两个cast，适用范围更加广泛。它可以适用于任何类型指针之间的转换。

该操作不会去进行动态类型或者静态类型的检测，它仅仅将值强行赋值过去。从某种意义上对编译器进行了一种欺骗，同时也带来了一定的不安全性。所以在使用这个cast的时候，要慎重。下面是这个操作的适用情况：

（1）   Int和指针之间的相互转换；

（2）   无关联类指针之间的转换；

（3）   函数指针之间的转换

 

下面是这个操作的使用实例：

[cpp]  view plain copy print ?

1. class A  
2. {  
3. public:  
4.     A(inti):m_data(i){}  
5.     int m_data;  
6. };  
7. class B  
8. {  
9. public:  
10.     B(floatf):m_data(f){}  
11.     floatm_data;  
12. };  
13. class C  
14. {  
15. public:  
16.     C(long long ll):m_date(ll){}  
17.     long long m_date;  
18. };  
19. void test_reinterpret_cast()  
20. {  
21.     A * pa = newA(1);  
22.     B * pb = newB(1.12);  
23.     C * pc = newC(121321312321);  
24.     //  
25.     A * p1 = reinterpret_cast<A*>(pb);  
26.     cout<<"  reinterpret_cast<A *>(pb); is ok?"<< ((p1 != NULL) ? "true": "false") <<endl;  
27.     cout<<p1->m_data<<endl;  
28.     p1 = reinterpret_cast<A*>(pc);  
29.     cout<<"  reinterpret_cast<A *>(pc); is ok?"<< ((p1 != NULL) ? "true": "false") <<endl;  
30.     cout<<p1->m_data<<endl;  
31.    
32.     //  
33.     delete pa;  
34.     delete pb;  
35.     delete pc;  
36. }  

结果：

四、Const_Cast

const_cast如它的名字，它是去除修饰在对象上的const和volatile。

 

五、总结

这里借用more effective c++中的观点：隐式转换，在代码中很难寻找；但是使用C++的这种cast可以轻松的找出，代码中哪里使用强制转换等。去除了c语言中转换之间的恶习，将它们规范成了几个operator。