强制类型转换函数使用说明

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.   
43.   
44.   
45.   
46.   
47. class B { ... };   
48.   
49. class D : public B { ... };   
50.   
51. void f(B* pb, D* pd)   
52.   
53. {   
54.   
55.    D* pd2 = static_cast<D*>(pb);        // 不安全, pb可能只是B的指针   
56.   
57.   
58.   
59.   
60.    B* pb2 = static_cast<B*>(pd);        // 安全的   
61.   
62.    ...   
63.   
64. }   
65.   
66.   
67.   
68.   
69.   
70.   
71.   
72. class B { ... };   
73.   
74. class D : public B { ... };   
75.   
76. void f(B* pb, D* pd)   
77.   
78. {   
79.   
80.    D* pd2 = static_cast<D*>(pb);        // 不安全, pb可能只是B的指针   
81.   
82.   
83.   
84.   
85.    B* pb2 = static_cast<B*>(pd);        // 安全的   
86.   
87.    ...   
88.   
89. }   
90.   
91.   
92.   
93.   
94. 2）dynamic_cast<T*>(a)   
95.   
96. 完成类层次结构中的提升。T必须是一个指针、引用或无类型的指针。a必须是决定一个指针或引用的表达式。   
97.   
98. 表达式dynamic_cast<T*>(a) 将a值转换为类型为T的对象指针。如果类型T不是a的某个基类型，该操作将返回一个空指针。   
99.   
100.   
101.   
102.   
103. 例子：   
104.   
105. class A { ... };   
106.   
107. class B { ... };   
108.   
109. void f()   
110.   
111. {   
112.   
113.   A* pa = new A;   
114.   
115.   B* pb = new B;   
116.   
117.   void* pv = dynamic_cast<A*>(pa);   
118.   
119.   // pv 现在指向了一个类型为A的对象   
120.   
121.   ...   
122.   
123.   pv = dynamic_cast<B*>(pb);   
124.   
125.   // pv 现在指向了一个类型为B的对象   
126.   
127. }   
128.   
129.   
130.   
131.   
132. 3）const_cast<T*>(a)   
133.   
134. 去掉类型中的常量，除了const或不稳定的变址数，T和a必须是相同的类型。   
135.   
136. 表达式const_cast<T*>(a)被用于从一个类中去除以下这些属性：const, volatile, 和 __unaligned。   
137.   
138.   
139.   
140.   
141. 例子：   
142.   
143.   
144.   
145.   
146.   
147.   
148.   
149. class A { ... };   
150.   
151. void f()   
152.   
153. {   
154.   
155.  const A *pa = new A;//const对象   
156.   
157.  A *pb;//非const对象   
158.   
159.   
160.   
161.   
162. //pb = pa; // 这里将出错，不能将const对象指针赋值给非const对象   
163.   
164.  pb = const_cast<A*>(pa); // 现在OK了   
165.   
166. ...   
167.   
168. }   
169.   
170.   
171.   
172.   
173.   
174.   
175.   
176. class A { ... };   
177.   
178. void f()   
179.   
180. {   
181.   
182.  const A *pa = new A;//const对象   
183.   
184.  A *pb;//非const对象   
185.   
186.   
187.   
188.   
189. //pb = pa; // 这里将出错，不能将const对象指针赋值给非const对象   
190.   
191.  pb = const_cast<A*>(pa); // 现在OK了   
192.   
193. ...   
194.   
195. }   
196.   
197.   
198.   
199.   
200.   
201.   
202.   
203. class A { ... };   
204.   
205. void f()   
206.   
207. {   
208.   
209.  const A *pa = new A;//const对象   
210.   
211.  A *pb;//非const对象   
212.   
213.   
214.   
215.   
216. //pb = pa; // 这里将出错，不能将const对象指针赋值给非const对象   
217.   
218.  pb = const_cast<A*>(pa); // 现在OK了   
219.   
220. ...   
221.   
222. }   
223.   
224.   
225.   
226.   
227. 4）reinterpret_cast<T*>(a)   
228.   
229. 任何指针都可以转换成其它类型的指针，T必须是一个指针、引用、算术类型、指向函数的指针或指向一个类成员的指针。   
230.   
231. 表达式reinterpret_cast<T*>(a)能够用于诸如char* 到 int*，或者One_class* 到 Unrelated_class*等类似这样的转换，因此可能是不安全的。   
232.   
233.   
234.   
235.   
236. 例子：   
237.   
238. class A { ... };   
239.   
240. class B { ... };   
241.   
242. void f()   
243.   
244. {   
245.   
246.   A* pa = new A;   
247.   
248.   void* pv = reinterpret_cast<A*>(pa);   
249.   
250.   // pv 现在指向了一个类型为B的对象，这可能是不安全的   
251.   
252.   ...   
253.   
254. }   

