C++ 强制类型转换（4种）

• C++强制类型转换
  
  • static_cast
  • const_cast
  • reinterpret_cast
  • dynamic_cast
• static_cast
  - static_cast用于非多态类型的转换（静态转换），任何标准转换都可以用，但是不能用于两个不相关类型的转换

void Test1()
{
     int i = 1;
     float d = static_cast< float>(i );
     printf("%d, %.2f\n" , i, d);
}
i = 1;
d = 1.00;

• reinterpret_cast
  reinterpret_cast操作符用于将一种类型转换为另一种不同的类型。

typedef void (* FUNC)();

int DoSomething (int i)
{
     cout<<"DoSomething" <<endl;
     return 0;
}

void Test2()
{
     FUNC f = reinterpret_cast< FUNC>(DoSomething );
     f();
}

• const_cast
  - 最常用的就是删除变量的const属性，方便赋值。

void Test3 ()
{
     const int a = 2;
     int* p = const_cast< int*>(&a );
     cout<<a<<endl;         //a的值
     cout<<*p<<endl;            //p指向地址的值
     *p = 3;
     cout<<a <<endl;            //修改后a的值
     cout<<*p<<endl;            //修改后p指向地址的值
     cout<<p<<endl;         //p中的地址
     cout<<&a<<endl;            //a的地址
}

运行结果如下：

由上图得到->a 的值并没有改变，但是*p的值却变了。他俩又是一个地址。

去除const属性：
当一个函数形参是非const的，现在有一个const类型的实参要传进去，为了能让形参接受实参就需要去除const类型数据的const属性；
const想要调用自身非const的方法。

• dynamic_cast
  
  • 将一个父类对象的指针转换为子类对象的指针或引用（动态转换）
  • 向上转型：子类对象指针->父类指针或引用（不需要转换）
  • 向下转型：父类指针对象->子类指针或引用（用dynamic_cast转型是安全的）
    -dynamic_cast只能用于含有虚函数的类
    dynamic_cast会先检查是否能转换成功，能成功则转换，不能则返回0；

class base
{
public :
     virtual void f(){}
};

class derive : public base
{};

void fun (base* pa)
{

   derive* pb1 = static_cast<derive*>(pa);
   derive* pb2 = dynamic_cast<derive*>(pa);     // dynamic_cast会先检查是否能转换成功，能成功则转换，不能则返回


   cout<<"pb1:" <<pb1<< endl;
   cout<<"pb2:" <<pb2<< endl;
}

int main ()
{
     base a;
     derive b;
     fun(&a);
     fun(&b);
     return 0;
}

• explicit关键字
  - 阻止经过转换构造函数进行的隐式转换的发生
  - 对单参数构造函数使用C++关键字explicit。
  通常，只有一个参数的构造函数可被用于转换（隐式转换）

class A
{
public :
     explicit A (int a)
    {
         cout<<"A(int a)" <<endl;
    }

     A(const A& a)
    {
         cout<<"A(const A& a)" <<endl;
    }
private :
     int _a ;
};

int main ()
{
     A a1 (1);

     // 隐式转换-> A tmp(1); A a2(tmp);
     A a2 = 1;
}

如果没有加explicit，程序是可以编译通过的，加了explicit 程序编译不通过，无法形成隐式转换。
说明explicit关键字就是为了阻止经过 转换构造函数 进行的隐式转换的发生。