深入理解C++中五种强制类型转换的使用场景
Posted 彼 方
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了深入理解C++中五种强制类型转换的使用场景相关的知识，希望对你有一定的参考价值。
深入理解C++中五种强制类型转换的使用场景
1、C风格的强制类型转换
C风格的强制类型转换很容易理解，不管什么类型都可以直接进行转换，使用格式如下：
Type b = (Type)a;
当然，C++也是支持C风格的强制类型转换的，但是C风格的强制类型转换可能会带来一些隐患，出现一些难以察觉的问题，所以C++又推出了四种新的强制类型转换来替代C风格的强制类型转换，降低使用风险。
2、C++风格的强制类型转换
在C++中新增了四个关键字static_cast、const_cast、reinterpret_cast和dynamic_cast，用于支持C++风格的强制类型转换。这几个看起来有点像类模板，但事实上他们是正儿八经的关键字。C++风格的强制类型转换的好处是它们能更清晰的表明它们要干什么，程序员只要扫一眼这样的代码，就能立即知道一个强制转换的目的，并且在多态场景也只能使用C++风格的强制类型转换。
看本节之前建议看一下一下两篇文章，因为往下的内容会涉及一些关于多态的知识：
2.1、static_cast
static_cast是最常用的C++风格的强制类型转换，主要是为了执行那些较为合理的强制类型转换，使用格式如下：
static_cast<type_id>(expression);
因为static_cast的使用范围比较广，而且限制也比较多，所以下面分小节对各个场景进行分析
2.1.1、用于基本内置数据类型之间的转换
static_cast可以用于基本内置数据类型之间的转换，比如把char转成float、double转换成long等，这种内置类型之间的转换往往可以由隐式转换自动执行，而不需要人工特地去执行强制类型转换。由于转换结果可能存在截断性，这种转换的安全性要由开发人员来保证（一般不会出现严重程序运行错误，但是可能会出现逻辑错误），编译器可能会适当打印警告信息。示例如下：
#include <iostream>
int main(int argc, char* argv[])
{
char type_char = 'A';
float type_float = type_char; // 隐式转换也可以
float type_float_cast = static_cast<float>(type_char); // 显式地使用static_cast进行强制类型转换
double type_double = 1.23;
long type_long = type_double; // 隐式转换也可以
long type_long_cast = static_cast<long>(type_double); // 显式地使用static_cast进行强制类型转换
}
2.1.2、用于指针之间的转换
static_cast可以用于指针之间的转换，这种转换类型检查非常严格，不同类型的指针是直接不给转的，除非使用void*作为中间参数，我们知道隐式转换下void*类型是无法直接转换为其它类型指针的，这时候就需要借助static_cast来转换了。示例如下：
#include <iostream>
int main(int argc, char* argv[])
{
int type_int = 10;
float* float_ptr1 = &type_int; // int* -> float* 隐式转换无效
float* float_ptr2 = static_cast<float*>(&type_int); // int* -> float* 使用static_cast转换无效
char* char_ptr1 = &type_int; // int* -> char* 隐式转换无效
char* char_ptr2 = static_cast<char*>(&type_int); // int* -> char* 使用static_cast转换无效
void* void_ptr = &type_int; // 任何指针都可以隐式转换为void*
float* float_ptr3 = void_ptr; // void* -> float* 隐式转换无效
float* float_ptr4 = static_cast<float*>(void_ptr); // void* -> float* 使用static_cast转换成功
char* char_ptr3 = void_ptr; // void* -> char* 隐式转换无效
char* char_ptr4 = static_cast<char*>(void_ptr); // void* -> char* 使用static_cast转换成功
}
补充说明：
static_cast是直接不允许不同类型的引用进行转换的，因为没有void类型引用可以作为中间介质，这点和指针是有相当大区别的
2.1.3、不能转换掉expression的const或volitale属性
static_cast不能转换掉expression的const或volitale属性。示例如下：
#include <iostream>
int main(int argc, char* argv[])
{
int temp = 10;
const int* a_const_ptr = &temp;
int* b_const_ptr = static_cast<int*>(a_const_ptr); // const int* -> int* 无效
const int a_const_ref = 10;
int& b_const_ref = static_cast<int&>(a_const_ref); // const int& -> int& 无效
volatile int* a_vol_ptr = &temp;
int* b_vol_ptr = static_cast<int*>(a_vol_ptr); // volatile int* -> int* 无效
volatile int a_vol_ref = 10;
int& b_vol_ref = static_cast<int&>(a_vol_ref); // volatile int& -> int& 无效
}
2.1.4、用于类实例的之间转换
测试程序如下：
#include <iostream>
class A
{
public:
int a;
};
class B
{
public:
int b;
};
class C : public A, public B
{
public:
int c;
};
int main(int argc, char* argv[])
{
C c;
A a = static_cast<A>(c); // 上行转换正常
B b = static_cast<B>(c); // 上行转换正常
C c_a = static_cast<C>(a); // 下行转换无效
C c_b = static_cast<C>(b); // 下行转换无效
}
从测试程序中可以看到如果对类实例使用static_cast进行转换，static_cast是会进行类型判断的，对于上行转换来说这个过程就是正常的（其实任何合法的上行转换都可以直接由隐式转换来完成，而不需要手工去强制类型转换），但是下行转换则不行，static_cast认为下行转换等同于两个无关联的类进行转换，会报错。但是这个错误是有解决方法的，我们从报错信息中可以看到当static_cast转换失败时，会使用expression作为传入参数来调用type_id的构造函数，所以我们可以把类C改成以下形式，上面的示例即可编译通过
class C : public A, public B
{
public:
C()
{
}
C(const A& v)
{
a = v.a;
}
C(const B& v)
{
b = v.b;
}
int c;
};
综上，我们可以得出使用static_cast对类实例进行强制类型转换时有以下特点：
- 进行上行转换是完全安全合法的，当然这个过程由隐式转换来完成也是合法的
- 进行下行转换时，
static_cast会认为两个类无关联，这种转换不合法。如果此时硬要转换的话，比如类A->类B（这两个类可以无任何关系，因为实例下行转换static_cast就是认为他们没关联），可以在B中添加一个使用类A进行构造的构造函数，比如B(const A&)，这样就可以正常使用static_cast来进行类A->类B的操作了
2.1.5、用于没有多态的类实例指针或引用之间的转换
进行上行转换的示例如下：
#include <iostream>
class A
{
public:
int a;
};
class B
{
public:
int b;
};
class C : public A, public B
{
public:
int c;
};
int main(int argc, char* argv[])
{
C c;
A* a_ptr = static_cast<A*>(&c); // 上行指针转换正常
B* b_ptr = static_cast<B*>(&c); // 上行指针转换正常
A& a_ref = static_cast<A&>(c); // 上行引用转换正常
B& b_ref = static_cast<B&>(c); // 上行引用转换正常
}
可以看到上行转换都是正常的，转换过程中不会出现任何显性和隐性错误，下面来看一下下行转换的示例：
int main(int argc, char* argv[])
{
C c;
A* a_ptr = static_cast<A*>(&c);
B* b_ptr = static_cast<B*>(&c);
A& a_ref = static_cast<A&>(c);
B& b_ref = static_cast<B&>(c);
C* c_ptra = static_cast<C*>(a_ptr); // 下行指针转换正常
C* c_ptrb = static_cast<C*>(b_ptr); // 下行指针转换正常
C& c_refa = static_cast<C&>(a_ref); // 下行引用转换正常
C& c_refb = static_cast<C&>(b_ref); // 下行引用转换正常
A* a_ptr_fail = static_cast<A*>(b_ptr); // B* -> A*，无关联的两个类型，无效
}
从上面的例子可以看到，下行转换也是正常的，并且static_cast也会拒绝掉两个无关联类之间的转换？？？这和书中说的不一样啊，不是说static_cast下行转换不安全吗？别急，上面的例子是片面的，各位看一下下面的代码就知道了
int main(int argc, char* argv[])
{
A a;
B b;
// 以下都能转换成功，说明static_cast根本就没有安全检查，只看到有继承关系就给转换了
C* c_ptra = static_cast<C*>(&a);
C* c_ptrb = static_cast<C*>(&b);
C& c_refa = static_cast<C&>(a);
C& c_refb = static_cast<C&>(b);
}
综上，我们可以得出使用static_cast对没有多态的类实例指针或引用进行强制类型转换时有以下特点：
- 进行上行转换（派生类指针->基类指针、派生类引用->基类引用）是完全安全的，没有任何问题，当然这个过程由隐式转换来完成也是合法的
- 进行下行转换（基类指针->派生类指针、基类引用->派生类引用）由于缺乏安全检查，所以是有问题的，要尽量避免这种用法
- 如果两个类无继承关系，则使用
static_cast进行转换时会失败，但是这种情况下static_cast会显性地展示出错误信息，是安全的
2.1.6、用于具有多态的类实例指针或引用之间的转换
进行上行转换的示例如下：
#include <iostream>
class A
{
public:
virtual void print()
{
std::cout << "A" << std::endl;
}
};
class B
{
public:
virtual void print()
{
std::cout << "B" << std::endl;
}
};
class C : public A, public B
{
public:
virtual void print() override
{
std::cout << "C" << std::endl;
}
};
int main(int argc, char* argv[])
{
C c;
A* a_ptr = static_cast<A*>(&c); // 上行指针转换正常
B* b_ptr = static_cast<B*>(&c); // 上行指针转换正常
a_ptr->print(); // 输出C，符合多态的要求
b_ptr->print(); // 输出C，符合多态的要求
A& a_ref = static_cast<A&>(c); // 上行引用转换正常
B& b_ref = static_cast<B&>(c); // 上行引用转换正常
a_ref.print(); // 输出C，符合多态的要求
b_ref.print(); // 输出C，符合多态的要求
}
可以看到上行转换都是正常的，转换过程中不会出现任何显性和隐性错误，下面来看一下正常的下行转换的示例：
int main(int argc, char* argv[])
{
C c;
A* a_ptr = static_cast<A*>(&c);
B* b_ptr = static_cast<B*>(&c);
A& a_ref = static_cast<A&>(c);
B& b_ref = static_cast<B&>(c);
C* c_ptra = static_cast<C*>(a_ptr); // 下行指针转换正常
C* c_ptrb = static_cast<C*>(b_ptr); // 下行指针转换正常
c_ptra->print(); // 输出C，符合多态的要求
c_ptrb->print(); // 输出C，符合多态的要求
C& c_refa = static_cast<C&>(a_ref); // 下行引用转换正常
C& c_refb = static_cast<C&>(b_ref); // 下行引用转换正常
c_refa.print(); // 输出C，符合多态的要求
c_refb.print(); // 输出C，符合多态的要求
}
可以看到这个也是正常的，和前面那个没有多态的差不多，接下来看一下不正常的下行转换例子：
int main(int argc, char* argv[])
{
A a;
B b;
C* c_ptra = static_cast<C*>(&a);
C* c_ptrb = static_cast<C*>(&b);
c_ptra->print(); // 正常输出A
c_ptrb->print(); // 段错误
C& c_refa = static_cast<C&>(a);
C& c_refb = static_cast<C&>(b);
c_refa.print(); // 正常输出A
c_refb.print(); // 段错误
}
上面这个例子中的下行转换是错误的，但是通过c_ptra可以正常调用类A的print()方法打印出字母A来，使用c_ptrb就直接段错误了，原因是类A是第一个被继承的，类B是第二个被继承的，也就是在类C中，第一个虚表指针指向的就是类A的虚表，第二个虚表指针指向的就是类B的虚表。在上面的例子那样进行错误地转换时，由于类A被继承之后它位置的特殊性导致可以使用c_ptra正确地调用类A的print()方法，而类B则不行，可能这有点难理解，下面给大家看张图就明白了，如图2-1所示：
从图2-1中可以看出，对于类C来说，它始终调用着_vptr.A指向的print()方法，当我们使用纯类B类型进行下行转换时，根本就没有这一块的数据（这个转换是不完整的、不安全的），所以就会出现段错误了。当然，使用纯类A类型进行下行转换也是不完整、不安全的，只不过位置刚好才不会出现段错误而已。综合分析上面的代码是完全错误的，一定要杜绝写出这种垃圾代码。
综上，我们可以得出使用static_cast对具有多态的类实例指针或引用进行强制类型转换时有以下特点：
- 进行上行转换（派生类指针->基类指针、派生类引用->基类引用）是完全安全的，没有任何问题，当然这个过程由隐式转换来完成也是合法的
- 进行下行转换（基类指针->派生类指针、基类引用->派生类引用）由于缺乏安全检查，所以是有问题的，并且因为具有多态的类往往具有特殊的用法，所以在这种情况下产生的后果比前面没有多态情况下的要更严重，要尽量避免这种用法
小结：通过上面的介绍，我们可以很直观地看到static_cast相比C风格的强制类型转换要安全很多，有很大程度上的类型安全检查。本节我们所有的例子都可以使用C风格的强制类型转换去做，但是转出来的结果有可能会错到天际去，并且编译器不会给你任何报错信息。。。同时我们也要认识到static_cast也是有明显缺点的，那就是无法消除const和volatile属性、无法直接对两个不同类型的指针或引用进行转换和下行转换无类型安全检查等，不过没关系，其它三个强制类型转换的关键字刚好能弥补static_cast的这些缺点。
2.2、const_cast
const_cast的作用是去除掉const或volitale属性，前面介绍static_cast的时候我们知道static_cast是不具备这种功能的。使用格式如下：
const_cast<type_id>(expression);
注意事项：const_cast不是用于去除变量的常量性，而是去除指向常量对象的指针或引用的常量性，其去除常量性的对象必须为指针或引用，并且const_cast不支持不同类型指针或引用之间的转换，比如说float*转换成int*是不允许的，直白一点说就是type_id和expression要基本类型保持一致，相差的话只能差const或volatile属性。
先来看一个错误的使用示例：
#include <iostream>
int main(int argc, char* argv[])
{
int type_int = 100;
float type_float = const_cast<float>(type_int); // 错误，const_cast只能转换引用或者指针
float* type_float_ptr = const_cast<float*>(&type_int); // 错误，从int* -> float* 无效
float& type_float_ref = const_cast<float&>(type_int); // 错误，从int& -> float& 无效
}
再来看一个不太正确的使用示例：
#include <iostream>
int main(int argc, char* argv[])
{
const int type_const_int = 100;
int* type_const_int_ptr = const_cast<int*>(&type_const_int); // 转换正确
int& type_const_int_ref = const_cast<int&>(type_const_int); // 转换正确
*type_const_int_ptr = 10;
std::cout << *type_const_int_ptr << std::endl; // 输出10
std::cout << type_const_int << std::endl; // 输出100，没有改变
type_const_int_ref = 20;
std::cout << type_const_int_ref << std::endl; // 输出20
std::cout << type_const_int << std::endl; // 输出100，没有改变
// 以下三个输出结果一致，说明const_cast确实只是去除了一些属性，并没有重新搞快内存把需要转换的变量给复制过去
std::cout << "&type_const_int:\\t" << &type_const_int << std::endl;
std::cout << "type_const_int_ptr:\\t" << type_const_int_ptr << std::endl;
std::cout << "&type_const_int_ref:\\t" << &type_const_int_ref << std::endl;
}
在上面这个例子中，转换是成功了，但是type_const_int的常量性并没有被改变，这是因为const_cast并没有办法把变量的常量性去除，而且比较有意思的是我们可以看到type_const_int对应地址的内容确实被改变了，但是type_const_int的值却并没有被改变，这是好事，因为从一开始我们把它定义为常量类型时这个值就不应该再被改变了。至于后面使用type_const_int_ptr和type_const_int_ref试图去改变type_const_int的值，这是很危险的做法，不同编译器可能会有不同的处理，是有可能出现严重错误的，要杜绝这种用法。
从这里看起来const_cast好像有点鸡肋。。。但是事实上不是这样的，在某些场景下const_cast还是挺好用的，比如下面这个例子：
#include <iostream>
void fun(const int& v)
{
int& type_int_ref = const_cast<int&>(v);
type_int_ref = 10;
}
int main(int argc, char* argv[])
{
int type_int = 100;
fun(type_int以上是关于深入理解C++中五种强制类型转换的使用场景的主要内容，如果未能解决你的问题，请参考以下文章