C++中强制类型转换的应用

　　4.       Const_cast 该运算符用来修改类型的const或volatile属性。除了const 或volatile修饰之外， type_id和expression的类型是一样的。
　　一、常量指针被转化成非常量指针，并且仍然指向原来的对象；
　　二、常量引用被转换成非常量引用，并且仍然指向原来的对象；
　　三、常量对象被转换成非常量对象。
　　Voiatile和const类试。举如下一例：
class B
{
public:
int m_iNum;
B(){}
};
void foo()
{
const B b1;
//b1.m_iNum = 100; //compile error
B& b2 = const_cast<B&>(b1);
b2. m_iNum = 200; //fine?
}
int main()
{
foo();
return 0;
}
　上面的代码编译时会报错，因为b1是一个常量对象，不能对它进行改变；
　　使用const_cast把它转换成一个非常量对象，可以对它的数据成员任意改变。注意：b1和b2是两个不同的对象。
　　c/c++强制类型转换
　　Q:什么是C风格转换？什么是static_cast， dynamic_cast 以及 reinterpret_cast？区别是什么？为什么要注意？
　　A:转换的含义是通过改变一个变量的类型为别的类型从而改变该变量的表示方式。为了类型转换一个简单对象为另一个对象你会使用传统的类型转换操作符。比如，为了转换一个类型为doubole的浮点数的指针到整型：
　　代码:
　　int i;
　　double d;
　　i = (int) d;或者：i = int (d);
　　对 于具有标准定义转换的简单类型而言工作的很好。然而，这样的转换符也能不分皂白的应用于类（class）和类的指针。ANSI-C++标准定义了四个新的 转换符：'reinterpret_cast'， 'static_cast'， 'dynamic_cast' 和 'const_cast'，目的在于控制类(class)之间的类型转换。
　　代码:
　　reinterpret_cast<new_type>(expression)
　　dynamic_cast<new_type>(expression)
　　static_cast<new_type>(expression)
　　const_cast<new_type>(expression)
　　1 reinterpret_cast
　　reinterpret_cast 转换一个指针为其它类型的指针。它也允许从一个指针转换为整数类型。反之亦然。（译注：是指针具体的地址值作为整数值？）
　　这个操作符能够在非相关的类型之间转换。操作结果只是简单的从一个指针到别的指针的值的二进制拷贝。在类型之间指向的内容不做任何类型的检查和转换。如果情况是从一个指针到整型的拷贝，内容的解释是系统相关的，所以任何的实现都不是方便的。一个转换到足够大的整型能够包含它的指针是能够转换回有效的指针的。
　　代码:
　　class A {};
　　class B {};
　　A * a = new A;
　　B * b = reinterpret_cast<B *>(a);
　　reinterpret_cast  像传统的类型转换一样对待所有指针的类型转换。
　　2 static_cast
　　static_cast 允许执行任意的隐式转换和相反转换动作。（即使它是不允许隐式的）
　　意思是说它允许子类类型的指针转换为父类类型的指针（这是一个有效的隐式转换），同时，也能够执行相反动作：转换父类为它的子类。
　　在这后例子里，被转换的父类没有被检查是否与目的类型相一致。
　　代码：
　　class Base {};
　　class Derived : public Base {};
　　Base *a    = new Base;
　　Derived *b = static_cast<Derived *>(a);
　　static_cast  除了操作类型指针，也能用于执行类型定义的显式的转换，以及基础类型之间的标准转换:
　　代码:
　　double d = 3.14159265;
　　int    i = static_cast<int>(d);
　　3 dynamic_cast
　　dynamic_cast 只用于对象的指针和引用。当用于多态类型时，它允许任意的隐式类型转换以及相反过程。不过，与static_cast不同，在后一种情况里（注：即隐式转 换的相反过程），dynamic_cast会检查操作是否有效。也是说，它会检查转换是否会返回一个被请求的有效的完整对象。
　　检测在运行时进行。如果被转换的指针不是一个被请求的有效完整的对象指针，返回值为NULL.
　　代码：
　　class Base { virtual dummy() {} };
　　class Derived : public Base {};
　　Base* b1 = new Derived;
　　Base* b2 = new Base;
　　Derived* d1 = dynamic_cast<Derived *>(b1);          // succeeds
　　Derived* d2 = dynamic_cast<Derived *>(b2);          // fails: returns 'NULL'
　　如果一个引用类型执行了类型转换并且这个转换是不可能的，一个bad_cast的异常类型被抛出：
　　代码:
　　class Base { virtual dummy() {} };
　　class Derived : public Base { };
　　Base* b1 = new Derived;
　　Base* b2 = new Base;
　　Derived d1 = dynamic_cast<Derived &*>(b1);          // succeeds
　　Derived d2 = dynamic_cast<Derived &*>(b2);          // fails: exception thrown
　　4 const_cast
　　这个转换类型操纵传递对象的const属性，或者是设置或者是移除：
　　代码:
　　class C {};
　　const C *a = new C;
　　C *b = const_cast<C *>(a);
　　其它三种操作符是不能修改一个对象的常量性的。
　　注意：'const_cast'也能改变一个类型的volatile qualifier。
　　C++的四种强制转型形式每一种适用于特定的目的：
　　·dynamic_cast 主要用于执行“安全的向下转型（safe downcasting）”，也是说，要确定一个对象是否是一个继承体系中的一个特定类型。它是不能用旧风格语法执行的强制转型，也是可能有重大运行时代价的强制转型。
　　·static_cast 可以被用于强制隐型转换（例如，non-const 对象转型为 const 对象，int 转型为 double，等等），它还可以用于很多这样的转换的反向转换（例如，void* 指针转型为有类型指针，基类指针转型为派生类指针），但是它不能将一个 const 对象转型为 non-const 对象（只有 const_cast 能做到），它接近于C-style的转换。
　　·const_cast 一般用于强制消除对象的常量性。它是能做到这一点的 C++ 风格的强制转型。
　　·reinterpret_cast 是特意用于底层的强制转型，导致实现依赖（implementation-dependent）（是说，不可移植）的结果，例如，将一个指针转型为一个整数。这样的强制转型在底层代码以外应该极为罕见。
　　C风格的强制类型转换(Type Cast)很简单，不管什么类型的转换统统是：
　　TYPE b = (TYPE)a
　　C++风格的类型转换提供了4种类型转换操作符来应对不同场合的应用。
　　const_cast，字面上理解是去const属性。
　　static_cast，命名上理解是静态类型转换。如int转换成char。
　　dynamic_cast，命名上理解是动态类型转换。如子类和父类之间的多态类型转换。
　　reinterpreter_cast，仅仅重新解释类型，但没有进行二进制的转换。
　　4种类型转换的格式，如：
　　TYPE B = static_cast(TYPE)(a)
　　const_cast
　　去掉类型的const或volatile属性。
　　struct SA {
　　int i;
　　};
　　const SA ra;
　　//ra.i = 10; //直接修改const类型，编译错误
　　SA &rb = const_castSA&>(ra);
　　rb.i = 10;
　　static_cast
　　类似于C风格的强制转换。无条件转换，静态类型转换。用于：
　　1. 基类和子类之间转换：其中子类指针转换成父类指针是安全的;但父类指针转换成子类指针是不安全的。(基类和子类之间的动态类型转换建议用dynamic_cast)
　　2. 基本数据类型转换。enum， struct， int， char， float等。static_cast不能进行无关类型(如非基类和子类)指针之间的转换。
　　3. 把空指针转换成目标类型的空指针。
　　4. 把任何类型的表达式转换成void类型。
　　5. static_cast不能去掉类型的const、volitale属性(用const_cast)。
　　int n = 6;
　　double d = static_castdouble>(n); // 基本类型转换
　　int *pn = &n;
　　double *d = static_castdouble *>(&n) //无关类型指针转换，编译错误
　　void *p = static_castvoid *>(pn); //任意类型转换成void类型
　　dynamic_cast
　　有条件转换，动态类型转换，运行时类型安全检查(转换失败返回NULL)：
　　1. 安全的基类和子类之间转换。
　　2. 必须要有虚函数。
　　3. 相同基类不同子类之间的交叉转换。但结果是NULL。
class BaseClass {
public:
int m_iNum;
virtual void foo(){};
//基类必须有虚函数。保持多台特性才能使用dynamic_cast
};
class DerivedClass: public BaseClass {
public:
char *m_szName[100];
void bar(){};
};
BaseClass* pb = new DerivedClass();
DerivedClass *pd1 = static_castDerivedClass *>(pb);
//子类->父类，静态类型转换，正确但不推荐
DerivedClass *pd2 = dynamic_castDerivedClass *>(pb);
//子类->父类，动态类型转换，正确
BaseClass* pb2 = new BaseClass();
DerivedClass *pd21 = static_castDerivedClass *>(pb2);
//父类->子类，静态类型转换，危险！访问子类m_szName成员越界
DerivedClass *pd22 = dynamic_castDerivedClass *>(pb2);
//父类->子类，动态类型转换，安全的。结果是NULL
reinterpreter_cast
　　仅仅重新解释类型，但没有进行二进制的转换：
　　1. 转换的类型必须是一个指针、引用、算术类型、函数指针或者成员指针。
　　2. 在比特位级别上进行转换。它可以把一个指针转换成一个整数，也可以把一个整数转换成一个指针(先把一个指针转换成一个整数，在把该整数转换成原类型的指针，还可以得到原先的指针值)。但不能将非32bit的实例转成指针。
　　3. 普通的用途是在函数指针类型之间进行转换。
　　4. 很难保证移植性。
int doSomething(){return 0;};
typedef void(*FuncPtr)();
//FuncPtr is 一个指向函数的指针，该函数没有参数，返回值类型为 void
FuncPtr funcPtrArray[10];
//10个FuncPtrs指针的数组 让我们假设你希望（因为某些莫名其妙的原因）把一个指向下面函数的指针存入funcPtrArray数组：
funcPtrArray[0] = &doSomething;
// 编译错误！类型不匹配，reinterpret_cast可以让编译器以你的方法去看待它们：funcPtrArray
funcPtrArray[0] = reinterpret_castFuncPtr>(&doSomething);
//不同函数指针类型之间进行转换
　　总 结
　　去const属性用const_cast。
　　基本类型转换用static_cast。
　　多态类之间的类型转换用daynamic_cast。
　　不同类型的指针类型转换用reinterpreter_cast。