一、static_cast, dynamic_cast, const_cast

http://www.cnblogs.com/chio/archive/2007/07/18/822389.html

http://blog.csdn.net/deyili/article/details/5354242（很重要的）

dynamic_cast一般用在父类和子类指针或引用的互相转化;
static_cast一般是普通数据类型(如int m=static_cast(3.14));
reinterpret_cast很像c的一般类型转换操作
const_cast是把cosnt或volatile属性去掉

#include
void main()
{
void *p=NULL;
int *pp=p;
}

//ok
#include
void main()
{
int *pp=NULL;
void *p=pp;
}

#include
using namespace std;
class A
{
public:
int m_a;
};
class B: public A
{
public:
int m_b;
};
class C
{
public:
int m_c;
};
void f(A &a)
{
cout<<"f is called"<(b));//static_cast的一大作用：子类对象b转化为父类对象，可以通过编译
// f(static_cast(c));//进行了类型检查，类A和类C是毫无关系的，检查出错，不能通过编译
//f(static_cast (pc));//进行了类型检查，类A和类C是毫无关系的，检查出错，不能通过编译
}

static_cast和dynamic_cast的不同

例子如下：三个类的定义同上

void main()
{
B b;
C c;
B & ref_b=reinterpret_cast(c);
f(static_cast(ref_b));//成功欺骗编译器，编译通过，成功运行
//f(dynamic_cast<A &(ref_b));//编译通过，但是运行时检查了ref_b的实际类型为B，所以运行失败
}

void main()
{
B b;
C c;
A & ref_b=reinterpret_cast (c);
f(ref_b);//成功欺骗编译器，编译通过，成功运行
}

在应用多态编程时，当我们无法确定传过来的对象的实际类型时使用dynamic_cast：如我们并不能确定传入的ref_b到底是B类型还是C类型（c通过reinterpret_cast转换为b，编译器并不知情），这时就应该用dynamic_cast。

void main()
{
B b;
C c;
B & ref_b=reinterpret_cast(c);
f(static_cast(ref_b));//成功欺骗编译器，编译通过，成功运行
//f(dynamic_cast (ref_b));//编译通过，但是运行时检查了ref_b的实际类型，所以运行失败
}

如果能保证对象的实际类型，用static_cast就可以了。至于reinterpret_cast，我很喜欢，很象c语言那样的暴力转换：）

#include
class CBaseX
{
public:
void foo() { printf("CBaseX::foo() x=%d/n", x); }
};
class CBaseY
{
public:
void bar() { printf("CBaseY::bar()");
}
};
void main()
{
CBaseX* pX = new CBaseX(); // 两个无关类：CBaseX* 和 CBaseY*之间的转换
// CBaseY* pY1 = static_cast(pX); // 错误，类型指向是无关的 (解释：指针变量PX是CBaseX类型，现在要将其转换为CBase类型)
CBaseY* pY2 = reinterpret_cast(pX); // 成功编译, 但是 pY2 不是CBaseX
pY2->bar();//如果你尝试转换一个对象（pX）到另一个无关的类(pY2)static_cast<>将失败，而reinterpret_cast<>总是能成功“欺骗”编译器：认为被转换的那个对象(pX)就是要转换到的无关类（pY）。
}

#include
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;
};
void main()
{
CDerived* pD = new CDerived();
printf("CDerived* pD = %x\n", (int)pD);
// static_cast<> CDerived* -> CBaseY* -> CDerived*
//成功编译，隐式static_cast<>转换
CBaseY* pY1 = pD;
printf("CBaseY* pY1 = %x\n", (int)pY1);
// 成功编译, 现在 pD1 = pD
CDerived* pD1 = static_cast(pY1);
printf("CDerived* pD1 = %x\n", (int)pD1);
// reinterpret_cast
// 成功编译, 但是 pY2 不是 CBaseY*
CBaseY* pY2 = reinterpret_cast(pD);
printf("CBaseY* pY2 = %x\n", (int)pY2);
// 无关的 static_cast<>
CBaseY* pY3 = new CBaseY();
printf("CBaseY* pY3 = %x\n", (int)pY3);
// 成功编译,尽管 pY3 只是一个 "新 CBaseY()"
CDerived* pD3 = static_cast(pY3);
printf("CDerived* pD3 = %x\n", (int)pD3);
}

如图所示，CDerived的内存布局包括两个对象，CBaseX 和 CBaseY，编译器也知道这一点。因此，当你将CDerived* 转换到 CBaseY*时，它给指针添加4个字节，同时当你将CBaseY*转换到CDerived*时，它给指针减去4。然而，甚至它即便不是一个CDerived你也可以这样做。

当然，这个问题只在如果你做了多继承时发生。在你将CDerived转换到 CBaseX时static_cast<> 和 reinterpret_cast<>是没有区别的。

void main()
{
CDerived* pD = new CDerived();
printf("CDerived* pD = %x\n", (int)pD);// 打印的是派生类的地址
CBaseY* pY = pD; // 成功编译, pY = pD + 4
printf("CBaseY* pY = %x\n", (int)pY);// 打印的是基类pY的地址
void* pV1 = pY; //成功编译, pV1 = pY //打印的是基类pY的地址
printf("void* pV1 = %x\n", (int)pV1);
CDerived* pD2 = static_cast(pV1);// pD2 = pV1=pY, 但是我们预期 pD2 = pY - 4
printf("CDerived* pD2 = %x\n", (int)pD2);
// 系统崩溃
// pD2->bar();
}

手机扫一扫
移动阅读更方便

你可能感兴趣的文章