C++ 四种显式类型转换-白红宇

C++ 四种显式类型转换

阅读量：6288 次

发布时间：2019-06-22

本文共 7561 字，大约阅读时间需要 25 分钟。

显式类型转换

reinterpret_cast<new_type>(EXPression)显式转换

const_cast<new_type>(EXPression) 显式转换

static_cast<new_type>(EXPression) 显式转换

dynamic_cast<new_type>(EXPression) 显式转换

功能: 将EXPression表达式的值转换为 new_type类型的值。

1 前三种类型的转换是在编译时期实现转换的,

最后一个是在运行时期进行类型转换的，并且返回转换成功与否标志，这是传统的类型转换所不具备的功能

double d=3.2;

int i= d; //隐式转换double变量d 为int 变量， i=3

倘若使用C++显式类型转换 static_cast(exp)函数做以上同样的事，就可以让他人知道这样的double 到 int 类型的转换，是有意这么做的，

并非疏忽大意所致。

double d=3.2;

int i = static_cast<int>(d);//显式转换

A reinterpret_cast 类型转换函数将一个类型的指针，转换为另一个类型的指针。这种转换不用改变指针变量值数据存放格式(不改变指针变量值),只需在编译时重新解释指针的类型就可以做到。reinterpret_cast 可以将指针转换为一个整形数(隐式转换),但不能用于非指针类型的转换，即使这样做也不会通过编译

1> 用显式的reinterpret_cast 将基本类型或一个类的指针，转换为另一个类型或类的指针

//基本类型指针的类型转换

double d=9.3;

double* pd = &d;

int *pi = reinterpret_cast<int* >(pd); //相当于隐式转换 int* pi = (int* )pd;

//不相关的类的指针的类型转换

class A{}; class B{};

A* pa = new A;

B* pb = reinterpret_cast<B* >(pa); // 相当于隐式转换 B* pb = (B*)pa;

3> 指针转换为整数

long j = reinterpret_cast<long>(pi); //相当于隐式转换 long j = (long)pi;

4> 尝试将int 类型的变量转换为double 类型，由于并非指针类型转换，因此转换不成功.

//企图转换非指针变量

int i=8;

double dl = reinterpret_cast<double>(i); //不能编译通过

//企图转换 const 指针为 void * 指针

const int* pci - 0;

void* pv = reinterpret_cast<void* >(pci); //不能编译通过

B const_cast 类型转换函数用于去除指针变量的常量属性，将它转换为一个对应指针类型的普通变量。反过来，也可以将一个非常量的指针变量转换为一个常指针变量。这种转换是在编译期间做出的类型更改。

1> 将int 类型的常指针便利pci 转换为int 指针变量，将类A的常指针便利pca 转换为类A的普通指针变量,将类A的常指针变量pca转换为类A的普通指针变量

const int* pci = 0;

int *pj = const_cast<int* >(pci); //相当于隐式转换 int * pj = (int* )pci;

const A* pca = new A;

A *pa = const_cast<A*>(pca); //相当于隐式转换 A* pa = (A*)pca;

2> 基于安全考虑，const_cast 无法将非指针的常变量转换为普通变量

const int i = 0;

const_cast<int>(i); //去除变量i的常属性，不能编译通过

3>将普通指针变量pi 转换为常指针变量，但不能将非指针的普通变量转换为常变量。而隐式转换则允许

int * pi = 0; //相当于隐式转换 const int* pcj = (int*)pi;

const int* pcj = const_cast<const int* >(pi);

int i =0;

const int cj = const_cast<const int>(i); //非指针转换，不能编译通过

const int ck = (const int)i; // 隐式转换，可通过编译

该运算符用来修改类型的const或volatile属性。除了const 或volatile修饰之外， type_id和expression的类型是一样的。

常量指针被转化成非常量指针，并且仍然指向原来的对象；

常量引用被转换成非常量引用，并且仍然指向原来的对象；常量对象被转换成非常量对象。

volatile和const类型，举例如下所示。

class B

{

public:

int m_iNum;

}

void foo()

