有谁知道下面四种类型转换用在什么地方?

[gyj_china]

dynamic_cast、static_cast、reinterpret_cast、const_cast一般用于什么情况下的转换。
最好能说明其优缺点，呵呵~~谢谢大家

[chin_chen]

   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. }  

[vk2211]

也想知道个全面的

[chin_chen]

强制转化四种类型可能很多人都常常忽略就象我一样，但是有时还是比较有用的。不了解的建议看看，一些机制我也不是十分了解，只是将一些用法写出来让大家看看。

强制转化无论从语法还是语意上看，都是c++中最难看的特征之一。但是基于c风格的转化的语义的不明确性及其一些潜在问题。强制类型转化最终还是被c++接受了。

1.static_cast运算符号
static_cast<T>(e),stroustrup让我们可以把它看成隐含转换的显示的逆运算。这个是有一定道理的，基于隐式转化的对象类型我们可以使用static_cast转化运算符号。它是静态的检测，无法运行时检测类型，在继承中尤为突出。

2.reinterpret_cast 运算
主要用于对于类型指针类型的强制转化，some_type* -> special_type*这样转化，类型信息可以是不完全的。它允许将任意指针转化到其他类型指针，也允许任意整数类型到任意指针类型转化(BT)。这样导致的结果是极其不安全的，不能安全的应用于其他目的，除非转化到原来类型。
<1> 使用所有整形可以转化为任意类型的指针(指针是4字节的long的东东，那么机器就认为同类型就是可以转化)
int c;
x* p = reinterpret_cast<x*>(c); //x是自定义的任意类型，当然包括系统类型
<2> 可以对于任意类型指针之间转化
y* c;
x* p = reinterpret_cast<x*>(c);//x,y代表所有自定义或系统类型
大家可以看到reinterpret_cast的转化是极度的不负责任的，他只管转化不检测是否可以转化。

3. const_cast运算符号
这个很简单从名字大家可以看出来，仅仅为了去掉或着加上const修饰符号。但是对于本身定义时为const的类型，即使你去掉const性，在你操作这片内容时候也要小心，只能r不能w操作，否则还是会出错。
const char* p = "123";
char* c = const_cast<char*>(p);
c[0] = 1; //表面上通过编译去掉了const性，但是操作其地址时系统依然不允许这
//么做。这是一个漏洞吧

4. dynamic_cast运算符号
Scott Mayers将其描述为用来执行继承体系中：安全的向下转型或者跨系转型动作。也就是说你可以，用dynamic_cast将 指向base class的指针或引用转型为 指向子类的对象的指针或引用。
class B {}; //polymorphic类型含virtual才能dynamic_cast
class D: public B {}
void f( B* pb )
{
D* pd1 = dynamic_cast<D*>(pb);//如果pb为d类型正确返回，如果不是返回0
D* pd2 = static_cast<D*>(pb); //不管怎么样都返回指针有可能指向不合适的对
//象，因为static仅仅静态检测，不能得到运
//行时对象的信息是否真正为D类型
}

反正大家在使用知道怎么用就ok了，c++强制转化在模板中还是非常有用的，其他时候本人也喜欢用c的转化方便。^_^

再贴个口语化的，呵呵，csdn上边都有。
http://topic.csdn.net/t/20050120/19/3741897.html

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

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

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

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

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

[猫已经找不回了]

1楼太全了，不多说了。。。纯up过。

[lingyin55]

纯up~

[tianma2005123]

为啥1楼要1种类型粘贴好几遍呢？

[na2650945]

[Quote=引用 3 楼 chin_chen 的回复:]
强制转化四种类型可能很多人都常常忽略就象我一样，但是有时还是比较有用的。不了解的建议看看，一些机制我也不是十分了解，只是将一些用法写出来让大家看看。

强制转化无论从语法还是语意上看，都是c++中最难看的特征之一。但是基于c风格的转化的语义的不明确性及其一些潜在问题。强制类型转化最终还是被c++接受了。

1.static_cast运算符号
static_cast <T>(e),stroustrup让我们可以把它看成隐含转换的显示的逆运算。…
[/Quote]
算是正解吧。
反正不建议使用。
按咱老师的话说。
因为不建议使用。
所以把名字弄这么长。

[zhoulehua]

1楼不错。