static_cast, dynamic_cast, const_cast学习和探讨

来源：互联网发布：视频制作编辑软件编辑：程序博客网时间：2024/05/06 03:17

一 C语言中存在着两种类型转换：

隐式转换和显式转换

隐式转换：不同数据类型之间赋值和运算，函数调用传递参数……编译器完成

1) 算术转换(Arithmetic conversion) : 在混合类型的算术表达式中, 最宽的数据类型成为目标转换类型。

2) 一种类型表达式赋值给另一种类型的对象：目标类型是被赋值对象的类型

3) 将一个表达式作为实参传递给函数调用，此时形参和实参类型不一致：目标转换类型为形参的类型

4)从一个函数返回一个表达式，表达式类型与返回类型不一致：目标转换类型为函数的返回类型

显示转换：在类型前增加：（Type）变量对变量进行的转换。用户显式增加
二 C++中的类型转换

　　通过这两种方式，C语言中大部分的类型转换都可以顺利进行。至于能不能进行转换，转换后的结果如何，编译器不管需要用户自己去控制。C++继承了C中的隐式和显式转换的方式。但这种转换并不是安全和严格的，加上C++本身对象模型的复杂性，C++增加了四个显示转换的关键字。（C++是强类型语言）

（static_cast，dynamic_cast，const_static，reinterpret_cast）

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

static_cast: 静态类型转换;一般是普通数据类型(如int m=static_cast<int>(3.14));只能提供编译时的类型安全;一般的转换，如果你不知道该用哪个，就用这个。

dynamic_cast: 动态类型转换;一般用在父类和子类指针或应用的互相转化;可以提供运行时类型安全

const_cast: 常量类型转换; 把cosnt或volatile属

reinterpret_cast: 重新解释类型转换;很像c的一般类型转换操作性去掉

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

static_cast

（1）用于基本的数据类型转换（char，int），及指针之间的转换

（2）类层次中基类与子类成员函数指针的转换

（3）类层次结构中基类与子类指针或引用之间的转换　　

上行转换：子类指针或引用转换成基类表示——安全

下行转换：基类指针或引用转换成子类表示——危险（没有动态类型检查）

（4）把空指针转换成目标类型的空指针。(不安全!!)

（5）把任何类型的表达式转换成void类型。

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

static_cast和普通强制转换的区别：

//两个无关类，

B* pB =new B();

A *pA1 = (A *)pB;//正常运行

A *pA2 = static_cast<A *>(pB);//error C2440: “static_cast”: 无法从“B *”转换为“A *”

static_cast和reinterpret_cast的区别：

C++primer第十五章里写了编译器隐式执行任何类型转换都可由static_cast显示完成;reinterpret_cast通常为操作数的位模式提供较低层的重新解释

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

dynamic_cast:

用法：dynamic_cast < type-id > ( expression_r_r )

该运算符把expression_r_r转换成type-id类型的对象。Type-id必须是类的指针、类的引用或者void *；如果type-id是类指针类型，那么expression_r_r也必须是一个指针，如果type-id是一个引用，那么expression_r_r也必须是一个引用。

dynamic_cast主要用于类层次间的上行转换和下行转换，还可以用于类之间的交叉转换。在类层次间进行上行转换时，dynamic_cast和static_cast的效果是一样的；在进行下行转换时，dynamic_cast具有类型检查的功能，比static_cast更安全。

（1）继承关系的类指针对象或引用之间转换

（2）包含有虚函数之间对象指针的转换

除了基类指针指向子类对象，可以没有虚函数外，其它要进行dynamic_cast转换必须具有虚函数才行。下面解释为什么：

虚函数对于dynamic_cast转换的作用

Dynamic_cast转换是在运行时进行转换，运行时转换就需要知道类对象的信息（继承关系等）。如何在运行时获取到这个信息——虚函数表。C++对象模型中，对象实例最前面的就是虚函数表指针，通过这个指针可以获取到该类对象的所有虚函数，包括父类的。因为派生类会继承基类的虚函数表，所以通过这个虚函数表，我们就可以知道该类对象的父类，在转换的时候就可以用来判断对象有无继承关系。

所以虚函数对于正确的基类指针转换为子类指针是非常重要的。

情况1： static_cast转换

class A
{
};

class B:public A
{
public:
    int m;         //B 成员
};
A* pObjA = new A();
B* pObjB  = NULL;
pObjB = static_cast<B*>(pObjA);   //基类指针转化为子类指针成功转换
pObjB->m = 10;                 //实际中pObj所指向的对象是A类对象
//上面会发生什么呢，在VC6.0中正常运行。。。？（测试结果正常运行）
//如果：
pObjB = dynamic_cast<B*>(pObjA); //error 基类A没有虚函数不构成多态