{

const B b1;

b1.m_iNum = 100; //comile error

B b2 = const_cast<B>(b1);

b2. m_iNum = 200; //fine

}

上面的代码编译时会报错，因为b1是一个常量对象，不能对它进行改变；

使用const_cast把它转换成一个非常量对象，就可以对它的数据成员任意改变。注意：b1和b2是两个不同的对象。

C static_cast 主要用于基本类型之间和具有继承关系的类型之间的转换，这种转换一般会更改变量的内部表示方式，因此static_cast应用于指针类型转换，没有太大意义，即使允许指针类型转换，也不及reinterpret_cast解释效率高

static_cast类型转换用于相关类型之间的转换，诸如：在同一个类的继承层次关系中，向上或向下转换；枚举类型与整数类型之间的转换；浮点类型与指数类型之间的转换。在这4中类型转换中，static_cast是最接近C-style的了。

该运算符把expression转换为type-id类型，但没有运行时类型检查来保证转换的安全性。它主要有如下几种用法：

（1）用于类层次结构中基类和派生类之间指针或引用的转换

进行上行转换（把派生类的指针或引用转换成基类表示）是安全的

进行下行转换（把基类的指针或引用转换为派生类表示），由于没有动态类型检查，所以是不安全的

（2）用于基本数据类型之间的转换，如把int转换成char。这种转换的安全也要开发人员来保证

（3）把空指针转换成目标类型的空指针

（4）把任何类型的表达式转换为void类型

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

1> // 基本类型转换

int i=0;

double d = static_cast<double>(i); //相当于隐式转换 double d =(double)i;

int j = static_cast<int>(d); //相当于隐式转换 int j = (int)d;

2> //转换继承类的对象为基类对象

class Base{};

class Derived : public Base{};

Derived d;

Base b = static_cast<Base >(d); //相当于隐式转换 Base b = (Base)d;

3> 如下将继承类与基类的指针进行相互转换，都能编译通过，但基类指针转换为继承类指针，具有一定的危害性.

// 继承类指针转换为基类指针

Derived* pd = new Derived;

Base* pb = static_cast<Base* >(pd); //相当于隐式转换 Base* pb = (Derived*)pd;

// 基类指针转换为继承类指针

Base* pb = new Base;

Derived* pd = static_cast<Derived* >(pb); //相当于隐式转换 Derived* pd = (Dervived*)pb;

4> 以下代码尝试用static_cast 转换基本数据类型的指针，将继承类对象转换为基类对象或转换无继承关系的类的指针，都不能编译通过.

class A{};

class B{};

int *pi = 0;

double *pd = static_cast<double* >(pi); //企图int* 转换为 double* , 不能编译通过

Base b;

Derived d = static_cast<Derived>(b); //企图继承类对象转换为基类对象，不能编译通过

A a;

B b = static_cast<B>(a); //企图转换无继承关系的类，不能编译通过

A * pa = NULL;

B* pb = static_cast<B*>(pa); // 企图转换无继承关系的类的指针，不能编译通过

D dynamic_cast 与静态static_cast 相对，是动态的转换。这种转换是在运行时进行转换分析的，并非在编译时期进行。

dynamic_cast 只能在继承类对象的指针之间或引用之间进行类型转换。进行转换时，会根据当前运行对象的运行时类型信息(RTTI),判断类型对象之间的转换是否合法。dynamic_cast的指针转换失败，可通过是否为NULL指针检测；引用转换失败，则抛出一个bad_cast异常。

用法：dynamic_cast<type_id> (expression)

该运算符把expression转换成type_id类型的对象。type_id必须是类的指针、引用或者void*；

如果type_id是类指针类型，那么expression也必须是一个指针，如果type_id是一个引用，那么expression也必须是一个引用。

dynamic_cast主要用于类层次间的上行转换和下行转换，还可以用于类之间的交叉转换。

在类层次间进行上行转换时，dynamic_cast和static_cast的效果是一样的；

在进行下行转换时，dynamic_cast具有类型检查的功能，比static_cast更安全。

