C++的四种强制类型转换

C++的四种强制类型转换，所以C++不是类型安全的。分别为：static_cast , dynamic_cast , const_cast , reinterpret_cast
为什么使用C风格的强制转换可以把想要的任何东西转换成合乎心意的类型。那为什么还需要一个新的C++类型的强制转换呢？
新类型的强制转换可以提供更好的控制强制转换过程，允许控制各种不同种类的强制转换。C++中风格是static_cast<type>(content)。C++风格的强制转换其他的好处是，它们能更清晰的表明它们要干什么。程序员只要扫一眼这样的代码，就能立即知道一个强制转换的目的。
四种转换的区别：

1、static_cast:可以实现C++中内置基本数据类型之间的相互转换。

[cpp]  view plain  copy

 

1. int c=static_cast<int>(7.987);   

如果涉及到类的话，static_cast只能在有相互联系的类型中进行相互转换,不一定包含虚函数。

[cpp]  view plain  copy

 

1. class A   
2. {};   
3. class B:public A   
4. {};   
5. class C   
6. {};   
7.   
8. int main()   
9. {   
10.     A* a=new A;   
11.     B* b;   
12.     C* c;   
13.     b=static_cast<B>(a);  // 编译不会报错, B类继承A类   
14.     c=static_cast<B>(a);  // 编译报错, C类与A类没有任何关系   
15.     return 1;   
16. }  

2、const_cast操作不能在不同的种类间转换。

相反，它仅仅把一个它作用的表达式转换成常量。它可以使一个本来不是const类型的数据转换成const类型的，或者把const属性去掉。

3、reinterpret_cast:  有着和C风格的强制转换同样的能力。它可以转化任何内置的数据类型为其他任何的数据类型，也可以转化任何指针类型为其他的类型。它甚至可以转化内置的数据类型为指针，无须考虑类型安全或者常量的情形。不到万不得已绝对不用。

4、dynamic_cast: 

（1）其他三种都是编译时完成的，dynamic_cast是运行时处理的，运行时要进行类型检查。
（2）不能用于内置的基本数据类型的强制转换。
（3）dynamic_cast转换如果成功的话返回的是指向类的指针或引用，转换失败的话则会返回NULL。
（4）使用dynamic_cast进行转换的，基类中一定要有虚函数，否则编译不通过。
        B中需要检测有虚函数的原因：类中存在虚函数，就说明它有想要让基类指针或引用指向派生类对象的情况，此时转换才有意义。 
        这是由于运行时类型检查需要运行时类型信息，而这个信息存储在类的虚函数表（关于虚函数表的概念，详细可见<Inside c++ object model>）中，
        只有定义了虚函数的类才有虚函数表。
 （5）在类的转换时，在类层次间进行上行转换时，dynamic_cast和static_cast的效果是一样的。在进行下行转换时，dynamic_cast具有类型检查的功能，比static_cast更安全。向上转换即为指向子类对象的向下转换，即将父类指针转化子类指针。向下转换的成功与否还与将要转换的类型有关，即要转换的指针指向的对象的实际类型与转换以后的对象类型一定要相同，否则转换失败。
参考例子:

[cpp]  view plain  copy

 

1. #include<iostream>   
2. #include<cstring>   
3. using namespace std;   
4. class A   
5. {   
6.    public:   
7.    virtual void f()   
8.    {   
9.        cout<<"hello"<<endl;   
10.        };   
11. };   
12.   
13. class B:public A   
14. {   
15.     public:   
16.     void f()   
17.     {   
18.         cout<<"hello2"<<endl;   
19.         };   
20.   
21. };   
22.   
23. class C   
24. {   
25.   void pp()   
26.   {   
27.       return;   
28.   }   
29. };   
30.   
31. int fun()   
32. {   
33.     return 1;   
34. }   
35. int main()   
36. {   
37.     A* a1=new B;//a1是A类型的指针指向一个B类型的对象   
38.     A* a2=new A;//a2是A类型的指针指向一个A类型的对象   
39.     B* b;   
40.     C* c;   
41.     b=dynamic_cast<B*>(a1);//结果为not null，向下转换成功，a1之前指向的就是B类型的对象，所以可以转换成B类型的指针。   
42.     if(b==NULL)   
43.     {   
44.         cout<<"null"<<endl;   
45.     }   
46.     else  
47.     {   
48.         cout<<"not null"<<endl;   
49.     }   
50.     b=dynamic_cast<B*>(a2);//结果为null，向下转换失败   
51.     if(b==NULL)   
52.     {   
53.         cout<<"null"<<endl;   
54.     }   
55.     else  
56.     {   
57.         cout<<"not null"<<endl;   
58.     }   
59.     c=dynamic_cast<C*>(a);//结果为null，向下转换失败   
60.     if(c==NULL)   
61.     {   
62.         cout<<"null"<<endl;   
63.     }   
64.     else  
65.     {   
66.         cout<<"not null"<<endl;   
67.     }   
68.     delete(a);   
69.     return 0;   
70. }  
71.   
72. 详细出处参考：http://www.jb51.net/article/36914.htm