2.5 C++面向对象编程_类型转换

C/C++的类型转换分为显示类型转换和隐式类型转换。

隐式类型转换

隐式类型转换由编译器实现。使用隐式类型转换时，编译器不一定能知道我们转换的意图，所以使用隐式类型转换，经常有各种警告。

对于隐式类型转换，有以下代码。

double d = 100.1;
int i = d; // 隐式类型转换，double 转为 int

char *str = "100ask.taobao.com";
int *p = str; // 隐式类型转换， char * 转为 int *;

写代码测试一下。

此时编译，编译器会报警告，但是编译执行不会出错。

其中，第9行的警告是，将char *转换为int *，编译器不能保证后续使用p会不会有问题，所以抛出了一个警告。

第11行，当使用%d来输出的时候，编译器就期望得到一个unsigned int的参数，但是我们传入的str是char *，p是int *，不是编译器期望的类型。

此时会触发编译器的隐式类型转换，编译器会将str和p转换为unsigned int类型，之后编译器不能保证程序的执行与我们期望的一致，所以编译器就抛出了一个警告。

这些警告不会影响程序的执行，但是这样会显得很碍眼，是否有什么办法可以将这些警告消除？

显示类型转换

使用显示类型转换可以将这些警告消除。

问：什么是显示类型转换？

答：显示类型转换，也叫强制类型转换。就是在进行类型转换时，指定想要将数据转换成哪种类型。

如下图所示，就是使用了显示类型转换的代码，在进行类型转换时，指定了要转换成哪种数据类型。

此时编译代码，还是有警告，但是与之前的警告已经不同了。

可以看到，执行结果与之前隐式类型转换的执行结果相同。

看一下警告的信息，是因为我们使用的是64位机，64位机的指针是64位即8个字节，但是unsigned int的长度是32位即4个字节，所以将64位转换为32位输出时，高的32位数据将会被丢掉，数据将变得不完整，此时编译器会提示警告。

使用32位的编译器编译，则不会有报错。

C++的显示类型转换

上面介绍的是C语言的类型转换，这些转换规则同样适用于C++。

但是C++还有四个独有的类型转换符（函数）：

1. reinterpret_cast：高度危险的转换，这种转换仅仅是对二进制位的重新解释，不会借助已有的转换规则对数据进行调整，但是可以实现最灵活的 C++ 类型转换。

2. static_cast：用于良性转换，一般不会导致意外发生，风险很低。

3. dynamic_cast：用于类型安全的下行转换（Downcasting）。

4. const_cast：用于 const 与非 const、volatile 与非 volatile 之间的转换。

这四个类型转换的格式都是一样的：

 xxx_cast<newType>(data)

其中，newType 是要转换成的新类型，data 是被转换的数据。

reinterpret_cast