1> dynamic_cast 将继承类指针或引用转换为基类指针或引用，并对没有继承关系，但被转换的类具有虚函数的对象指针进行转换，均可编译通过。

class Base{};

class Derived: public Base{};

//继承类指针转换为基类指针

Derived* pd = new Derived();

Base* pb = dynamic_cast<Base* >(pd);

if(!pb)

printf("dynamic_cast 类型转换失败\n");

else

printf("dynamic_cast 类型转换成功\n");

//有继承关系的引用之间转换

Derived d;

Base& b = dynamic_cast<Base& >(d);

//没有继承关系，但被转换的类有虚函数

class A {virtual ~A(){}}; // 有虚函数

class B{};

A* pa = new A;

B* pb = dynamic_cast<B* >(pa); //有虚函数的对象指针，可以转换

if(!pb)

printf("dynamic_cast 类型转换失败\n");

else

printf("dynamic_cast 类型转换成功\n");

2> 如下代码尝试将非指针的继承对象转换为基类对象，对无继承关系(且没有虚函数)的对象指针进行转换, 基本类型指针转换以及基类指针转换为继承类指针，均不能编译通过

class A{}; //没有虚函数

class B{virtual ~B(){}};

//继承类转换为基类对象，不能编译通过

Derived d;

Base b = dynamic_cast<Base>(d);

//无继承关系，且A 无虚函数， A类对象指针转换，不能编译通过

A* pa = new A;

B* pb = dynamic_cast<B* >(pa);

// 基本类型之间转换(无继承关系)，不能通过

int* i=0;

int j = dynamic_cast<int* >(i);

//基类指针转换为继承类指针，不能编译通过

Base* pb = new Base;

Derived *pd = dynamic_cast<Derived* >(pb);

3> dynamic_cast 不只是应用于类型转换，通常利用它做运行时对象类型检查的特性，在程序中检测当前内存对象的类型信息。

class B

{

public:

int m_iNum;

virtual void foo();

};

class D:public B

{

public:

char *m_szName[100];

};

void func(B *pb)

{

D *pd1 = static_cast<D *>(pb);

D *pd2 = dynamic_cast<D *>(pb);

}

在上面的代码段中，如果pb指向一个D类型的对象，pd1和pd2是一样的，并且对这两个指针执行D类型的任何操作都是安全的；

但是，如果pb指向的是一个B类型的对象，那么pd1将是一个指向该对象的指针，对它进行D类型的操作将是不安全的（如访问m_szName），

而pd2将是一个空指针。

另外要注意：B要有虚函数，否则会编译出错；static_cast则没有这个限制。

这是由于运行时类型检查需要运行时类型信息，而这个信息存储在类的虚函数表（

关于虚函数表的概念，详细可见<Inside c++ object model>）中，只有定义了虚函数的类才有虚函数表，

没有定义虚函数的类是没有虚函数表的。

另外，dynamic_cast还支持交叉转换，如下所示。

class A

{

public:

int m_iNum;

virtual void f(){}

};

class B:public A

{

};

class D:public A

{

};

void foo()

{

B *pb = new B;

pb->m_iNum = 100;

D *pd1 = static_cast<D *>(pb); //compile error

D *pd2 = dynamic_cast<D *>(pb); //pd2 is NULL

delete pb;

}

在函数foo中，使用static_cast进行转换是不被允许的，将在编译时出错，而使用dynamic_cast转换则是允许的，结果是空指针。

zongjie

在写代码中经常会有很多的隐式类型转换或显式类型转换。

对于隐式的类型转换主要是放生在赋值的时候，讲变量赋值给不同类型的变量的时候就会发生类型转换，如果是宽化转换（即从占字节少的类型向占字节多的类型转换），这个时候是不会出现丢失数据的。如果是窄化转换（从占字节多的类型向占字节少的类型转换），这个时候就很有可能会出现丢失数据，或者数据错误（如从有符号向无符号转换，就可能会出现各种无法想象的问题）。。。所以这种情况应该尽量避免。

对于C风格显式转换，就是强制转换，可能会造成数据解释错误，也是很不安全的。

在C++中有四种类型转换：