reinterpret_cast,const_cast,static_cast,dynamic_cast 总结

[czbever]

reinterpret_cast,const_cast,static_cast,dynamic_cast 总结


(一)、reinterpret_cast

1、将一个类型指针转换为另一个类型指针，这种转换不修改指针变量值数据存放格式
2、只需在编译时重新解释指针的类型，它可以将指针转化为一个整型数但不能用于非指针的转换

double d=9.3;
double* pd = &d;
int* pi = reinterpret_cast<int *> (pd);
class A{};
class B{};
A* pa = new A;
B* pb=reinterpret_cast<B*>(pa); //将pa 转为B
long j=reinterpret_cast<long> (pa);//指针转换为整数
int i=9;
double x=reinterpret_cast<double>(i); //reinterpret_cast不能用于非指针的转换

(二)、const_cast
用法：const_cast< type-id > (exdivssion)
该运算符用来修改类型的const或volatile属性。

1.用于去除指针变量的常属性，将它转换为一个对应指针类型的普通变量，
2.反过来也可以将一个非常量指针转换为一个常量指针变量
3.它无法将一个非指针的常量转换为普通变量

example: const i=10;
int j=const_cast<int>(i); //无法转换
const int ppp=998;

const int* pca=&ppp;
int* p=const_cast<int*>(pca);//将它转换为一个对应指针类型的普通变量，去除了const;可以改成int *p=(int *)(pca);

const A* paa=new A;
A * ppppa=const_cast<A*> (paa);//它转换为一个对应指针类型的普通变量，去除了const;

int * pii=0;//反过来也可以将一个非常量指针转换为一个常量指针变量
const int* piiic=const_cast<const int *>(pii);

注意下列情况：
const int a=1;
int &ra=a;// 错
int *pa=&a;//错
const int &rb=b;//对
const int *pb=&b;//对

//////////////////////////////////////////////////////////////////////////////////

(三)、static_cast

1、用于转换基本类型和具有继承关系的类成员之间转换
2、static_cast不太用于指针类型的之间的转换，它的效率没有reinterpret_cast的效率高。而对于基本类型的转换是完全不行的，
像这样
double aa=1.0;
int *p=static_cast<int *>(&aa);
是不允许的。

int in=99;
double dn=static_cast<double> (in);//用于转换基本类型和具有继承关系的类新之间转换

class Base{};
class derv:public Base{};
derv dd;
Base bbbb=static_cast<Base>(dd);//具有继承关系的类新之间转换

//static_cast不太用于指针类型的之间的转换，它的效率没有reinterpret_cast的效率高
Base *pb1=new Base;
derv *pder=static_cast<derv*>(pb1);//基类转继承类
derv* pder1=new derv;
Base* pbase1=static_cast<Base*>(pder1);//继承类指针转父类指针，此时pbase1返回NULL；若pder1不是指针，则也返回NULL

注意：static_cast不能转换掉exdivssion的const、volitale、或者__unaligned属性。
//////////////////////////////////////////////////////////////////////////

(四)、dynamic_cast

1.只能在继承类对象的指针之间或引用之间进行类型转换
2.这种转换并非在编译时，而是在运行时，动态的
3.没有继承关系，但被转换的类具有虚函数对象的指针进行转换
4、dynamic_cast具有类型检查的功能，在把子类的指针或引用转换成基类时，比static_cast更安全。

derv* dp=new derv;
Base* bv=dynamic_cast<Base *>(dp);//继承类对象的指针之间进行类型转换

derv dpp;//继承类对象引用之间进行类型转换
Base &b=dynamic_cast<Base&>(dpp);

class AA{virtual fun(){}
virtual ~AA(){}};
class BB{};

//没有继承关系，但被转换的类具有虚函数对象的指针进行转换，编译可通过
AA* pAA=new AA;
BB* pBB=dynamic_cast<BB *>(pAA);//

//没有继承关系，被转换的类也没有有虚函数对象的指针进行转换，编译不能通过
BB* pBBB=new BB;
AA* pAAA=dynamic_cast<AA*>(pBBB);

return 1;
}


//总结：
//reinterpret_cast 将一个类型指针转换为另一个类型指针
//const_cast 用于去除指针变量的常属性，将它转换为一个对应指针类型的普通变量，反过来也可以将一个非常量指针转换为一个常量指针变量
//static_cast 用于转换基本类型和具有继承关系的类成员之间转换,不太用于指针类型的之间的转换
//dynamic_cast 只能在继承类对象的指针之间或引用之间进行类型转换
//以上只有dynamic_cast这种转换并非在编译时，而是在运行时，动态的。其它均在编译时

[帅得不敢出门]

up

[ChamPagneZ]

//mark

[lgccaa]

up

[backway]

支持楼主