强制类型转换是有一定风险的,有的转换并不一定安全,如把整型数值转换成指针,把基类指针转换成派生类指针,把一种函数指针转换成另一种函数指针,把常量指针转换成非常量指针等。
C语言强制类型转换缺点:
主要是为了克服C语言强制类型转换的以下三个缺点。
例如,将int 强制转换成 double 是没有风险的,而将常量指针转换成非常量指针,将基类指针转换成派生类指针都是高风险的,而且后两者带来的风险不同(即可能引发不同种类的错误),C语言的强制类型转换形式对这些不同并不加以区分
C++ 引入了四种功能不同的强制类型转换运算符以进行强制类型转换
语法:
static_cast<目标类型>(表达式);
const_cast<目标类型>(表达式);
reinterpret_cast<目标类型>(表达式);
dynamic_cast<目标类型>(表达式);
C风格的类型转换很容易理解:
语法:(目标类型)表达式或目标类型(表达式);
C++认为C风格的类型转换过于松散,可能会带来隐患,不够安全。
C++推出了新的类型转换来替代C风格的类型转换,采用更严格的语法检查,降低使用风险。
C++新增了四个关键字static_cast、const_cast、reinterpret_cast和dynamic_cast,用于支持C++风格的类型转换。
C++的类型转换只是语法上的解释,本质上与C风格的类型转换没什么不同,C语言做不到事情的C++也做不到。
除了语法不同,C和C++没有区别。
#include
using namespace std;
int main(int argc, char* argv[])
{
int ii = 3;
long ll = ii; // 绝对安全,可以隐式转换,不会出现警告。
double dd = 1.23;
long ll1 = dd; // 可以隐式转换,但是,会出现可能丢失数据的警告。
long ll2 = (long)dd; // C风格:显式转换,不会出现警告。
long ll3 = static_cast<long>(dd); // C++风格:显式转换,不会出现警告。
cout << "ll1=" << ll1 << ",ll2=" << ll2 << ",ll3=" << ll3 << endl;
}
C风格可以把不同类型的指针进行转换。
C++不可以,需要借助void *。
#include
using namespace std;
void func(void* ptr) { // 其它类型指针 -> void *指针 -> 其它类型指针
double* pp = static_cast<double*>(ptr);
}
int main(int argc, char* argv[])
{
int ii = 10;
//double* pd1 = ⅈ // 错误,不能隐式转换。
double* pd2 = (double*) ⅈ // C风格,强制转换。
//double* pd3 = static_cast(&ii); // 错误,static_cast不支持不同类型指针的转换。
void* pv = ⅈ // 任何类型的指针都可以隐式转换成void*。
double* pd4 = static_cast<double*>(pv); // static_cast可以把void *转换成其它类型的指针。
func(&ii);
}
static_cast不能丢掉指针(引用)的const和volitale属性,const_cast可以。
示例:
#include
using namespace std;
void func(int *ii)
{}
int main(int argc, char* argv[])
{
const int *aa=nullptr;
int *bb = (int *)aa; // C风格,强制转换,丢掉const限定符。
int* cc = const_cast<int*>(aa); // C++风格,强制转换,丢掉const限定符。
func(const_cast<int *>(aa));
}
static_cast不能用于转换不同类型的指针(引用)(不考虑有继承关系的情况),reinterpret_cast可以。
reinterpret_cast的意思是重新解释,能够将一种对象类型转换为另一种,不管它们是否有关系。
语法:reinterpret_cast<目标类型>(表达式);
<目标类型>和(表达式)中必须有一个是指针(引用)类型。
reinterpret_cast不能丢掉(表达式)的const或volitale属性。
应用场景:
1)reinterpret_cast的第一种用途是改变指针(引用)的类型。
2)reinterpret_cast的第二种用途是将指针(引用)转换成整型变量。整型与指针占用的字节数必须一致,否则会出现警告,转换可能损失精度。
3)reinterpret_cast的第三种用途是将一个整型变量转换成指针(引用)。
示例:
#include
using namespace std;
void func(void* ptr) {
long long ii = reinterpret_cast<long long>(ptr);
cout << "ii=" << ii << endl;
}
int main(int argc, char* argv[])
{
long long ii = 10;
func(reinterpret_cast<void *>(ii));
}
动态转换(dynamic_cast)用于基类和派生类之间的转换,但只能在运行时确定类型信息,因此只能用于多态类型。如果转换失败,将返回一个null指针。其语法如下:
dynamic_cast<目标类型> (原始类型)
以下是几个具体例子:
1、将一个基类指针强制转换为一个派生类指针:
class Base { virtual void f(){} };
class Derived : public Base { void f(){} };
Base *b = new Derived(); // 基类指针指向派生类对象
Derived *p = dynamic_cast<Derived *>(b); // 将基类指针转换为派生类指针
2、使用 dynamic_cast 对指针进行类型判断:
class Base {};
class Derived : public Base {};
Base* b1 = new Derived();
Derived* d1 = dynamic_cast<Derived*>(b1);
if (d1 != nullptr) {
// b1 是 Derived 类型的。
}
需要注意的是,如果指向的基类指针并不真正指向派生类,或者目标类型与原始类型之间的类型转换无法完成,dynamic_cast会返回null指针或抛出std::bad_cast异常。因此,在使用dynamic_cast时需要非常小心,确保程序的健壮性和安全性。