情况2： dynamic_cast转换

class A
{
public:
   virtual ~A(){}         //虚函数多态
};
class B:public A
{
public:
    int m;
};

A* pObjA = new A();
B* pObjB  = NULL;
pObjB = dynamic_cast<B*>(pObjA);  //编译通过
//实际运行结果：pObjB == NULL   // dynamic_cast保证转换无效返回NULL

dynamic_cast转换的安全性

dynamic_cast是动态转换，只有在基类指针转换为子类指针时才有意义。（子类指针转换为基类指针本来就是可以的：基类指针指向子类对象OK）。

但是基类指针转换为子类指针，并不是每一次都有效：只有基类指针本身指向的是一个派生类的对象，然后将此基类指针转换为对应的派生类指针才是有效的。这种情况在表面上是无法判定的。此时dynamic就发挥了作用。dynamic_cast主要用于类层次间的上行转换和下行转换，还可以用于类之间的交叉转换。在类层次间进行上行转换时，dynamic_cast和static_cast的效果是一样的；在进行下行转换时，dynamic_cast具有类型检查的功能，比static_cast更安全。

示例1：

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>）中，只有定义了虚函数的类才有虚函数表，没有定义虚函数的类是没有虚函数表的。

示例2：

另外，dynamic_cast还支持交叉转换（cross cast）。如下代码所示。

class A

{

public:

int m_iNum;

virtual void f(){}

};

class B:public A{};

class D:public A{};

int _tmain(int argc, _TCHAR* argv[])

{

B *pb = new B;

pb->m_iNum = 100;

D *pd1 = static_cast<D *>(pb); //编译出错 error C2440: “static_cast”: 无法从“B *”转换为“D *”

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

delete pb;

return 0;

}

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

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

const_cast

用法：const_cast<type_id> (expression_r_r)

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

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

Voiatile和const类试。举如下一例：

class B

{

public:

int m_iNum;

}

int _tmain(int argc, _TCHAR* argv[])

{

const B b1;

b1.m_iNum = 100; //编译出错：error C3892: “b1”: 不能给常量赋值

B &b2 = static_cast<B&>(b1);//编译出错：error C2440: “static_cast”: 无法从“const B”转换为“B &”

B b2 = const_cast<B>(b1);//编译出错：error C2440: “const_cast”: 无法从“const B”转换为“B”

B &b2 = const_cast<B&>(b1);

b2. m_iNum = 200; //fine

return 0;

}*/

来源：为什么需要dynamic_cast强制转换？
简单的说，当无法使用virtual函数的时候

典型案例：
Wicrosoft公司提供给我们一个类库，其中提供一个类Employee.以头文件Eemployee.h和类库.lib分发给用户
显然我们并无法得到类的实现的源代码

//Emplyee.h
class Employee
{
public:
    virtual int salary();
};

class Manager : public Employee
{
public:
    int salary();
};

class Programmer : public Employee
{
public:
    int salary();
};

我们公司在开发的时候建立有如下类:

class MyCompany
{
public:
    void payroll(Employee *pe);
    //
};

void MyCompany::payroll(Employee *pe)
{
    //do something
}

但是开发到后期，我们希望能增加一个bonus()的成员函数到W$公司提供的类层次中。
假设我们知道源代码的情况下，很简单，增加虚函数：

//Emplyee.h
class Employee
{
public:
    virtual int salary();
    virtual int bonus();
};

class Manager : public Employee
{
public:
    int salary();
};

class Programmer : public Employee
{
public:
    int salary();
    int bonus();
};

//Emplyee.cpp

int Programmer::bonus()
{
    //
}

payroll()通过多态来调用bonus()

class MyCompany
{
public:
    void payroll(Employee *pe);
    //
};

void MyCompany::payroll(Employee *pe)
{
    //do something
    //pe->bonus();
}

但是现在情况是，我们并不能修改源代码，怎么办？dynamic_cast华丽登场了！
在Employee.h中增加bonus()声明，在另一个地方定义此函数，修改调用函数payroll().重新编译，ok

//Emplyee.h
class Employee
{
public:
    virtual int salary();
};

class Manager : public Employee
{
public:
    int salary();
};

class Programmer : public Employee
{
public:
    int salary();
    int bonus();//直接在这里扩展
};

//somewhere.cpp