尽量使用C++风格的类型转换 仔细想想地位卑贱的类型转换功能（cast），其在程序设计中的地位就象goto语句一样令人鄙视。但是它还不是无法令人忍受，因为当在某些紧要的关头，类型转换还是必需的，这时它是一个必需品。 不过C风格的类型转换并不代表所有的类型转换功能。 一来它们过于粗鲁，能允许你在任何类型之间进行转换。不过如果要进行更精确的类型转换，这会是一个优点。在这些类型转换中存在着巨大的不同，例如把一个指向const对象的指针（pointer-to-const-object）转换成指向非const对象的指针（pointer-to-non-const-object）(即一个仅仅去除const的类型转换)，把一个指向基类的指针转换成指向子类的指针（即完全改变对象类型）。传统的C风格的类型转换不对上述两种转换进行区分。（这一点也不令人惊讶，因为C风格的类型转换是为C语言设计的，而不是为C++语言设计的）。 二来C风格的类型转换在程序语句中难以识别。在语法上，类型转换由圆括号和标识符组成，而这些可以用在C＋＋中的任何地方。这使得回答象这样一个最基本的有关类型转换的问题变得很困难：“在这个程序中是否使用了类型转换？”。这是因为人工阅读很可能忽略了类型转换的语句，而利用象grep的工具程序也不能从语句构成上区分出它们来。 C++通过引进四个新的类型转换操作符克服了C风格类型转换的缺点，这四个操作符是, static_cast, const_cast, dynamic_cast, 和reinterpret_cast。在大多数情况下，对于这些操作符你只需要知道原来你习惯于这样写， (type) expression 而现在你总应该这样写： static_cast<type>(expression) 例如，假设你想把一个int转换成double，以便让包含int类型变量的表达式产生出浮点数值的结果。如果用C风格的类型转换，你能这样写： int firstNumber, secondNumber; ... double result = ((double)firstNumber)/secondNumber； 如果用上述新的类型转换方法，你应该这样写： double result = static_cast<double>(firstNumber)/secondNumber; 这样的类型转换不论是对人工还是对程序都很容易识别。 static_cast在功能上基本上与C风格的类型转换一样强大，含义也一样。它也有功能上限制。例如，你不能用static_cast象用C风格的类型转换一样把struct转换成int类型或者把double类型转换成指针类型，另外，static_cast不能从表达式中去除const属性，因为另一个新的类型转换操作符const_cast有这样的功能。 其它新的C++类型转换操作符被用在需要更多限制的地方。const_cast用于类型转换掉表达式的const或volatileness属性。通过使用const_cast，你向人们和编译器强调你通过类型转换想做的只是改变一些东西的constness或者volatileness属性。这个含义被编译器所约束。如果你试图使用const_cast来完成修改constness 或者volatileness属性之外的事情，你的类型转换将被拒绝。下面是一些例子： class Widget { ... }; class SpecialWidget: public Widget { ... }; void update(SpecialWidget *psw); SpecialWidget sw; // sw 是一个非const 对象。 const SpecialWidget& csw = sw; // csw 是sw的一个引用 // 它是一个const 对象 update(&csw); // 错误!不能传递一个const SpecialWidget* 变量 // 给一个处理SpecialWidget*类型变量的函数 update(const_cast<SpecialWidget*>(&csw)); // 正确，csw的const被显示地转换掉（ // csw和sw两个变量值在update //函数中能被更新） update((SpecialWidget*)&csw); // 同上，但用了一个更难识别 //的C风格的类型转换 Widget *pw = new SpecialWidget; update(pw); // 错误！pw的类型是Widget*，但是 // update函数处理的是SpecialWidget*类型 update(const_cast<SpecialWidget*>(pw)); // 错误！const_cast仅能被用在影响 // constness or volatileness的地方上。, // 不能用在向继承子类进行类型转换。 到目前为止，const_cast最普通的用途就是转换掉对象的const属性。 第二种特殊的类型转换符是dynamic_cast，它被用于安全地沿着类的继承关系向下进行类型转换。这就是说，你能用dynamic_cast把指向基类的指针或引用转换成指向其派生类或其兄弟类的指针或引用，而且你能知道转换是否成功。失败的转换将返回空指针（当对指针进行类型转换时）或者抛出异常（当对引用进行类型转换时）： Widget *pw; ... update(dynamic_cast<SpecialWidget*>(pw)); // 正确，传递给update函数一个指针 // 是指向变量类型为SpecialWidget的pw的指针 // 如果pw确实指向一个对象, // 否则传递过去的将使空指针。 void updateViaRef(SpecialWidget& rsw); updateViaRef(dynamic_cast<SpecialWidget&>(*pw)); //正确。传递给updateViaRef函数 // SpecialWidget pw 指针，如果pw // 确实指向了某个对象 // 否则将抛出异常 dynamic_casts在帮助你浏览继承层次上是有限制的。它不能被用于缺乏虚函数的类型上（参见条款M24），也不能用它来转换掉constness： int firstNumber, secondNumber; ... double result = dynamic_cast<double>(firstNumber)/secondNumber; // 错误！没有继承关系 const SpecialWidget sw; ... update(dynamic_cast<SpecialWidget*>(&sw)); // 错误! dynamic_cast不能转换 // 掉const。 如你想在没有继承关系的类型中进行转换，你可能想到static_cast。如果是为了去除const，你总得用const_cast。 这四个类型转换符中的最后一个是reinterpret_cast。使用这个操作符的类型转换，其的转换结果几乎都是执行期定义（implementation-defined）。因此，使用reinterpret_casts的代码很难移植。 reinterpret_casts的最普通的用途就是在函数指针类型之间进行转换。例如，假设你有一个函数指针数组： typedef void (*FuncPtr)(); // FuncPtr is 一个指向函数 // 的指针，该函数没有参数 // 返回值类型为void FuncPtr funcPtrArray[10]; // funcPtrArray 是一个能容纳 // 10个FuncPtrs指针的数组 让我们假设你希望（因为某些莫名其妙的原因）把一个指向下面函数的指针存入funcPtrArray数组： int doSomething(); 你不能不经过类型转换而直接去做，因为doSomething函数对于funcPtrArray数组来说有一个错误的类型。在FuncPtrArray数组里的函数返回值是void类型，而doSomething函数返回值是int类型。 funcPtrArray[0] = &doSomething; // 错误！类型不匹配 reinterpret_cast可以让你迫使编译器以你的方法去看待它们： funcPtrArray[0] = // this compiles reinterpret_cast<FuncPtr>(&doSomething); 转换函数指针的代码是不可移植的（C++不保证所有的函数指针都被用一样的方法表示），在一些情况下这样的转换会产生不正确的结果（参见条款M31），所以你应该避免转换函数指针类型，除非你处于着背水一战和尖刀架喉的危急时刻。一把锋利的刀。一把非常锋利的刀。 如果你使用的编译器缺乏对新的类型转换方式的支持，你可以用传统的类型转换方法代替static_cast, const_cast, 以及reinterpret_cast。也可以用下面的宏替换来模拟新的类型转换语法： #define static_cast(TYPE,EXPR) ((TYPE)(EXPR)) #define const_cast(TYPE,EXPR) ((TYPE)(EXPR)) #define reinterpret_cast(TYPE,EXPR) ((TYPE)(EXPR)) 你可以象这样使用使用： double result = static_cast(double, firstNumber)/secondNumber; update(const_cast(SpecialWidget*, &sw)); funcPtrArray[0] = reinterpret_cast(FuncPtr, &doSomething); 这些模拟不会象真实的操作符一样安全，但是当你的编译器可以支持新的的类型转换时，它们可以简化你把代码升级的过程。 没有一个容易的方法来模拟dynamic_cast的操作，但是很多函数库提供了函数，安全地在派生类与基类之间进行类型转换。如果你没有这些函数而你有必须进行这样的类型转换，你也可以回到C风格的类型转换方法上，但是这样的话你将不能获知类型转换是否失败。当然，你也可以定义一个宏来模拟dynamic_cast的功能，就象模拟其它的类型转换一样： #define dynamic_cast(TYPE,EXPR) (TYPE)(EXPR) 请记住，这个模拟并不能完全实现dynamic_cast的功能，它没有办法知道转换是否失败。 我知道，是的，我知道，新的类型转换操作符不是很美观而且用键盘键入也很麻烦。如果你发现它们看上去实在令人讨厌，C风格的类型转换还可以继续使用并且合法。然而，正是因为新的类型转换符缺乏美感才能使它弥补了在含义精确性和可辨认性上的缺点。并且，使用新类型转换符的程序更容易被解析（不论是对人工还是对于工具程序），它们允许编译器检测出原来不能发现的错误。这些都是放弃C风格类型转换方法的强有力的理由。还有第三个理由：也许让类型转换符不美观和键入麻烦是一件好事。