C++：强制类型转换

更多C++知识点：C++目录索引

---

1. C语言中的几种强制类型转换

　　C语言的强制类型转换不做解释，直接上代码：

//c语言
void TestC()
{
    int i = 1;
    double d = i;//相近类型的隐式类型转换（１）

    int* p = &i;
    //int j = p;//不是相近类型，不支持隐式类型转换，一个指针，一个大小
    int j = (int)p;//不相关类型，需要进行强制类型的转换（２）
}

2. C++几种强制类型转换

1. static_cast ——– 相关类型隐式类型转换

   1. 用于非多态的类型转换
   2. 用于两个相关（相近）类型之间进行转换
   3. 相当于C语言中的隐式类型转换 　

   　示例：　

   void test_static_cast()
   {
       int i = 10;
       double d = static_cast<double>(i);//c语言的隐式类型转换，相关类型，相近类型的转换
   }
   

2. reinterpret_cast ——— 不相关类型的隐式类型转换

   1. 用于静态的强制类型转换
   2. 用于两个不相关类型变量之间的转换
   3. 相当于C语言中的部分强制类型转换

   示例：

       void test_reinterpret_cast()
       {
           int i = 10;
   
           int* p = &i;//指针
           int j = reinterpret_cast<int>(p);//大小

3. const_cast ——— 去除const属性的强制类型转换

   1. 用于静态的强制类型转换
   2. 去掉变量的const属性

   示例：

       void test_const_cast()
       {
           int i = 10;
           int* p = &i;
   
           const int* p1 = p;
           int* p2 = const_cast<int*>(p1);//去掉const属性-----C部分强制类型转换
           //将const指针赋给非const，这是非法的，因为权限扩大，但是加上const_cast后，就会将其const属性去掉，不在受到权限扩大的影响
       }

4. dynamic_cast ———— 多态的强制类型转换

   1. 用于将父类对象的指针转换为子类对象的指针或引用，是一种动态的强制类型转换
   2. 只能作用于含有虚函数的类
   3. 当父类指针转换成子类的指针时，会先检查是否能够转换成功，如果能够转换成功，就将其转换，如果不能，就返回0

   示例：

       class A
       {   
       public:
           virtual void f()
           {
               cout << __FUNCTION__ << endl;
           }
   
           int _a;
       };
   
       class B :public  A
       {
       public:
           virtual void f()
           {
               cout << __FUNCTION__ << endl;//宏替换
   
           }
   
           int _b;
       };
   
   
       //这里检查传过来的指针p是父类还是子类
       //如果是父类指针，那么将不能转换成功，因为父类不能给子类
       //如果本来就是子类，那么就可以将其转换
       void func(A* p)
       {
           p->f();
   
           //p是指向父类还是子类？
           B* p1 = dynamic_cast<B*>(p);
           if (p1 != NULL)
           {
               cout << "子类" << endl;
               printf("%p\n",p1);
           }
           else
           {
               cout << "父类" << endl;
               printf("%p\n",p1);
           }
       }
       void test1()
       {
           A a;
           B b;
   
           //func(&a);
           func(&b);
       }

   结果：

   

3. explicit 关键字

　　explicit关键字阻止经过转换构造函数进行的隐式转换的发生。但只能阻止具有但参数构造函数类的隐式类型转换
　　
示例：

class AA
{
public:
  explicit  AA(int a)//加上explicit，会阻止隐式类型的转换
        :_a(a)
    {
        cout << "AA()" << endl;
    }
    AA(const AA& a)
        :_a(a._a)
    {
        cout << "拷贝构造" << endl;
    }
protected:
    int _a;
};
void test_explicit()
{
    AA a1 = 20;// 隐式类型转换----具有单参数构造函数的类型
}   

结果：