类型转换

1. 旧式类型转换–隐式类型转换&强制类型转换
【缺陷】
强制转换的可视性比较差， 所有的转换形式都是以一种相同
形式书写， 难以跟踪错误的转换。
C++强制类型转换
标准C++为了加强类型转换的可视性，引入了四种命名的强制类
型转换操作符：
static_cast/reinterpret_cast/const_cast/dynamic_cast
static_cast
static_cast用于非多态类型的转换（静态转换），编译器隐式
执行的任何类型转换都可用static_cast，但它不能用于两个不
相关的类型进行转换。
reinterpret_cast
reinterpret_cast操作符通常为操作数的位模式提供较低层次的
重新解释，用于将一种类型转换为另一种不同的类型。
const_cast
const_cast最常用的用途就是删除变量的const属性，方便赋
值
dynamic_cast
dynamic_cast用于将一个父类对象的指针转换为子类对象的指针
或引用（动态转换）
向上转型：子类对象指针->父类指针/引用（不需要转换）
向下转型：父类对象指针->子类指针/引用（用dynamic_cast转
型是安全的）
1. dynamic_cast只能用于含有虚函数的类
2. dynamic_cast会先检查是否能转换成功，能成功则转换，不
能则返回0
【注意】
强制类型转换关闭或挂起了正常的类型检查，每次使用强制
类型转换前，程序员应该仔细考虑是否还有其他不同的方法达到
同一目的，如果非强制类型转换不可，则应限制强制转换值的作
用域，以减少发生错误的机会。强烈建议：避免使用强制类型
转换。
explicit关键字
explicit关键字阻止经过转换构造函数进行的隐式转换的发生。
强制类型转换：

C++中的强制类型转换：static_cast、reinterpret_cast、const_cast、dynamic_cast.  

static_cast：用于非多态类型之间的转换(静态转换)，任何标准类型之间都可以用它，但它不能用于不相关类型之间的转换。static_cast只能用于相关类型之间的转换。  
例：  
       int i = 2;  
       double d = static_cast<double>(i); //正确，相关类型转换        
       int *p = &i;  
       double d = static_cast<double>(p);//错误，不能转换，不想关类型  



reinterpret_cast：操作符用于将一种类型转换成另一种不同的类型.  
例：  
typedef void(*FUNC)();  
int DoSomthing(int i)  
{  
       cout << "DoSomthing():" << i << endl;  
       return 0;  
}  
void test()  
{  
       FUNC pf = reinterpret_cast<FUNC>(DoSomthing);  
       pf();  
}  
reinterpret_cast：可以让编译器以FUNC的定义方式去看待DoSomething函数，不过这样有时会产生不确定的结果。总而言之，reinterpret_cast非常的BUG。  


const_cast：最常见的用途就是删除变量的const属性，方便赋值。  
例：  
void test()  
{  
       const int i = 10;  
       int* b =const_cast<int *>(&i);  
       *b = 20;  
       cout << i << endl;      //结果是10，因为编译器有优化，所以会到寄存器中取值  
       cout << *b << endl;     //结果是20，b指向内存中的i,改的是内存中的值  
}  

void test()  
{  
       volatile const int i = 10;     
       int* b =const_cast<int *>(&i);  
       *b = 20;  
       cout << i << endl;      //结果是20,因为volatile保证内存可见性  
       cout << *b << endl;      
}  

dynamic_cast：用于将一个父类对象的指针或引用转换成子类对象的指针或引用。  
1、dynamic_cast只能用于含有虚函数的类  
2、如果父类指针指向的是父类对象，则会返回0，如果父类指针指向子类对象，则转化成功。  
例：  
void test()  
{  
       A a;  
       B b;  
       A *pa = &a;  //正确，父类指针指向父类对象  
       pa = &b;     //正确，父类指针指向子类对象  
       //B *pb = &a;  //c错误，子类指针指向父类对象  
       B *pb = &b;      //正确，子类指针指向子类对象  
}  

void fun(A *pa)  
{  
       B *pb = dynamic_cast<B *>(pa);        //如果pa指向父类对象，则返回0，如果指向子类对象，成功转换  
       cout << "pb1:" << pb<< endl;  
}  
void test()  
{  
       A a;  
       B b;  
       fun(&a);             
       cout << &a << endl;  
       fun(&b);  
       cout << &b<< endl;  
}  

explicit：防止经过构造函数进行的隐式类型转换  
例：  
class A  
{  
public:  
       A(int a)  
              :_a(0){}  
       A(const A& a)  
       {  
       }  
private:  
       int _a;  
};  
void test()  
{  
       A a1(1);  //直接初始化  
       //1隐式转换成 A tmp(1),A a2(tmp)  
       A a2 = 1;       //正确  
}  


class A  
{  
public:  
       explicit A(int a)  
              :_a(0){}  
       A(const A& a)  
       {  
       }  
private:  
       int _a;  
};  
void test()  
{  
       A a1(1);  //直接初始化  
       //1隐式转换成 A tmp(1),A a2(tmp)  
       A a2 = 1;    //错误  
}  
如果不希望生成中间对象的话，可以在构造函数前面声明explicit.