类型转换

在C++语言中，某些类型之间有关联。如果两种类型有关联，那么当程序需要其中一种类型的运算对象时，可以用另一种关联类型的对象或值来替代。

一、何时发生隐式类型转换

在下面这些情况下，编译器会自动地转换运算对象的类型：

• 在大多数表达式中，比int类型小的整型值首先提升为较大的整数类型。
• 在条件中，非布尔值转换成布尔类型。
• 初始化过程中，初始值转换成变量的类型；在赋值语句中，右侧运算对象转换成左侧运算对象的类型。
• 如果算术运算或关系运算的运算对象有多种类型，需要转换成同一种类型。

二、转换类型有哪些

算术转换

算术转换（arithmetic conversion）的含义是把一种算术类型转换成另外一种算术类型。算术转换的规则定义了一套类型转换的层次，其中运算符的运算对象将转换成最宽的类型。例如，如果一个运算对象的类型是long double，那么不论另外一个运算对象的类型是什么都会转换成long double。还有一种更普遍的情况，当表达式中既有浮点类型也有整数类型时，整数值将转换成相应的浮点类型。

• 整形提升
  整型提升（integral promotion）负责把小整数类型转换成较大的整数类型。对于bool、char、signed char、unsigned char、short和unsigned short等类型来说，只要它们所有可能的值都能存在int里，它们就会提升成int类型；否则，提升成unsigned int类型。就如我们所熟知的，布尔值false提升成0、true提升成1。较大的char类型（wchar_t、char16_t、char32_t）提升成int、unsigned int、long、unsigned long、long long和unsigned long long中最小的一种类型，前提是转换后的类型要能容纳原类型所有可能的值。

• 无符号类型的运算对象

  1. 如果某个运算符的运算对象类型不一致，这些运算对象将转换成同一种类型。但是如果某个运算对象的类型是无符号类型，那么转换的结果就要依赖于机器中各个整数类型的相对大小了。
     像往常一样，首先执行整型提升。如果结果的类型匹配，无须进行进一步的转换。如果两个（提升后的）运算对象的类型要么都是带符号的、要么都是无符号的，则小类型的运算对象转换成较大的类型。
  2. 如果一个运算对象是无符号类型、另外一个运算对象是带符号类型，而且其中的无符号类型不小于带符号类型，那么带符号的运算对象转换成无符号的。例如，假设两个类型分别是unsigned int和int，则int类型的运算对象转换成unsigned int类型。需要注意的是，如果int型的值恰好为负值，并且超出它表示的范围的值时，其结果是未定义的，程序可能继续工作，可能崩溃，也可能产生垃圾数据。
  3. 如果是带符号类型大于无符号类型，此时转换的结果依赖于机器。如果无符号类型的所有值都能存在该带符号类型中，则无符号类型的运算对象转换成带符号类型。如果不能，那么带符号类型的运算对象转换成无符号类型。例如，如果两个运算对象的类型分别是long和unsigned int，并且int和long的大小相同，则long类型的运算对象转换成unsigned int类型；如果long类型占用的空间比int更多，则unsigned int类型的运算对象转换成long类型。

数组转化成指针

数组转换成指针：在大多数用到数组的表达式中，数组自动转换成指向数组首元素的指针：

int ia[10];             // 含有10个整数的数组  
int* ip = ia;       // ia转换成指向数组首元素的指针

当数组被用作decltype关键字的参数，或者作为取地址符（&）、sizeof及typeid等运算符的运算对象时，上述转换不会发生。同样的，如果用一个引用来初始化数组，上述转换也不会发生。

指针的转换

C++还规定了几种其他的指针转换方式，包括常量整数值0或者字面值nullptr能转换成任意指针类型；指向任意非常量的指针能转换成void*；指向任意对象的指针能转换成const void*

转换成布尔类型

存在一种从算术类型或指针类型向布尔类型自动转换的机制。如果指针或算术类型的值为0，转换结果是false；否则转换结果是true：