int Programmer::bonus()
{
    //define
}

class MyCompany
{
public:
    void payroll(Employee *pe);
    //
};

void MyCompany::payroll(Employee *pe)
{
    Programmer *pm = dynamic_cast<Programmer *>(pe);

    //如果pe实际指向一个Programmer对象,dynamic_cast成功，并且开始指向Programmer对象起始处
    if(pm)
    {
        //call Programmer::bonus()
    }
    //如果pe不是实际指向Programmer对象，dynamic_cast失败，并且pm = 0
    else
    {
        //use Employee member functions
    }
}

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

reinterpret_cast

可以转换任意一个32bit整数，包括所有的指针和整数。可以把任何整数转成指针，也可以把任何指针转成整数，以及把指针转化为任意类型的指针，

威力最为强大！但不能将非32bit的实例转成指针。总之，只要是32bit的东东，怎么转都行！

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

前言

这篇文章总结的是C++中的类型转换，这些小的知识点，有的时候，自己不是很注意，但是在实际开发中确实经常使用的。俗话说的好，不懂自己写的代码的程序员，不是好的程序员；如果一个程序员对于自己写的代码都不懂，只是知道一昧的的去使用，终有一天，你会迷失你自己的。

C++中的类型转换分为两种：

隐式类型转换；
显式类型转换。

而对于隐式变换，就是标准的转换，在很多时候，不经意间就发生了，比如int类型和float类型相加时，int类型就会被隐式的转换位float类型，然后再进行相加运算。而关于隐式转换不是今天总结的重点，重点是显式转换。在标准C++中有四个类型转换符：static_cast、dynamic_cast、const_cast和reinterpret_cast；下面将对它们一一的进行总结。

static_cast

static_cast的转换格式：static_cast <type-id> (expression)

将expression转换为type-id类型，主要用于非多态类型之间的转换，不提供运行时的检查来确保转换的安全性。主要在以下几种场合中使用：

用于类层次结构中，基类和子类之间指针和引用的转换；
当进行上行转换，也就是把子类的指针或引用转换成父类表示，这种转换是安全的；
当进行下行转换，也就是把父类的指针或引用转换成子类表示，这种转换是不安全的，也需要程序员来保证；
用于基本数据类型之间的转换，如把int转换成char，把int转换成enum等等，这种转换的安全性需要程序员来保证；
把void指针转换成目标类型的指针，是及其不安全的；

注：static_cast不能转换掉expression的const、volatile和__unaligned属性。

dynamic_cast

dynamic_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更安全。在多态类型之间的转换主要使用dynamic_cast，因为类型提供了运行时信息。下面我将分别在以下的几种场合下进行dynamic_cast的使用总结：

最简单的上行转换
比如B继承自A，B转换为A，进行上行转换时，是安全的，如下：

#include <iostream>using namespace std;class A{     // ......};class B : public A{     // ......};int main(){     B *pB = new B;     A *pA = dynamic_cast<A *>(pB); // Safe and will succeed}

