c++类型转换

c++类型转换的解决方法：

1）C风格的强制类型转换

2）标准C++的类型转换符:static_cast、dynamic_cast、reinterpret_cast、和const_cast

static_cast              静态类型转换，属于最安全的强制类型转换。

const_cast              在可变与不可变类型之间转换
dynamic_cast        在多态的情况下，父子类之间的转换
reinterpret_cast     所有类型间的转换，最不安全的转换

1、C风格的类型转换

1）显示强制类型转换

用法: type (expression)或（type）expression
　　经强制类型转换运算符运算后，返回一个具有type类型的数值，这种强制类型转换操作并不改变操作数本身，运算后操作数本身未改变。

代码如下：

int nVar=0xab65;char cChar=char (nVar);

　　强制类型转换的结果是将整型值0xab65的高端3个字节删掉，将低端1个字节的内容作为char型数值赋值给变量cChar。

2）隐式强制类型转换
　　隐式类型转换发生在赋值表达式、有返回值的函数调用表达式、函数参数拷贝。

在赋值表达式中，如果赋值符左右两侧的操作数类型不同，则将赋值符右边操作数强制转换为赋值符左侧的类型数值后，赋值给赋值符左侧的变量。

在函数调用时，如果return后面表达式的类型与函数返回值类型不同，则在返回值时将return后面表达式的数值强制转换为函数返回值类型后，再将值返回。

参数拷贝时，先转换为目标类型后，传递参数。

2、标准C++的类型转换符

C++的四种强制转型形式如下。

（1）static_cast

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

运算符把expression_r_r转换为type-id类型，但没有运行时类型检查来保证转换的安全性。

目的：
1）用于类层次结构中基类和子类之间指针或引用的转换。进行上行转换（把子类的指针或引用转换成基类表示）是安全的；

2）进行下行转换（把基类指针或引用转换成子类表示）时，由于没有动态类型检查，所以是不安全的。
3）用于基本数据类型之间的转换，如把int转换成char，把int转换成enum。

4）把空指针(void*)转换成目标类型的空指针

5）把任何类型的表达式转换成void*类型
注意：static_cast接近于C-style的转换，不能转换掉expression_r_r的const、volitale、或者__unaligned属性。

（2）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也必须是一个引用。

将一个基类对象指针（或引用）cast到继承类指针，dynamic_cast会根据基类指针是否真正指向继承类指针来做相应处理。(会作一定的判断)
1)对指针进行dynamic_cast，失败返回null，成功返回正常cast后的对象指针； 
2) 对引用进行dynamic_cast，失败抛出一个异常，成功返回正常cast后的对象引用。 

注意：dynamic_cast在将父类cast到子类时，父类必须要有虚函数。
例如在下面的代码中将CBasic类中的test函数不定义成virtual时，编译器会报错：error C2683: dynamic_cast : “CBasic”不是多态类型 
  
对编译器的要求： 
dynamic_cast<> 会用到RTTI技术，因此需要启动“运行时类型信息”这一选项，而在VC.net 2003中默认是关闭的。 
所以需要启动这一选项。否则编译器会报下面的警告：   
warning C4541: “dynamic_cast”用在了带 /GR- 的多态类型“CBasic”上； 
致不可预知的行为从而导致程序在运行时发生异常。 
该设置在 Project->Setting中 C/C++ -> C++ Language中设置。 

代码如下：

#include <iostream> using namespace std; class CBasic { public:      virtual int test(){return 0;} // 一定要是 virtual };   class CDerived : public CBasic { public:      virtual int test(){return 1;} //覆盖父类函数}; int main() { CBasic        cBasic; CDerived    cDerived;CBasic * pB1 = new CBasic;CBasic * pB2 = new CDerived;//dynamic cast failed, so pD1 is null.CDerived * pD1 = dynamic_cast<CDerived * > (pB1);            //dynamic cast succeeded, so pD2 points to  CDerived object                                      CDerived * pD2 = dynamic_cast<CDerived * > (pB2);//dynamci cast failed, so throw an exception.       //CDerived & rD1 = dynamic_cast<CDerived &> (*pB1);//dynamic cast succeeded, so rD2 references to CDerived object. CDerived & rD2 = dynamic_cast<CDerived &> (*pB2);    delete pB1;delete pB2;return 0; } 

dynamic_cast与static_cast区别：

1）用于执行安全的向下转型。

也就是说，要确定一个对象是否是一个继承体系中的一个特定类型。它是唯一不能用旧风格语法执行的强制转型，也是唯一可能有重大运行时代价的强制转型。

在类层次间进行上行转换时，dynamic_cast和static_cast的效果是一样的；在进行下行转换时，dynamic_cast具有类型检查的功能，比static_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会编译出错，由于运行时类型检查需要运行时类型信息，需要的信息存储在类的虚函数表（如果定义了虚函数）。

2）用于类之间的交叉转换检查

代码如下：

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); //copile errorD *pd2 = dynamic_cast<D *>(pb); //pd2 is NULLdelete pb;}

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

（3）reinpreter_cast

原型：reinpreter_cast<type-id> (expression_r_r)

type-id必须是一个指针、引用、算术类型、函数指针或者成员指针。操作符修改了操作数类型,但仅仅是重新解释了给出的对象的比特模型而没有进行二进制转换。

例如：

int *n= new int ;double *d=reinterpret_cast<double*> (n);

在进行计算以后, d 包含无用值. 这是因为 reinterpret_cast 仅仅是复制 n 的比特位到 d, 没有进行必要的分析。

 

1)static_cast 与 reinterpret_cast

reinterpret_cast是为了映射到一个完全不同类型的意思，这个关键词在我们需要把类型映射回原有类型时用到它。我们映射到的类型仅仅是为了故弄玄虚和其他目的，这是所有映射中最危险的。(这句话是C++编程思想中的原话)

static_cast和reinterpret_cast的区别主要在于多重继承的地址偏移

代码如下：

class A {   public:   int m_a;}; class B {   public:   int m_b;}; class C : public A,public B {};C c;printf("%p, %p, %p", &c, reinterpret_cast<B*>(&c),static_cast<B*>(&c));

前两个的输出值是相同的，最后一个则会在原基础上偏移4个字节。

因为static_cast计算了父子类指针转换的偏移量，并将之转换到正确的地址（c里面有m_a,m_b，转换为B*指针后指到m_b处），而reinterpret_cast却不会做这一层转换。

应用场合：

是特意用于底层的强制转型，导致实现依赖（不可移植）的结果，例如，将一个指针转型为一个整数。一般用在底层代码。需要谨慎使用 reinterpret_cast.

（4）const_cast

原型：const_cast<type_id> (expression_r_r)

该运算符用来修改类型的const或volatile属性。它是唯一能做到这一点的 C++ 风格的强制转型。 

除了const 或volatile修饰之外， type_id和expression_r_r的类型是一样的。

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

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

常量对象被转换成非常量对象。

代码：

class B{public:int m_iNum;}void foo(){const B b1;b1.m_iNum = 100; //comile errorB b2 = const_cast<B>(b1);b2. m_iNum = 200; //fine}

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

使用const_cast把它转换成一个常量对象，就可以对它的数据成员任意改变。

注意：b1和b2是两个不同的对象。