char *cp = get_string();  
if (cp) /* . . . */         // 如果指针cp不是0，条件为真  
while (*cp) /* . . . */     // 如果*cp不是空字符，条件为真

相反的转换并不存在，因为它试图删除掉底层const。

类类型定义的转换：类类型能定义由编译器自动执行的转换，不过编译器每次只能执行一种类类型的转换。如果同时提出多个转换请求，这些请求将被拒绝。

三、显示转换

有时我们希望显式地将对象强制转换成另外一种类型。例如，如果想在下面的代码中执行浮点数除法：

int i, j;  
double slope = i/j;  

就要使用某种方法将i和/或j显式地转换成double，这种方法称作强制类型转换（cast）。

虽然有时不得不使用强制类型转换，但这种方法本质上是非常危险的。

命名的强制类型转换

一个命名的强制类型转换具有如下形式：

cast-name<type>(expression);

其中，type是转换的目标类型而expression是要转换的值。如果type是引用类型，则结果是左值。cast-name是static_cast、dynamic_cast、const_cast和reinterpret_cast中的一种。

1. static_cast

任何具有明确定义的类型转换，只要不包含底层const，都可以使用static_cast。例如，通过将一个运算对象强制转换成double类型就能使表达式执行浮点数除法：

// 进行强制类型转换以便执行浮点数除法  
double slope = static_cast<double>(j) / i;

当需要把一个较大的算术类型赋值给较小的类型时，static_cast非常有用。此时，强制类型转换告诉程序的读者和编译器：我们知道并且不在乎潜在的精度损失。一般来说，如果编译器发现一个较大的算术类型试图赋值给较小的类型，就会给出警告信息；但是当我们执行了显式的类型转换后，警告信息就会被关闭了。

static_cast对于编译器无法自动执行的类型转换也非常有用。例如，我们可以使用static_cast找回存在于void*指针中的值：

void* p = &d;   // 正确：任何非常量对象的地址都能存入void*  
//正确：将void*转换回初始的指针类型  
double *dp = static_cast<double*>(p);

当我们把指针存放在void*中，并且使用static_cast将其强制转换回原来的类型时，应该确保指针的值保持不变。也就是说，强制转换的结果将与原始的地址值相等，因此我们必须确保转换后所得的类型就是指针所指的类型。类型一旦不符，将产生未定义的后果。

2. const_cast

const_cast只能改变运算对象的底层const。

const char *pc;  
char *p = const_cast<char*>(pc); // 正确：但是通过p写值是未定义的行为 

对于将常量对象转换成非常量对象的行为，我们一般称其为”去掉const性质（cast away the const）”。一旦我们去掉了某个对象的const性质，编译器就不再阻止我们对该对象进行写操作了。如果对象本身不是一个常量，使用强制类型转换获得写权限是合法的行为。然而如果对象是一个常量，再使用const_cast执行写操作就会产生未定义的后果。

只有const_cast能改变表达式的常量属性，使用其他形式的命名强制类型转换改变表达式的常量属性都将引发编译器错误。同样的，也不能用const_cast改变表达式的类型：

const char *cp;  
// 错误：static_cast不能转换掉const性质  
char *q = static_cast<char*>(cp);  
static_cast<string>(cp);    // 正确：字符串字面值转换成string类型  
const_cast<string>(cp);         // 错误：const_cast只改变常量属性

const_cast常常用于有函数重载的上下文中。

3. reinterpret_cast

reinterpret_cast通常为运算对象的位模式提供较低层次上的重新解释。举个例子，假设有如下的转换

int *ip;  
char *pc = reinterpret_cast<char*>(ip); 

我们必须牢记pc所指的真实对象是一个int而非字符，如果把pc当成普通的字符指针使用就可能在运行时发生错误。例如：

string str(pc);

可能导致异常的运行时行为。

