标准c++中主要有四种强制转换类型运算符

先声明是从别人那里转来的，原文地址：http://www.doserver.net/read.php?520

 

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