<!-- /* Font Definitions */ @font-face {font-family:宋体; panose-1:2 1 6 0 3 1 1 1 1 1; mso-font-alt:SimSun; mso-font-charset:134; mso-generic-font-family:auto; mso-font-pitch:variable; mso-font-signature:3 135135232 16 0 262145 0;} @font-face {font-family:"/@宋体"; panose-1:2 1 6 0 3 1 1 1 1 1; mso-font-charset:134; mso-generic-font-family:auto; mso-font-pitch:variable; mso-font-signature:3 135135232 16 0 262145 0;} /* Style Definitions */ p.MsoNormal, li.MsoNormal, div.MsoNormal {mso-style-parent:""; margin:0cm; margin-bottom:.0001pt; text-align:justify; text-justify:inter-ideograph; mso-pagination:none; font-size:10.5pt; mso-bidi-font-size:12.0pt; font-family:"Times New Roman"; mso-fareast-font-family:宋体; mso-font-kerning:1.0pt;} a:link, span.MsoHyperlink {color:blue; text-decoration:underline; text-underline:single;} a:visited, span.MsoHyperlinkFollowed {color:purple; text-decoration:underline; text-underline:single;} /* Page Definitions */ @page {mso-page-border-surround-header:no; mso-page-border-surround-footer:no;} @page Section1 {size:612.0pt 792.0pt; margin:72.0pt 90.0pt 72.0pt 90.0pt; mso-header-margin:36.0pt; mso-footer-margin:36.0pt; mso-paper-source:0;} div.Section1 {page:Section1;} -->
原文链接: What static_cast<> is actually doing
本文讨论 static_cast<> 和 reinterpret_cast<> 。
介绍
大多程序员在学 C++ 前都学过 C ,并且习惯于 C 风格(类型)转换。当写 C++ (程序)时,有时候我们在使用 static_cast<> 和 reinterpret_cast<> 时可能会有点模糊。在本文中,我将说明 static_cast<> 实际上做了什么,并且指 出一些将会导致错误的情况。
泛型( Generic Types )
float f = 12.3;
float* pf = &f;
// static cast<>
// 成功编译 , n = 12
int n = static_cast<int>(f);
// 错误 , 指向的类型是无关的(译注:即指针变量 pf 是 float 类型,现在要被转换为 int 类型)
//int* pn = static_cast<int*>(pf);
// 成功编译
void* pv = static_cast<void*>(pf);
// 成功编译 , 但是 *pn2 是无意义的内存( rubbish )
int* pn2 = static_cast<int*>(pv);
// reinterpret_cast<>
// 错误 , 编译器知道你应该调用 static_cast<>
//int i = reinterpret_cast<int>(f);
// 成功编译 , 但是 *pn 实际上是无意义的内存 , 和 *pn2 一样
int* pi = reinterpret_cast<int*>(pf);
简而言之, static_cast<> 将尝试转换,举例来说,如 float- 到 -integer ,而 reinterpret_cast<> 简单改变编译器的意图重新考虑那个对象作为另一类型。
指针类型( Pointer Types )
指针转换有点复杂,我们将在本文的剩余部分使用下面的类:
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 :两个无关的类之间的转换
// Convert between CBaseX* and CBaseY*
// CBaseX* 和 CBaseY* 之间的转换
CBaseX* pX = new CBaseX();
// Error, types pointed to are unrelated
// 错误, 类型指向是无关的
// CBaseY* pY1 = static_cast<CBaseY*>(pX);
// Compile OK, but pY2 is not CBaseX
// 成功编译 , 但是 pY2 不是 CBaseX
CBaseY* pY2 = reinterpret_cast<CBaseY*>(pX);
// System crash!!
// 系统崩溃 !!
// pY2->bar();
正如我们在泛型例子中所认识到的,如果你尝试转换一个对象到另一个无关的类 static_cast<> 将失败,而 reinterpret_cast<> 就总是成功 “ 欺骗 ” 编译器:那个对象就是那个无关类。
情况 2 :转换到相关的类
1. CDerived* pD = new CDerived();
2. printf("CDerived* pD = %x/n", (int)pD);
3.
4. // static_cast<> CDerived* -> CBaseY* -> CDerived*
// 成功编译,隐式 static_cast<> 转换
5. CBaseY* pY1 = pD;
6. printf("CBaseY* pY1 = %x/n", (int)pY1);
// 成功编译 , 现在 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. // 无关的 static_cast<>
15. CBaseY* pY3 = new CBaseY();
16. printf("CBaseY* pY3 = %x/n", (int)pY3);
// 成功编译 , 尽管 pY3 只是一个 " 新 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<> 转换到 CBaseY* (第 5 行)时,结果是(指向) CDerived* (的指针向后) 偏移了 4 (个字节)(译注: 4 为 int 类型在内存中所占字节数)。为了知道 static_cast<> 实际如何,我们不得不要来看一下 CDerived 的内存布局。
CDerived 的内存布局( Memory Layout )
如图所示, CDerived 的内存布局包括两个对象, CBaseX 和 CBaseY ,编译器也知道这一点。因此,当你将 CDerived* 转换到 CBaseY* 时,它给指针添加 4 个字节,同时当你将 CBaseY* 转换到 CDerived* 时,它给指针减去 4 。然而,甚至它即便不是一个 CDerived 你也可以这样做。
当然,这个问题只在如果你做了多继承时发生。在你将 CDerived 转换 到 CBaseX 时 static_cast<> 和 reinterpret_cast<> 是没有区别的。
情况 3 : void* 之间的向前和向后转换
因为任何指针可以被转换到 void* ,而 void* 可以被向后转换到任何指针(对于 static_cast<> 和 reinterpret_cast<> 转换都可以这样做),如果没有小心处理的话错误可能发生。
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, 但是我们预期 pD2 = pY - 4
CDerived* pD2 = static_cast<CDerived*>(pV1);
printf("CDerived* pD2 = %x/n", (int)pD2);
// 系统崩溃
// pD2->bar();
---------------------- 输出 ---------------------------
CDerived* pD = 392fb8
CBaseY* pY = 392fbc
void* pV1 = 392fbc
CDerived* pD2 = 392fbc
一旦我们已经转换指针为 void* ,我们就不能轻易将其转换回原类。在上面的例子中,从一个 void* 返回 CDerived* 的唯一方法是将其转换为 CBaseY* 然后再转换为 CDerived* 。
但是如果我们不能确定它是 CBaseY* 还是 CDerived* ,这时我们不得不用 dynamic_cast<> 或 typeid[2] 。
注释:
1. dynamic_cast<> ,从另一方面来说,可以防止一个泛型 CBaseY* 被转换到 CDerived* 。
2. dynamic_cast<> 需要类成为多态,即包括 “ 虚 ” 函数,并因此而不能成为 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
推荐链接: 如何在运行时确定对象类型( RTTI)