使用reinterpret_cast是非常危险的，用pc初始化str的例子很好地证明了这一点。其中的关键问题是类型改变了，但编译器没有给出任何警告或者错误的提示信息。当我们用一个int的地址初始化pc时，由于显式地声称这种转换合法，所以编译器不会发出任何警告或错误信息。接下来再使用pc时就会认定它的值是char*类型，编译器没法知道它实际存放的是指向int的指针。最终的结果就是，在上面的例子中虽然用pc初始化str没什么实际意义，甚至还可能引发更糟糕的后果，但仅从语法上而言这种操作无可指摘。查找这类问题的原因非常困难，如果将ip强制转换成pc的语句和用pc初始化string对象的语句分属不同文件就更是如此。

reinterpret_cast本质上依赖于机器。要想安全地使用reinterpret_cast必须对涉及的类型和编译器实现转换的过程都非常了解。

4. dynamic_cast

dynamic_cast运算符的使用形式如下所示：

dynamic_cast<type*>(e)
dynamic_cast<type&>(e)
dynamic_cast<type&&>(e)

其中，type必须是一个类类型，并且通常情况下该类型应该含有虚函数。在第一种形式中，e必须是一个有效的指针；在第二种形式中，e必须是一个左值；在第三种形式中，e不能是左值。

在上面的所有形式中，e的类型必须符合以下三个条件中的任意一个：e的类型是目标type的公有派生类、e的类型是目标type的公有基类或者e的类型就是目标type的类型。如果符合，则类型可以转换成功。否则，转换失败。如果一条dynamic_cast语句的转换目标是指针类型并且失败了，则结果为0。如果转换目标是引用类型并且失败了，则dynamic_cast运算符将抛出一个bad_cast异常。

指针类型的dynamic_cast

举个简单的例子，假定Base类至少含有一个虚函数、Derived是Base的公有派生类。如果有一个指向Base的指针bp，则我们可以在运行时将它转换成指向Derived的指针，具体代码如下：

if (Derived *dp = dynamic_cast<Derived*>(bp)
{
    //使用dp指向的Dervied对象
}
else
{
    //bp指向一个Base对象
    //使用bp指向的Base对象
}

如果bp指向Derived对象，则上述的类型转换初始化dp并令其指向bp所指的Derived对象。此时，if 语句内部使用Derived操作的代码是安全的。否则，类型转换的结果为0，dp为0 意味着if 语句的条件失败，此时else子句执行相应的Base操作。
在条件部分执行dynamic_cast操作可以确保类型转换和结果检查在同一条表达式中完成。可以对一个空指针执行dynamic_cast，结果是所需类型的空指针。

引用类型的dynamic_cast

引用类型的dynamic_cast与指针类型的dynamic_cast在表示错误发生的方式上略有不同。因为不存在所谓的空引用，所以对于引用类型来说无法使用与指针类型完全相同的错误报告策略。当对引用的类型转换失败时，程序抛出一个名为std::bad_cast的异常，在异常定义在typeinfo标准库头文件中。

可以按照如下的形式改写之前的程序，令其使用引用类型：

void f(const Base &b)
{
    try
    {
        const Derived &d = dynamic_cast<const_Derived&>(b)
        //使用b引用的Derived对象
    }
    catch(bad_cast)
    {
        //处理类型转换失败的情况
    }
}

建议：避免强制类型转换

强制类型转换干扰了正常的类型检查，因此我们强烈建议程序员避免使用强制类型转换。这个建议对于reinterpret_cast尤其适用，因为此类类型转换总是充满了风险。在有重载函数的上下文中使用const_cast无可厚非,但是在其他情况下使用const_cast也就意味着程序存在某种设计缺陷。其他强制类型转换，比如static_cast和dynamic_cast，都不应该频繁使用。每次书写了一条强制类型转换语句，都应该反复斟酌能否以其他方式实现相同的目标。就算实在无法避免，也应该尽量限制类型转换值的作用域，并且记录对相关类型的所有假定，这样可以减少错误发生的机会。