关闭

总结C++中的所有强制转换函数(const_cast,reinterpret_cast,static_cast,dynamic_cast)

275人阅读 评论(0) 收藏 举报
这篇文章其实并不是不才的原创,本来打算自己写的,但是通过baidu一下,发现有兄弟写出来了,就干脆摘录下来,供大家参考使用了!
详情请看:


  1. 标准c++中主要有四种强制转换类型运算符:  
  2.   
  3. const_castreinterpret_caststatic_castdynamic_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)被用于从一个类中去除以下这些属性:constvolatile, 和 __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. }  


如果不明白,可以给我留言!


0
0

查看评论
* 以上用户言论只代表其个人观点,不代表CSDN网站的观点或立场