类型转换

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.