非常抱歉，謝謝郭老師的指正，我沒有認真看這個文章就轉過來了，其實他的錯誤太多了，而且還是致命的，對大家不負責任了，請大家諒解！現在是修正版本，基本沒有錯誤了！如果覺得還有問題，請聯系我，謝謝你的關注！
這篇文章其實并不是不才的原創，本來打算自己寫的，但是通過baidu一下，發現有兄弟寫出來了，就干脆摘錄下來，供大家參考使用了！
詳情請看：


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


如果不明白，可以給我留言！