多重继承之间的上行转换
C继承自B，B继承自A，这种多重继承的关系；但是，关系很明确，使用dynamic_cast进行转换时，也是很简单的：
```
class A{     // ......};class B : public A{     // ......};class C : public B{     // ......};int main(){     C *pC = new C;     B *pB = dynamic_cast<B *>(pC); // OK     A *pA = dynamic_cast<A *>(pC); // OK}
```
而上述的转换，static_cast和dynamic_cast具有同样的效果。而这种上行转换，也被称为隐式转换；比如我们在定义变量时经常这么写：B *pB = new C;这和上面是一个道理的，只是多加了一个dynamic_cast转换符而已。
转换成void *
可以将类转换成void *，例如：
```
class A{public:     virtual void f(){}     // ......};class B{public:     virtual void f(){}     // ......};int main(){     A *pA = new A;     B *pB = new B;     void *pV = dynamic_cast<void *>(pA); // pV points to an object of A     pV = dynamic_cast<void *>(pB); // pV points to an object of B}
```
但是，在类A和类B中必须包含虚函数，为什么呢？因为类中存在虚函数，就说明它有想让基类指针或引用指向派生类对象的情况，此时转换才有意义；由于运行时类型检查需要运行时类型信息，而这个信息存储在类的虚函数表中，只有定义了虚函数的类才有虚函数表。
如果expression是type-id的基类，使用dynamic_cast进行转换时，在运行时就会检查expression是否真正的指向一个type-id类型的对象，如果是，则能进行正确的转换，获得对应的值；否则返回NULL，如果是引用，则在运行时就会抛出异常；例如：
```
class B{     virtual void f(){};};class D : public B{     virtual void f(){};};void main(){     B* pb = new D;   // unclear but ok     B* pb2 = new B;     D* pd = dynamic_cast<D*>(pb);   // ok: pb actually points to a D     D* pd2 = dynamic_cast<D*>(pb2);   // pb2 points to a B not a D, now pd2 is NULL}
```
这个就是下行转换，从基类指针转换到派生类指针。
对于一些复杂的继承关系来说，使用dynamic_cast进行转换是存在一些陷阱的；比如，有如下的一个结构：
D类型可以安全的转换成B和C类型，但是D类型要是直接转换成A类型呢？
```
class A{     virtual void Func() = 0;};class B : public A{     void Func(){};};class C : public A{     void Func(){};};class D : public B, public C{     void Func(){}};int main(){     D *pD = new D;     A *pA = dynamic_cast<A *>(pD); // You will get a pA which is NULL}
```
如果进行上面的直接转，你将会得到一个NULL的pA指针；这是因为，B和C都继承了A，并且都实现了虚函数Func，导致在进行转换时，无法进行抉择应该向哪个A进行转换。正确的做法是：
```
int main(){     D *pD = new D;     B *pB = dynamic_cast<B *>(pD);     A *pA = dynamic_cast<A *>(pB);}
```
这就是我在实现QueryInterface时，得到IUnknown的指针时，使用的是*ppv = static_cast<IX *>(this);而不是*ppv = static_cast<IUnknown *>(this);
对于多重继承的情况，从派生类往父类的父类进行转时，需要特别注意；比如有下面这种情况：
现在，你拥有一个A类型的指针，它指向E实例，如何获得B类型的指针，指向E实例呢？如果直接进行转的话，就会出现编译器出现分歧，不知道是走E->C->B，还是走E->D->B。对于这种情况，我们就必须先将A类型的指针进行下行转换，获得E类型的指针，然后，在指定一条正确的路线进行上行转换。

上面就是对于dynamic_cast转换的一些细节知识点，特别是对于多重继承的情况，在实际项目中，很容易出现问题。

const_cast

const_cast的转换格式：const_cast <type-id> (expression)

const_cast用来将类型的const、volatile和__unaligned属性移除。常量指针被转换成非常量指针，并且仍然指向原来的对象；常量引用被转换成非常量引用，并且仍然引用原来的对象。看以下的代码例子：

/*** FileName     : ConstCastDemo** Author       : Jelly Young** Date         : 2013/12/27** Description  : More information, please go to http://www.jellythink.com*/#include <iostream>using namespace std;class CA{public:     CA():m_iA(10){}     int m_iA;};int main(){     const CA *pA = new CA;     // pA->m_iA = 100; // Error     CA *pB = const_cast<CA *>(pA);     pB->m_iA = 100;     // Now the pA and the pB points to the same object     cout<<pA->m_iA<<endl;     cout<<pB->m_iA<<endl;     const CA &a = *pA;     // a.m_iA = 200; // Error     CA &b = const_cast<CA &>(a);     pB->m_iA = 200;     // Now the a and the b reference to the same object     cout<<b.m_iA<<endl;     cout<<a.m_iA<<endl;}

注：你不能直接对非指针和非引用的变量使用const_cast操作符去直接移除它的const、volatile和__unaligned属性。

reinterpret_cast

reinterpret_cast的转换格式：reinterpret_cast <type-id> (expression)

允许将任何指针类型转换为其它的指针类型；听起来很强大，但是也很不靠谱。它主要用于将一种数据类型从一种类型转换为另一种类型。它可以将一个指针转换成一个整数，也可以将一个整数转换成一个指针，在实际开发中，先把一个指针转换成一个整数，在把该整数转换成原类型的指针，还可以得到原来的指针值；特别是开辟了系统全局的内存空间，需要在多个应用程序之间使用时，需要彼此共享，传递这个内存空间的指针时，就可以将指针转换成整数值，得到以后，再将整数值转换成指针，进行对应的操作。

总结

这篇博文总结了C++中的类型转换，重点总结了其中的显式转换。对于C++支持的这四种显式转换都进行了详细的描述。如果大家有什么补充的，或者我总结的有误的地方，请大家多多指教。

听闻雷哥在北京面试不顺，公司对数据结构和算法都要求很多，过段日子准备再将数据结构和算法进行整理一下。

2013年12月27日于大连，东软。

0 0