格式：reinterpret_cast<type-id>(experssion

相当于C风格的用小括号“（type-id）”实现的强制类型转换。

1、type-id 必须是一个指针、引用、算数类型、函数指针或者成员指针；

2、它可以把一个指针转换成一个整数，也可以把一个整数转换成一个指针；

3、跟C风格的强制转换类似，没有安全性检查。

可以用于无关类型之间的转换，转换过程中不会改变原有数据的二进制数值。

使用 reinterpret_cast 进行强制类型转换，将指针转换为unsigned int类型，代码如下。

编译测试，有发现报错和警告。

第8行的报错是，字符串常量是不可以改变值的，但是char *是可读可写的，所以编译器会抛出一个警告。将char *改为const，即可读但是不可写。

第12行的警告是，x86的指针是64位的，但是 unsigned int 是32位的，类型转换的过程中会丢失高32位的数据，如果使用32位的编译器则不会有这个警告。

修改代码，将str改为const char *类型，然后使用32位的编译器（arm-linux-gcc）编译。

此时编译还有警告和报错。

const_cast

格式：const_cast<type-id>(expression)

去掉原来类型的 const 或 volatile 属性。

为了解决第9行的错误，这里引入const_cast。

它用来去掉原来类型的 const 或 volatile 属性。换句话说，const_cast 就是用来将 const/volatile 类型转换为非 const/volatile 类型。

代码修改如下，将const char *先转换为char *类型，然后再通过 reinterpret_cast 转换成 int *。

编译测试，还有一个警告。

static_cast（简单介绍）

格式：static_cast<type-id>(expression)

将 expression 转换为 type-id 类型，但是运行时没有类型检查来保证转换的安全。

1、用于类层次结构中，基类和子类之间指针或引用的转换；

2、用于上行转换（子类转为基类）是安全的；

3、用于下行转换（基类转为子类），由于没有动态类型转换，所以是不安全的；

4、用于基本数据类型之间的转换，如把 int 转换成 char，把 int 转换成 enum；这种转换的安全性也要开发人员来保证；

5、把 void 指针转换成目标类型的指针（不安全！！！）

6、把任何类型的表达式转换成void类型；

注意：static_cast 不能换掉expression的const、volitale、或者__unaligned属性。

这里使用 static_cast，将 reinterpret_cast 改为 static_cast 后编译，没有报错。

但是需要注意，这种转换的安全性需要由开发人员来保证。

dynamic_cast 和 static_cast

格式：dynamic_cast<type-id>(expression)

将 expression 转换成type-id类型的对象。

type-id必须是类的指针、类的引用，或者void *；

如果type-id 是 类的指针/引用，那么expression也必须对应是 类的指针/引用；

1、用于多态场合，即：必须有虚函数；

2、主要用于类层次间的上行和下行转换，还可以用于类之间的交叉交换；

3、在类层次间进行上行转换（派生类转换成基类）时，dynamic_cast 和 static_cast 的效果是一样的；

在进行下行转换（基类转换成派生类）时，dynamic_cast 具有类型检查的功能，比 static_cast 更安全。

使用之前human.cpp的代码，介绍 dynamic_cast 和 static_cast。

初始代码如下。

#include <stdio.h>
#include <iostream>
#include <string.h>
#include <unistd.h>

#define RTE_TEST

using namespace std;

class Human {
public:
    virtual void eating(void)
    {
        cout << "using hands" << endl;
    }

    virtual ~Human()
    {
        cout << "~Human()" << endl;
    }

    virtual Human* test(void)
    {
        cout << "Human's test" << endl;
        return this;
    }
};

class Englishman : public Human {
public:
    void eating(void)
    {
        cout << "using knife" << endl;
    }

    virtual ~Englishman()
    {
        cout << "~Englishman()" << endl;
    }

    virtual Englishman* test(void)
    {
        cout << "Englishman's test" << endl;
        return this;
    }
};

class Chinese : public Human {
public:
    void eating(void)
    {
        cout << "using chopsticks" << endl;
    }

    virtual ~Chinese()
    {
        cout << "~Chinese()" << endl;
    }

    virtual Chinese* test(void)
    {
        cout << "Chinese's test" << endl;
        return this;
    }
};

void test_eating(Human& h)
{
    h.eating();
}

int main(int argc, char **argv)
{
    Human h;
    Englishman e;
    Chinese c;

    test_eating(h);
    test_eating(e);
    test_eating(c);

    return 0;
}

在这份代码里面，我们创建了一个基类Human，两个派生类Englishman类和Chinese类，然后使用虚函数实现了多态，在test_eating函数中，通过传入的参数类型，决定调用哪一个类的eating成员函数。

问：怎么在test_eating函数中，分辨传入的Human参数是Chinese还Englishman？

答：可以使用 dynamic_cast 动态类型转换，将传入的参数进行一次下行转换（将基类对象转换为派生类对象）。

修改test_eating函数。

编译测试，可以看到根据传入的参数类型不同，分别输出了不同的调试信息。

那么，这背后的机制是怎么样的呢？

在之前讲虚函数的时候讲过，如果一个类含有虚函数成员，那么它的对象就会包含一个指针指向一个虚函数表。

父类对象有一个指针指向虚函数表，子类对象也有一个指针指向虚函数表。

需要注意一点，虚函数表中不仅含有虚函数的信息，同时还有类的信息，那么就可以从类信息中知道这个对象是属于哪个类的了，并且还包含继承信息。

所以，动态类型转换 dynamic_cast 就是根据这个指向虚函数表的指针，找到这些类信息，从而知道这些对象是不是属于某一个类。

所以，动态类型转换只能用于含有虚函数的类里面。

修改代码，创建一个Chinese类的派生类，Guangximan 类。

在main函数中，创建一个 Guangximan 类的对象，在 test_eating 函数中添加Guangximan的判断。

 

 

显然，此时应该打印两条语句，Chinese和Guangximan。

测试结果如下：

 修改代码，使用dynamic_cast将对象转换为引用类型。

此时编译没有问题，然后执行，发现有core dump。

这是因为我们传入的是一个Guangximan类的对象，但是在test_eating函数里面，要把它转成一个Englishman类的对象引用，这时候就会发生错误。

 

如果把Englishman的转换屏蔽，则可以正常执行了。

 

 

如果使用的是一个指针，我们可以通过判空来查看指针是否有效，但是如果是一个引用， 如果这个引用没有一个实体，那么这个引用就是无效的了。

所以在动态类型转换中，通常使用的是指针，而不是引用。

测试函数中，我们往test_eating函数传入了一个派生类Guangximan的对象，然后会触发一次隐式类型转换，将Guangximan转换为Human，这是一次上行转换（派生类转为基类）。

然后在test_eating函数中，又有一次显示类型转换，将Human转为Chinese，Guangximan，这是一次下行转换（基类转为派生类）。这次的下行转换，如果从Human转换为Englishman就会失败，转为Chinese，Guangximan才会成功。也就是说，下行转换有可能成功，也有可能失败。

如果使用 reinterpret_cast，那么会怎么样？

修改代码，使用 reinterpret_cast 替换 dynamic_cast。

此时编译执行都没有报错，这样显然是有隐患的，Guangximan被强制转换成了Englishman，如果后续的代码中执行了一些Guangximan特有的操作，那么程序就会出问题。

而如果是 dynamic_cast，那么程序会报错。

也就是说，下行转换中，使用dynamic_cast会更安全。

与动态类型转换 dynamic_cast 相对的是静态类型转换 static_cast，它是在代码编译时就确定运行情况的。

修改代码。

此时编译，没有问题。但是很明显，这个逻辑上是有问题的，Human不一定是Englishman啊。

 也就是说，使用static_cast进行下行转换时，static_cast不能检查到异常。

再修改下代码，将Guangximan强转成Englishman试试。

此时编译有报错，编译器无法把Guangximan强转成Englishman。

也就是说，对于上行转换，static_cast 和 dynamic_cast 一样，可以检测出异常；但是下行转换时，static_cast 不一定可以检测到异常；