C++强制类型转换

在 C++语言中新增了四个关键字 static_cast、const_cast、reinterpret_cast 和 dynamic_cast。这四个关键字都是用于强制类型转换的。我们逐一来介绍这四个关键字。

1) static_cast

在 C++语言中，static_cast 用于数据类型的强制转换，强制将一种数据类型转换为另一种数据类型。例如将整型数据转换为浮点型数据。

【例 1】C语言所采用的类型转换方式：

int a = 10;
int b = 3;
double result = (double)a / (double)b;

例 1 中将整型变量 a 和 b 转换为双精度浮点型，然后相除。在 C++语言中，我们可以采用 static_cast 关键字来进行强制类型转换，如下所示。

【例 2】static_cast关键字的使用：

int a = 10;
int b = 3;
double result = static_cast<double>(a) / static_cast<double>(b);

在本例中同样是将整型变量 a 转换为双精度浮点型。采用 static_cast 进行强制数据类型转换时，将想要转换成的数据类型放到尖括号中，将待转换的变量或表达式放在元括号中，其格式可以概括为如下形式：

static_cast<类型说明符>(变量或表达式)

2) const_cast

在 C语言中，const 限定符通常被用来限定变量，用于表示该变量的值不能被修改。而 const_cast 则正是用于强制去掉这种不能被修改的常数特性，但需要特别注意的是，const_cast 不是用于去除变量的常量性，而是去除指向常数对象的指针或引用的常量性，其去除常量性的对象必须为指针或引用。

【例 3】一个错误的例子：

const int a = 10;
const int * p = &a;
*p = 20;                  //compile error
int b = const_cast<int>(a);  //compile error

在本例中出现了两个编译错误，第一个编译错误是 *p 因为具有常量性，其值是不能被修改的；另一处错误是 const_cast 强制转换对象必须为指针或引用，而例 3 中为一个变量，这是不允许的！

【例 4】const_cast 关键字的使用

#include<iostream>
using namespace std;

int main()
{
    const int a = 10;
    const int * p = &a;
    int *q;
    q = const_cast<int *>(p);
    *q = 20;    //fine
    cout <<a<<" "<<*p<<" "<<*q<<endl;
    cout <<&a<<" "<<p<<" "<<q<<endl;
    return 0;
}

在本例中，我们将变量 a 声明为常量变量，同时声明了一个 const 指针指向该变量（此时如果声明一个普通指针指向该常量变量的话是不允许的，Visual Studio 2010编译器会报错），之后我们定义了一个普通的指针 *q。将 p 指针通过 const_cast 去掉其常量性，并赋给 q 指针。之后我再修改 q 指针所指地址的值时，这是不会有问题的。

最后将结果打印出来，运行结果如下：

10 20 20
002CFAF4 002CFAF4 002CFAF4

查看运行结果，问题来了，指针 p 和指针 q 都是指向 a 变量的，指向地址相同，而且经过调试发现 002CFAF4 地址内的值确实由 10 被修改成了 20，这是怎么一回事呢？为什么 a 的值打印出来还是 10 呢？

其实这是一件好事，我们要庆幸 a 变量最终的值没有变成 20！变量 a 一开始就被声明为一个常量变量，不管后面的程序怎么处理，它就是一个常量，就是不会变化的。试想一下如果这个变量 a 最终变成了 20 会有什么后果呢？对于这些简短的程序而言，如果最后 a 变成了 20，我们会一眼看出是 q 指针修改了，但是一旦一个项目工程非常庞大的时候，在程序某个地方出现了一个 q 这样的指针，它可以修改常量 a，这是一件很可怕的事情的，可以说是一个程序的漏洞，毕竟将变量 a 声明为常量就是不希望修改它，如果后面能修改，这就太恐怖了。

在例 4 中，我们称*q=20;语句为未定义行为语句，所谓的未定义行为是指在标准的 C++ 规范中并没有明确规定这种语句的具体行为，该语句的具体行为由编译器来自行决定如何处理。对于这种未定义行为的语句我们应该尽量予以避免！

从例 4 中我们可以看出，我们是不想修改变量 a 的值的，既然如此，定义一个 const_cast 关键字强制去掉指针的常量性到底有什么用呢？我们接着来看下面的例子。

【例 5】

#include<iostream>
using namespace std;

const int * Search(const int * a, int n, int val);

int main()
{
    int a[10] = {0,1,2,3,4,5,6,7,8,9};
    int val = 5;
    int *p;
    p = const_cast<int *>(Search(a, 10, val));
    if(p == NULL)
        cout<<"Not found the val in array a"<<endl;
    else
        cout<<"hvae found the val in array a and the val = "<<*p<<endl;
    return 0;
}

const int * Search(const int * a, int n, int val)
{
    int i;
    for(i=0; i<n; i++)
    {
        if(a[i] == val)
            return &a[i];
    }
    return  NULL;
}

Search() 函数用于在 a 数组中寻找 val 值，如果找到了就返回该值的地址，如果没有找到则返回 NULL。Search() 函数的返回值是 const 指针，当我们在 a 数组中找到了 val 值的时候，我们会返回 val 的地址，最关键的是 a 数组在 main() 函数中并不是 const，因此即使我们去掉返回值的常量性有可能会造成 a 数组被修改，但是这也依然是安全的。

对于引用，我们同样能使用 const_cast 来强制去掉常量性，如例 6 所示。

【例 6】

#include<iostream>
using namespace std;

const int & Search(const int * a, int n, int val);

int main()
{
    int a[10] = {0,1,2,3,4,5,6,7,8,9};
    int val = 5;
    int &p = const_cast<int &>(Search(a, 10, val));
    if(p == NULL)
        cout<<"Not found the val in array a"<<endl;
    else
        cout<<"hvae found the val in array a and the val = "<<p<<endl;
    return 0;
}

const int & Search(const int * a, int n, int val)
{
    int i;
    for(i=0; i<n; i++)
    {
        if(a[i] == val)
            return a[i];
    }
    return  NULL;
}

了解了 const_cast 的使用场景后，可以知道使用 const_cast 通常是一种无奈之举，同时也建议大家在今后的 C++ 程序设计过程中一定不要利用 const_cast 去掉指针或引用的常量性并且去修改原始变量的数值，这是一种非常不好的行为。

3) reinterpret_cast

在 C++语言中，reinterpret_cast 主要有三种强制转换用途：改变指针或引用的类型、将指针或引用转换为一个足够长度的整形、将整型转换为指针或引用类型。在使用 reinterpret_cast 强制转换过程仅仅只是比特位的拷贝，因此在使用过程中需要特别谨慎！

【例 7】

int *a = new int;
double *d = reinterpret_cast<double *>(a);

在例 7 中，将整型指针通过 reinterpret_cast 强制转换成了双精度浮点型指针。

reinterpret_cast 可以将指针或引用转换为一个足够长度的整形，此中的足够长度具体长度需要多少则取决于操作系统，如果是 32 位的操作系统，就需要 4 个字节及以上的整型，如果是 64 位的操作系统，则需要 8 个字节及以上的整型。   

4) dynamic_cast

dynamic_cast 用于类的继承层次之间的强制类型转换，我们将在讲到类的继承的时候再来介绍 dynamic_cast。