http://www.cnblogs.com/cutepig/archive/2009/02/10/1387761.htmldynamic_cast: 通常在基類和派生類之間轉(zhuǎn)換時(shí)使用,run-time cast
const_cast: 主要針對(duì)const和volatile的轉(zhuǎn)換.
static_cast: 一般的轉(zhuǎn)換，no run-time check.通常，如果你不知道該用哪個(gè)，就用這個(gè)。
reinterpret_cast: 用于進(jìn)行沒有任何關(guān)聯(lián)之間的轉(zhuǎn)換，比如一個(gè)字符指針轉(zhuǎn)換為一個(gè)整形數(shù)。
http://blog.csdn.net/goodluckyxl/archive/2005/01/19/259851.aspx
強(qiáng)制轉(zhuǎn)化四種類型可能很多人都常常忽略就象我一樣，但是有時(shí)還是比較有用的。不了解的建議看看，一些機(jī)制我也不是十分了解，只是將一些用法寫出來讓大家看看。
2004-11-27 9:00
強(qiáng)制轉(zhuǎn)化無論從語法還是語意上看，都是c++中最難看的特征之一。但是基于c風(fēng)格的轉(zhuǎn)化的語義的不明確性及其一些潛在問題。強(qiáng)制類型轉(zhuǎn)化最終還是被c++接受了。
1.static_cast運(yùn)算符號(hào)
static_cast<T>(e),stroustrup讓我們可以把它看成隱含轉(zhuǎn)換的顯示的逆運(yùn)算。這個(gè)是有一定道理的，基于隱式轉(zhuǎn)化的對(duì)象類型我們可以使用static_cast轉(zhuǎn)化運(yùn)算符號(hào)。它是靜態(tài)的檢測(cè)，無法運(yùn)行時(shí)檢測(cè)類型，在繼承中尤為突出。
使用范圍
<1>用于所有系統(tǒng)類型之間轉(zhuǎn)化，不能用于系統(tǒng)類型指針類型轉(zhuǎn)化
double t_d = 0;
int t_i= static_cast<int>(t_d); //是合法的轉(zhuǎn)化
而企圖將double*->int*是不允許的
<2>用于繼承類之間的轉(zhuǎn)化（含指針），不能用于其他沒有隱式轉(zhuǎn)化的對(duì)象類型之間的轉(zhuǎn)化
繼承舉例:
class x
{
};
class y: public x
{
};
使用:x t_o_x;
y t_o_y = static_cast<y>(t_o_x); //x* y*轉(zhuǎn)化也可以進(jìn)行因?yàn)閤,y繼承關(guān)
//系，類型可以自動(dòng)隱式轉(zhuǎn)化使用
隱式轉(zhuǎn)化舉例:
class x
{
};
class y
{
public:
y( x i_x ) {}
};
x t_o_x;
y t_o_y = static_cast<y>(t_o_x); //大家看到y(tǒng)構(gòu)造函數(shù)可以對(duì)于x類型隱式轉(zhuǎn)化
//所以可以將x->y，如果企圖將y->x會(huì)報(bào)錯(cuò)
2.reinterpret_cast 運(yùn)算
主要用于對(duì)于類型指針類型的強(qiáng)制轉(zhuǎn)化，some_type* -> special_type*這樣轉(zhuǎn)化，類型信息可以是不完全的。它允許將任意指針轉(zhuǎn)化到其他類型指針，也允許任意整數(shù)類型到任意指針類型轉(zhuǎn)化(BT)。這樣導(dǎo)致的結(jié)果是極其不安全的，不能安全的應(yīng)用于其他目的，除非轉(zhuǎn)化到原來類型。
<1> 使用所有整形可以轉(zhuǎn)化為任意類型的指針(指針是4字節(jié)的long的東東，那么機(jī)器就認(rèn)為同類型就是可以轉(zhuǎn)化)
int c;
x* p = reinterpret_cast<x*>(c); //x是自定義的任意類型，當(dāng)然包括系統(tǒng)類型
<2> 可以對(duì)于任意類型指針之間轉(zhuǎn)化
y* c;
x* p = reinterpret_cast<x*>(c);//x,y代表所有自定義或系統(tǒng)類型
大家可以看到reinterpret_cast的轉(zhuǎn)化是極度的不負(fù)責(zé)任的，他只管轉(zhuǎn)化不檢測(cè)是否可以轉(zhuǎn)化。
<3> const_cast運(yùn)算符號(hào)
這個(gè)很簡(jiǎn)單從名字大家可以看出來，僅僅為了去掉或著加上const修飾符號(hào)。但是對(duì)于本身定義時(shí)為const的類型，即使你去掉const性，在你操作這片內(nèi)容時(shí)候也要小心，只能r不能w操作，否則還是會(huì)出錯(cuò)。
const char* p = "123";
char* c = const_cast<char*>(p);
c[0] = 1; //表面上通過編譯去掉了const性，但是操作其地址時(shí)系統(tǒng)依然不允許這
//么做。這是一個(gè)漏洞吧
<4> dynamic_cast運(yùn)算符號(hào)
Scott Mayers將其描述為用來執(zhí)行繼承體系中：安全的向下轉(zhuǎn)型或者跨系轉(zhuǎn)型動(dòng)作。也就是說你可以，用dynamic_cast將 指向base class的指針或引用轉(zhuǎn)型為 指向子類的對(duì)象的指針或引用。
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); //不管怎么樣都返回指針有可能指向不合適的對(duì)
//象，因?yàn)閟tatic僅僅靜態(tài)檢測(cè)，不能得到運(yùn)
//行時(shí)對(duì)象的信息是否真正為D類型
}
反正大家在使用知道怎么用就ok了，c++強(qiáng)制轉(zhuǎn)化在模板中還是非常有用的，其他時(shí)候本人也喜歡用c的轉(zhuǎn)化方便。^_^
http://www.vckbase.com/document/viewdoc/?id=1651
static_cast<>揭密
作者：Sam NG
譯者：小刀人
原文鏈接：What static_cast<> is actually doing
本文討論static_cast<> 和 reinterpret_cast<>。
介紹
大多程序員在學(xué)C++前都學(xué)過C，并且習(xí)慣于C風(fēng)格（類型）轉(zhuǎn)換。當(dāng)寫C++（程序）時(shí)，有時(shí)候我們?cè)谑褂胹tatic_cast<>和 reinterpret_cast<>時(shí)可能會(huì)有點(diǎn)模糊。在本文中，我將說明static_cast<>實(shí)際上做了什么，并且指出一些將會(huì)導(dǎo)致錯(cuò)誤的情況。
泛型（Generic Types）
float f = 12.3;
float* pf = &f;
// static cast<>
// 成功編譯, n = 12
int n = static_cast<int>(f);
// 錯(cuò)誤,指向的類型是無關(guān)的（譯注：即指針變量pf是float類型，現(xiàn)在要被轉(zhuǎn)換為int類型）
//int* pn = static_cast<int*>(pf);
//成功編譯
void* pv = static_cast<void*>(pf);
//成功編譯, 但是 *pn2是無意義的內(nèi)存（rubbish）
int* pn2 = static_cast<int*>(pv);
// reinterpret_cast<>
//錯(cuò)誤,編譯器知道你應(yīng)該調(diào)用static_cast<>
//int i = reinterpret_cast<int>(f);
//成功編譯, 但是 *pn 實(shí)際上是無意義的內(nèi)存,和 *pn2一樣
int* pi = reinterpret_cast<int*>(pf);
簡(jiǎn)而言之，static_cast<> 將嘗試轉(zhuǎn)換，舉例來說，如float-到-integer，而reinterpret_cast<>簡(jiǎn)單改變編譯器的意圖重新考慮那個(gè)對(duì)象作為另一類型。
指針類型（Pointer Types）指針轉(zhuǎn)換有點(diǎn)復(fù)雜，我們將在本文的剩余部分使用下面的類：
class CBaseX
{
public:
int x;
CBaseX() { x = 10; }
void foo() { printf("CBaseX::foo() x=%d\n", x); }
};
class CBaseY
{
public:
int y;
int* py;
CBaseY() { y = 20; py = &y; }
void bar() { printf("CBaseY::bar() y=%d, *py=%d\n", y, *py);
}
};
class CDerived : public CBaseX, public CBaseY
{
public:
int z;
};
情況1：兩個(gè)無關(guān)的類之間的轉(zhuǎn)換
// Convert between CBaseX* and CBaseY*
// CBaseX* 和 CBaseY*之間的轉(zhuǎn)換
CBaseX* pX = new CBaseX();
// Error, types pointed to are unrelated
// 錯(cuò)誤， 類型指向是無關(guān)的
// CBaseY* pY1 = static_cast<CBaseY*>(pX);
// Compile OK, but pY2 is not CBaseX
// 成功編譯, 但是 pY2 不是CBaseX
CBaseY* pY2 = reinterpret_cast<CBaseY*>(pX);
// System crash!!
// 系統(tǒng)崩潰!!
// pY2->bar();
正如我們?cè)诜盒屠又兴J(rèn)識(shí)到的，如果你嘗試轉(zhuǎn)換一個(gè)對(duì)象到另一個(gè)無關(guān)的類static_cast<>將失敗，而reinterpret_cast<>就總是成功“欺騙”編譯器：那個(gè)對(duì)象就是那個(gè)無關(guān)類。
情況2：轉(zhuǎn)換到相關(guān)的類
1. CDerived* pD = new CDerived();
2. printf("CDerived* pD = %x\n", (int)pD);
3.
4. // static_cast<> CDerived* -> CBaseY* -> CDerived*
//成功編譯，隱式static_cast<>轉(zhuǎn)換
5. CBaseY* pY1 = pD;
6. printf("CBaseY* pY1 = %x\n", (int)pY1);
// 成功編譯, 現(xiàn)在 pD1 = pD
7. CDerived* pD1 = static_cast<CDerived*>(pY1);
8. printf("CDerived* pD1 = %x\n", (int)pD1);
9.
10. // reinterpret_cast
// 成功編譯, 但是 pY2 不是 CBaseY*
11. CBaseY* pY2 = reinterpret_cast<CBaseY*>(pD);
12. printf("CBaseY* pY2 = %x\n", (int)pY2);
13.
14. // 無關(guān)的 static_cast<>
15. CBaseY* pY3 = new CBaseY();
16. printf("CBaseY* pY3 = %x\n", (int)pY3);
// 成功編譯,盡管 pY3 只是一個(gè) "新 CBaseY()"
17. CDerived* pD3 = static_cast<CDerived*>(pY3);
18. printf("CDerived* pD3 = %x\n", (int)pD3);
---------------------- 輸出 ---------------------------
CDerived* pD = 392fb8
CBaseY* pY1 = 392fbc
CDerived* pD1 = 392fb8
CBaseY* pY2 = 392fb8
CBaseY* pY3 = 390ff0
CDerived* pD3 = 390fec
注意：在將CDerived*用隱式 static_cast<>轉(zhuǎn)換到CBaseY*（第5行）時(shí)，結(jié)果是（指向）CDerived*（的指針向后） 偏移了4（個(gè)字節(jié)）（譯注：4為int類型在內(nèi)存中所占字節(jié)數(shù)）。為了知道static_cast<> 實(shí)際如何，我們不得不要來看一下CDerived的內(nèi)存布局。
CDerived的內(nèi)存布局（Memory Layout）
如圖所示，CDerived的內(nèi)存布局包括兩個(gè)對(duì)象，CBaseX 和 CBaseY，編譯器也知道這一點(diǎn)。因此，當(dāng)你將CDerived* 轉(zhuǎn)換到 CBaseY*時(shí)，它給指針添加4個(gè)字節(jié)，同時(shí)當(dāng)你將CBaseY*轉(zhuǎn)換到CDerived*時(shí)，它給指針減去4。然而，甚至它即便不是一個(gè)CDerived你也可以這樣做。
當(dāng)然，這個(gè)問題只在如果你做了多繼承時(shí)發(fā)生。在你將CDerived轉(zhuǎn)換 到 CBaseX時(shí)static_cast<> 和 reinterpret_cast<>是沒有區(qū)別的。
情況3：void*之間的向前和向后轉(zhuǎn)換
因?yàn)槿魏沃羔樋梢员晦D(zhuǎn)換到void*，而void*可以被向后轉(zhuǎn)換到任何指針（對(duì)于static_cast<> 和 reinterpret_cast<>轉(zhuǎn)換都可以這樣做），如果沒有小心處理的話錯(cuò)誤可能發(fā)生。
CDerived* pD = new CDerived();
printf("CDerived* pD = %x\n", (int)pD);
CBaseY* pY = pD; // 成功編譯, pY = pD + 4
printf("CBaseY* pY = %x\n", (int)pY);
void* pV1 = pY; //成功編譯, pV1 = pY
printf("void* pV1 = %x\n", (int)pV1);
// pD2 = pY, 但是我們預(yù)期 pD2 = pY - 4
CDerived* pD2 = static_cast<CDerived*>(pV1);
printf("CDerived* pD2 = %x\n", (int)pD2);
// 系統(tǒng)崩潰
// pD2->bar();
---------------------- 輸出 ---------------------------
CDerived* pD = 392fb8
CBaseY* pY = 392fbc
void* pV1 = 392fbc
CDerived* pD2 = 392fbc
一旦我們已經(jīng)轉(zhuǎn)換指針為void*，我們就不能輕易將其轉(zhuǎn)換回原類。在上面的例子中，從一個(gè)void* 返回CDerived*的唯一方法是將其轉(zhuǎn)換為CBaseY*然后再轉(zhuǎn)換為CDerived*。
但是如果我們不能確定它是CBaseY* 還是 CDerived*，這時(shí)我們不得不用dynamic_cast<> 或typeid[2]。
注釋：
1. dynamic_cast<>，從另一方面來說，可以防止一個(gè)泛型CBaseY* 被轉(zhuǎn)換到CDerived*。
2. dynamic_cast<>需要類成為多態(tài)，即包括“虛”函數(shù)，并因此而不能成為void*。
參考：
1. [MSDN] C++ Language Reference -- Casting
2. Nishant Sivakumar, Casting Basics - Use C++ casts in your VC++.NET programs
3. Juan Soulie, C++ Language Tutorial: Type Casting
推薦鏈接：如何在運(yùn)行時(shí)確定對(duì)象類型（RTTI）