C++强制类型转换
1.C语言的强制类型转换与C++区别
C风格的强制类型转换统一使用()，而()在代码中随处可见，所以也不利于使用检索工具定位强转的代码位置。
C++ 对类型转换进行了分类，并新增了四个关键字来予以支持，它们分别是：
关键字 说明
static_cast 用于良性转换，一般不会导致意外发生，风险很低。
const_cast 用于 const 与非 const、volatile 与非 volatile 之间的转换。
reinterpret_cast 高度危险的转换，这种转换仅仅是对二进制位的重新解释，不会借助已有的转换规则对数据进行调整，但是可以实现最灵活的 C++ 类型转换。
dynamic_cast 借助 RTTI，用于类型安全的向下转型（Downcasting）。
语法格式为： xxx_cast
2.static_cast
#include
#include
using namespace std;
class Complex{
public:
Complex(double real = 0.0, double imag = 0.0): m_real(real), m_imag(imag){ }
public:
operator double() const { return m_real; } //类型转换函数
private:
double m_real;
double m_imag;
};
int main(){
//下面是正确的用法
int m = 100;
Complex c(12.5, 23.8);
long n = static_cast(m); //宽转换，没有信息丢失
char ch = static_cast(m); //窄转换，可能会丢失信息
int *p1 = static_cast( malloc(10 * sizeof(int)) ); //将void指针转换为具体类型指针
void *p2 = static_cast(p1); //将具体类型指针，转换为void指针
double real= static_cast(c); //调用类型转换函数
//下面的用法是错误的
float *p3 = static_cast(p1); //不能在两个具体类型的指针之间进行转换
p3 = static_cast(0X2DF9); //不能将整数转换为指针类型
return 0;
} 3.reinterpret_cast
#include
using namespace std;
class A
{
public:
int i;
int j;
A(int n):i(n),j(n) { }
};
int main()
{
A a(100);
int &r = reinterpret_cast(a); //强行让 r 引用 a
r = 200; //把 a.i 变成了 200
cout << a.i << "," << a.j << endl; // 输出 200,100
int n = 300;
A *pa = reinterpret_cast ( & n); //强行让 pa 指向 n
pa->i = 400; // n 变成 400
pa->j = 500; //此条语句不安全，很可能导致程序崩溃
cout << n << endl; // 输出 400
long long la = 0x12345678abcdLL;
pa = reinterpret_cast(la); //la太长，只取低32位0x5678abcd拷贝给pa
unsigned int u = reinterpret_cast(pa);//pa逐个比特拷贝到u
cout << hex << u << endl; //输出 5678abcd
typedef void (* PF1) (int);
typedef int (* PF2) (int,char *);
PF1 pf1; PF2 pf2;
pf2 = reinterpret_cast(pf1); //两个不同类型的函数指针之间可以互相转换
}
4.const_cast
const_cast 运算符仅用于进行去除 const 属性的转换，它也是四个强制类型转换运算符中唯一能够去除 const 属性的运算符。
将 const 引用转换为同类型的非 const 引用，将 const 指针转换为同类型的非 const 指针时可以使用 const_cast 运算符。例如：
const string s = "Inception";
string& p = const_cast (s);
string* ps = const_cast (&s); // &s 的类型是 const string*
5.dynamic_cast
5.1向上转型（Upcasting)
向上转型时，只要待转换的两个类型之间存在继承关系，并且基类包含了虚函数（这些信息在编译期间就能确定），就一定能转换成功。因为向上转型始终是安全的，所以 dynamic_cast 不会进行任何运行期间的检查，这个时候的 dynamic_cast 和 static_cast 就没有什么区别了。
「向上转型时不执行运行期检测」虽然提高了效率，但也留下了安全隐患，请看下面的代码：
#include
#include
using namespace std;
class Base{
public:
Base(int a = 0): m_a(a){ }
int get_a() const{ return m_a; }
virtual void func() const { }
protected:
int m_a;
};
class Derived: public Base{
public:
Derived(int a = 0, int b = 0): Base(a), m_b(b){ }
int get_b() const { return m_b; }
private:
int m_b;
};
int main(){
//情况①
Derived *pd1 = new Derived(35, 78);
Base *pb1 = dynamic_cast(pd1);
cout<<"pd1 = "<#include
using namespace std;
class A{
public:
virtual void func() const { cout<<"Class A"<(pa); //向下转型失败
if(pb == NULL){
cout<<"Downcasting failed: A* to B*"< func();
}
pc = dynamic_cast(pa); //向下转型失败
if(pc == NULL){
cout<<"Downcasting failed: A* to C*"< func();
}
cout<<"-------------------------"<(pa); //向下转型成功
if(pb == NULL){
cout<<"Downcasting failed: A* to B*"< func();
}
pc = dynamic_cast(pa); //向下转型成功
if(pc == NULL){
cout<<"Downcasting failed: A* to C*"< func();
}
return 0;
} 当使用 dynamic_cast 对指针进行类型转换时，程序会先找到该指针指向的对象，再根据对象找到当前类（指针指向的对象所属的类）的类型信息，并从此节点开始沿着继承链向上遍历，如果找到了要转化的目标类型，那么说明这种转换是安全的，就能够转换成功，如果没有找到要转换的目标类型，那么说明这种转换存在较大的风险，就不能转换。
对于本例中的情况①，pa 指向 A 类对象，根据该对象找到的就是 A 的类型信息，当程序从这个节点开始向上遍历时，发现 A 的上方没有要转换的 B 类型或 C 类型（实际上 A 的上方没有任何类型了），所以就转换败了。对于情况②，pa 指向 D 类对象，根据该对象找到的就是 D 的类型信息，程序从这个节点向上遍历的过程中，发现了 C 类型和 B 类型，所以就转换成功了。
总起来说，dynamic_cast 会在程序运行过程中遍历继承链，如果途中遇到了要转换的目标类型，那么就能够转换成功，如果直到继承链的顶点（最顶层的基类）还没有遇到要转换的目标类型，那么就转换失败。对于同一个指针（例如 pa），它指向的对象不同，会导致遍历继承链的起点不一样，途中能够匹配到的类型也不一样，所以相同的类型转换产生了不同的结果。
从表面上看起来 dynamic_cast 确实能够向下转型，本例也很好地证明了这一点：B 和 C 都是 A 的派生类，我们成功地将 pa 从 A 类型指针转换成了 B 和 C 类型指针。但是从本质上讲，dynamic_cast 还是只允许向上转型，因为它只会向上遍历继承链。造成这种假象的根本原因在于，派生类对象可以用任何一个基类的指针指向它，这样做始终是安全的。本例中的情况②，pa 指向的对象是 D 类型的，pa、pb、pc 都是 D 的基类的指针，所以它们都可以指向 D 类型的对象，dynamic_cast 只是让不同的基类指针指向同一个派生类对象罢了。