二十二、类型转换

类型转换的名称和语法

类型转换有 c 风格的,当然还有 c++风格的。c 风格的转换的格式很简单(TYPE) EXPRESSION,但是 c 风格的类型转换有不少的缺点,有的时候用 c 风格的转换是不合适的,因为它可以在任意类型之间转换,比如你可以把一个指向const 对象的指针转换成指向非 const 对象的指针,把一个指向基类对象的指针转换成指向一个派生类对象的指针,这两种转换之间的差别是巨大的,但是传统的 c 语言风格的类型转换没有区分这些。还有一个缺点就是,c 风格的转换不容易查找,他由一个括号加上一个标识符组成, 而这样的东西在 c++程序里一大堆。所以 c++为了克服这些缺点,引进了 4 新的类型转换操作符。

C风格强制类型转换(Type Cast)

TYPE b = (TYPE)a;

C++提供了4种类型转换，分别处理不同的场景应用

static_cast         静态类型转换。
reinterpret_cast    重新解释类型转换。
dynamic_cast        子类和父类之间的多态类型转换。
const_cast          去掉const属性转换。

1.static_cast静态类型转换

static_cast<目标类型>(标识符)

所谓的静态,即在编译期内即可决定其类型的转换,用的也是最多的一种。

#include <iostream>
using namespace std;

int main(void)
{
   double dPi = 3.1415926;
   int num1 = (int)dPi;//c语言的 旧式类型转换
   int num2 = dPi;     //隐式类型转换

  //静态的类型转换:
  //在编译的时进行基本类型的转换能替代c风格的类型转换可以进行一部分检查
   int num3 = static_cast<int>(dPi);//static_cast增加可读性，代表普通类型的强制转换
  //static_cast实际上是编译器在编译的时候就已经将PI解释成num类型了
   cout<<"num1:"<<num1<<"num2:"<<num2<<"num3:"<<num3<<endl;
//3  3  3
   return 0;
}

2.dynamic_cast 子类和父类之间的多态类型转换

dynamic_cast<目标类型>(标识符)

用于多态中的父子类之间的强制转化。

#include <iostream>
using namespace std;

//动物的抽象类
class Animal
{
public:
    virtual void cry() = 0;//纯虚函数

};


class Dog:public Animal
{
public:
    virtual void cry(){
        cout<<"汪汪"<<endl;
    }
    void doHome(){
        cout<<"看家"<<endl;
    }
};


class Cat:public Animal
{
public:
    virtual void cry(){
        cout<<"喵喵"<<endl;
    }
    void doHome(){
        cout<<"抓耗子"<<endl;
    }
};


int main(void)
{
    Animal *animal = NULL;//抽象指针

    animal = new Dog;

    animal->cry();

    Dog *dog = new Dog;

    //dog = animal;//报错！！！不能将父类对象赋值给子类指针

    dog = dynamic_cast<Dog*>(animal);//这样才可以

    if (dog != NULL)
    {
        cout<<"转换成功"<<endl;
        dog->cry();
        dog->doHome();
    }
    else
    {
        cout<<"转换失败"<<endl;
    }

    //dynamic_cast是将父类转换成子类，让老子变成儿子
    //让子类指针指向执行父类的对象

    Cat *cat = dynamic_cast<Cat*>(animal);
    //试图让一只狗变成一只猫
    if (cat != NULL)
    {
        cout<<"转换成功"<<endl;
        dog->cry();
        dog->doHome();
    }
    else
    {
        cout<<"转换失败"<<endl;//必然失败！
    }


   return 0;
}

3.const_cast 去掉const属性转换

const_cast<目标类型>(标识符)//目标类类型只能是指针或引用。

#include <iostream>
using namespace std;

void func(const char *p)//p所指向的区域不能修改
{
   char *pp = const_cast<char*>(p);//将p的const属性去掉
   pp[0] = 'A';
}

int main(void) 
{
   #if 0
   char *p = "12345677";//p指向的是常量区-------这个不可修改
   char buf[] = "12345676453";//在栈上开辟一个数组---------这个可修改

   func(p);   //必然崩  p指向的空间是常量区，必然不能修改！去了const也不能修改
   func(buf); //成功！！
   
   cout<<"buf:"<<buf<<endl;
   cout<<"p:"<<p<<endl;
   #endif
  
   const int a = 10;//a就是一个常量，是一个10的符号 key-value那个图

   const int *a_p = &a;//临时开辟了一个空间，把10放进去，用a_p指向这个空间

   int *a_p1 = const_cast<int*>(a_p);//把a_p的const属性去掉

   *a_p1 = 100;//能成功，但是a没改变！

    cout<<"a_p:"<<*a_p<<endl;//100
    cout<<"a:"<<a<<endl;     //10

   //const_cast的作用就是将 一个有只读属性的指针去掉，但是前提是当前的内存空间是可以修改

   return 0;
}

4.reinterpret_cast 重新解释类型转换

reinterpret_cast<目标类型> (标识符)

interpret 是解释的意思,reinterpret 即为重新解释,此标识符的意思即为数据的二进制形式重新解释,但是不改变其值。

#include <iostream>
using namespace std;

//动物的抽象类
class Animal
{
public:
    virtual void cry() = 0;//纯虚函数

};

class Dog:public Animal
{
public:
    virtual void cry(){
        cout<<"汪汪"<<endl;
    }
    void doHome(){
        cout<<"看家"<<endl;
    }
};

class Tree
{
public:
    void printT(){
        cout<<"我是大树"<<endl;
    }
    int age;
};

int main(void) 
{
   
   Animal *animal = new Dog;

   animal->cry();
   
   Tree *tree = reinterpret_cast<Tree*>(animal);//很不安全

   if (tree != NULL)
   {
     cout<<"转换成功"<<endl;
     tree->printT();
   }
   else
   {
     cout<<"转换失败"<<endl;
   }
   return 0;
}

程序员要清除的知道:要转的变量，类型转换前是什么类型，类型转换后是什么类型。转换后有什么后果。
一般情况下，不建议进行类型转换。