dynamic_cast: 通常在基类和派生类之间转换时使用,run-time cast const_cast: 主要针对const和volatile的转换. static_cast: 一般的转换

http://bbs.csdn.net/topics/70053213

dynamic_cast: 通常在基类和派生类之间转换时使用,run-time cast

const_cast: 主要针对const和volatile的转换.

static_cast: 一般的转换，no run-time check.通常，如果你不知道该用哪个，就用这个。

reinterpret_cast: 用于进行没有任何关联之间的转换，比如一个字符指针转换为一个整形数。

这些偏重于口语化解释，最好还是看看书，讲述标准c＋＋的教材上都会有的。

//-------------------------------------------------------------------------------------------------------------------------

http://www.cppblog.com/iuranus/archive/2009/06/22/88257.html

1. 标准c++中主要有四种强制转换类型运算符：  
2.   
3. const_cast，reinterpret_cast，static_cast，dynamic_cast等等。  
4. 
   
5. 1）static_cast<T*>(a)  
6.   
7. 将地址a转换成类型T，T和a必须是指针、引用、算术类型或枚举类型。  
8.   
9. 表达式static_cast<T*>(a), a的值转换为模板中指定的类型T。在运行时转换过程中，不进行类型检查来确保转换的安全性。  
10.   
11. 例子：  
12. 
    
13. class B { ... };  
14.   
15. class D : public B { ... };  
16.   
17. void f(B* pb, D* pd)  
18. {  
19.   
20.    D* pd2 = static_cast<D*>(pb);        // 不安全, pb可能只是B的指针  
21. 
    
22.    B* pb2 = static_cast<B*>(pd);        // 安全的  
23.    ...  
24. }  
25. 
    
26. class B { ... };  
27.   
28. class D : public B { ... };  
29. void f(B* pb, D* pd)  
30. {  
31.    D* pd2 = static_cast<D*>(pb);        // 不安全, pb可能只是B的指针  
32.    B* pb2 = static_cast<B*>(pd);        // 安全的  
33.    ...  
34. }  
35.  
36. class B { ... };  
37. class D : public B { ... };  
38. void f(B* pb, D* pd)  
39. {  
40.    D* pd2 = static_cast<D*>(pb);        // 不安全, pb可能只是B的指针  
41.    B* pb2 = static_cast<B*>(pd);        // 安全的  
42.   ...  
43. }  
44. 
    
45. 2）dynamic_cast<T*>(a)  
46.   
47. 完成类层次结构中的提升。T必须是一个指针、引用或无类型的指针。a必须是决定一个指针或引用的表达式。  
48.   
49. 表达式dynamic_cast<T*>(a) 将a值转换为类型为T的对象指针。如果类型T不是a的某个基类型，该操作将返回一个空指针。  
50. 
    
51. 例子：  
52.   
53. class A { ... };  
54.   
55. class B { ... };  
56.   
57. void f()   
58. {  
59.   A* pa = new A;    
60.   B* pb = new B;    
61.   void* pv = dynamic_cast<A*>(pa);    
62.   // pv 现在指向了一个类型为A的对象  
63.   ...   
64.   pv = dynamic_cast<B*>(pb);    
65.   // pv 现在指向了一个类型为B的对象  
66.   
67. }  
68. 
    
69.   
70. 3）const_cast<T*>(a)  
71.   
72. 去掉类型中的常量，除了const或不稳定的变址数，T和a必须是相同的类型。  
73.   
74. 表达式const_cast<T*>(a)被用于从一个类中去除以下这些属性：const, volatile, 和 __unaligned。  
75. 
    
76. 例子：  
77.   
78. class A { ... };  
79.   
80. void f()   
81. {    
82.  const A *pa = new A;//const对象   
83.  A *pb;//非const对象  
84.  
85. //pb = pa; // 这里将出错，不能将const对象指针赋值给非const对象  
86.  pb = const_cast<A*>(pa); // 现在OK了  
87. ...  
88. }  
89.    
90. class A { ... };  
91.   
92. void f()  
93. {  
94.  const A *pa = new A;//const对象    
95.  A *pb;//非const对象  
96. 
    
97. //pb = pa; // 这里将出错，不能将const对象指针赋值给非const对象  
98.   
99.  pb = const_cast<A*>(pa); // 现在OK了  
100. ...  
101. }  
102. 
     
103. class A { ... };  
104. void f()  
105. {    
106.  const A *pa = new A;//const对象   
107.  A *pb;//非const对象  
108. //pb = pa; // 这里将出错，不能将const对象指针赋值给非const对象  
109.  pb = const_cast<A*>(pa); // 现在OK了  
110. ...   
111. }  
112.   
113. 4）reinterpret_cast<T*>(a)  
114.   
115. 任何指针都可以转换成其它类型的指针，T必须是一个指针、引用、算术类型、指向函数的指针或指向一个类成员的指针。  
116.   
117. 表达式reinterpret_cast<T*>(a)能够用于诸如char* 到 int*，或者One_class* 到 Unrelated_class*等类似这样的转换，因此可能是不安全的。  
118. 
     
119. 例子：  
120.   
121. class A { ... };  
122.   
123. class B { ... };  
124.   
125. void f()  
126.   
127. {  
128.   A* pa = new A;   
129.   void* pv = reinterpret_cast<A*>(pa);   
130.   // pv 现在指向了一个类型为B的对象，这可能是不安全的  
131.   ...   
132. }