C++提供了四种强制类型转换
1.const_cast,去除对象的const属性,因为一般情况下用非常量指针指向一个常量是非法的,比如
int main()
{
const int k=5;
int *q=const_cast<int*>(&k);//编译成功
int *p=&k;//编译错误
return 0;
}
2.reinterpret_cast,只能进行32位的位拷贝,除此之外不做其他操作,比如将in*转换为double*或int型,因此比较危险。
int main()
{
int k=5,*p=&k;
double *q=reinterpret_cast<double*>(p);//编译成功
double *w=p;//编译失败
return 0;
}
原理是编译器检查到q和p不是一个类型的指针,因此报错,但是用reinterpret_cast的话就相当于是告诉了编译器p是double*,编译器就不会
展开类型检查,因此被“骗”了。
3.static_cast,普通的类型转换,比如int转为double,父子类之间的转换,在编译时展开类型检查。
4.dynamic_cast ,也跟static_cast转换差不多,但是在运行时展开类型检查(用于多态,比如父子类之间的转换)。
比如
class A{};
class B:public A{};
int main()
{
A a;B b;
A *pa=&b;
B* pb1=static_cast<B*>(&a);//显示不出错
B* pb2=dynamic_cast<B*>(&a);//显示出错
return 0;
}
如上所示,在static_cast中,因为只在编译时展开类型检查,而基类的引用既可以绑定基类也可以绑定派生类,编译器无法确定&a绑定的啥,所以就不会报错(因为人家可能对了呀,怎么能报错)。但是在dynamic_cast中,会在运行时展开类型检查,发现我们将一个基类的指针转换为一个派生类指针,这是不合法的,所以就报错了。
static_cast与C强制类型转换区别
class A
{
int a;
};
class B
{
int b;
};
class C : public A
{
int c;
};
int main()
{
B b;
C c;
A* p1 = (A*) &b; // 这句是c风格的强制类型转换,编译不会报错,留下了隐患
A* p2 = static_cast<A*>(&b); //static_cast编译时进行了类型检查,直接报错
A* p3 = dynamic_cast<A*>(&b);//也会报错
A* p4 = (A*) &c;
A* p5 = static_cast<A*>(&c);
A* p6 = dynamic_cast<A*>(&c);
return 0;
}
参考:
- static_cast和reinterpret_cast揭秘 收藏
- 本文讨论static_cast<> 和 reinterpret_cast<>。
-
- reinterpret_cast可以转换任意一个32bit整数,包括所有的指针和整数。可以把任何整数转成指针,也可以把任何指针转成整数,以及把指针转化为任意类型的指针,威力最为强大!但不能将非32bit的实例转成指针。总之,只要是32bit的东东,怎么转都行!
- static_cast和dynamic_cast可以执行指针到指针的转换,或实例本身到实例本身的转换,但不能在实例和指针之间转换。static_cast只能提供编译时的类型安全,而dynamic_cast可以提供运行时类型安全。举个例子:
- class a;class b:a;class c。
- 上面三个类a是基类,b继承a,c和ab没有关系。
- 有一个函数void function(a&a);
- 现在有一个对象是b的实例b,一个c的实例c。
- function(static_cast<a&>(b)可以通过而function(static<a&>(c))不能通过编译,因为在编译的时候编译器已经知道c和a的类型不符,因此static_cast可以保证安全。
- 下面我们骗一下编译器,先把c转成类型a
- b& ref_b = reinterpret_cast<b&>c;
- 然后function(static_cast<a&>(ref_b))就通过了!因为从编译器的角度来看,在编译时并不能知道ref_b实际上是c!
- 而function(dynamic_cast<a&>(ref_b))编译时也能过,但在运行时就失败了,因为dynamic_cast在运行时检查了ref_b的实际类型,这样怎么也骗不过去了。
- 在应用多态编程时,当我们无法确定传过来的对象的实际类型时使用dynamic_cast,如果能保证对象的实际类型,用static_cast就可以了。至于reinterpret_cast,我很喜欢,很象<a href="http://lib.csdn.net/base/c" class='replace_word' title="C语言知识库" target='_blank' style='color:#df3434; font-weight:bold;'>C语言</a>那样的暴力转换:)
-
- dynamic_cast:动态类型转换
- static_cast:静态类型转换
- reinterpret_cast:重新解释类型转换
- const_cast:常量类型转换
- 专业的上面很多了,我说说我自己的理解吧:
- synamic_cast一般用在父类和子类指针或应用的互相转化;
- static_cast一般是普通数据类型(如int m=static_cast<int>(3.14));
- reinterpret_cast很像c的一般类型转换操作
- const_cast是把cosnt或volatile属性去掉
-
- .
-
- 介绍
- 大多程序员在学C++前都学过C,并且习惯于C风格(类型)转换。当写C++(程序)时,有时候我们在使用static_cast<>和reinterpret_cast<>时可能会有点模糊。在本文中,我将说明static_cast<>实际上做了什么,并且指出一些将会导致错误的情况。
-
- 泛型(Generic Types)
-
-
-
- float f = 12.3;
- float* pf = &f;
-
-
- int n = static_cast<int>(f);
-
-
- void* pv = static_cast<void*>(pf);
-
- int* pn2 = static_cast<int*>(pv);
-
-
-
-
- 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:两个无关的类之间的转换
-
-
-
-
- CBaseX* pX = new CBaseX();
-
-
-
-
-
- CBaseY* pY2 = reinterpret_cast<CBaseY*>(pX);
-
-
-
-
- 情况2:转换到相关的类
-
- 1. CDerived* pD = new CDerived();
- 2. printf("CDerived* pD = %x/n", (int)pD);
- 3.
- 4.
-
- 5. CBaseY* pY1 = pD;
- 6. printf("CBaseY* pY1 = %x/n", (int)pY1);
-
- 7. CDerived* pD1 = static_cast<CDerived*>(pY1);
- 8. printf("CDerived* pD1 = %x/n", (int)pD1);
- 9.
- 10.
-
- 11. CBaseY* pY2 = reinterpret_cast<CBaseY*>(pD);
- 12. printf("CBaseY* pY2 = %x/n", (int)pY2);
- 13.
- 14.
- 15. CBaseY* pY3 = new CBaseY();
- 16. printf("CBaseY* pY3 = %x/n", (int)pY3);
-
- 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)
-
-
- 本文来自CSDN博客,转载请标明出处:http:
- 如图所示,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;
- printf("CBaseY* pY = %x/n", (int)pY);
- void* pV1 = pY;
- printf("void* pV1 = %x/n", (int)pV1);
-
- CDerived* pD2 = static_cast<CDerived*>(pV1);
- printf("CDerived* pD2 = %x/n", (int)pD2);
-
-
- 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
-
-
-
- 本文来自CSDN博客,转载请标明出处:http:
<顶