类型转换运算符

类型转换运算符是一种特殊的成员函数，用于自定义类对象之间的显式类型转换。通过定义类型转换运算符，可以使得类对象能够像基本数据类型一样进行类型转换操作。

类型转换运算符具有以下特点：

• 定义为类的成员函数，没有返回类型，但是在函数前面加上要转换的目标类型。
• 可以将一个类对象转换为其他类型的对象。
• 可以通过重载多个类型转换运算符，以支持不同的目标类型转换。

四种类型转换运算符

1. static_cast

static_cast 是一种静态类型转换，在编译时期完成。
它主要用于进行一些明显的类型转换，比如数值类型之间的转换、向上转型（从派生类到基类的转换）以及基类指针向派生类指针的转换。

static_cast的语法如下：

static_cast<目标类型>(表达式)

使用场景：

1. 基本数据类型之间的转换：

可以在合理范围内进行基本数据类型之间的转换，例如将整数转换为浮点数，或者将较窄的数据类型转换为较宽的数据类型。

int i = 10;
double d = static_cast<double>(i);  // 将整数转换为浮点数

2. 父子类指针或引用之间的转换：

可以将一个指向基类对象的指针或引用转换为指向派生类对象的指针或引用，但需要确保转换是安全的。
这样做可以在某些情况下访问派生类特有的成员函数或成员变量。

class Base { ... };
class Derived : public Base { ... };


//基类指针basePtr指向派生类对象，因此你可以使用basePtr来访问派生类对象中从基类继承的成员函数和成员变量。

Base* basePtr = new Derived();
Derived* derivedPtr = static_cast<Derived*>(basePtr); 
// 将基类指针转换为派生类指针

3. 隐式类型转换：

可以进行一些隐式转换（如非 const 到 const 的转换），也可以将指针或引用转换为 void*。

int i = 42;

// 非 const 指针转换为 const 指针
const int* constPtr = static_cast<const int*>(&i);  

int* p = new int(10);
void* voidPtr = static_cast<void*>(p);  // 将 int* 转换为 void*

当使用 static_cast 将基类指针转换为派生类指针时，编译器会进行类型转换，但不会进行安全检查。如果转换是合法的，那么转换后的指针可以正确地指向派生类对象；如果转换是不合法的，那么可能导致未定义的行为。

2. dynamic_cast

dynamic_cast 是一种动态类型转换，在运行时期完成。
它通常用于在继承关系中进行安全的向下转型（从基类指针向派生类指针的转换）。

dynamic_cast的语法如下:

dynamic_cast<目标类型>(表达式)

使用场景

1. 将基类指针或引用转换为派生类指针或引用：

(向下转型)当需要将基类指针或引用转换为派生类指针或引用，并且想要进行类型检查以确保转换的安全性时，可以使用 dynamic_cast。

class Base { ... };
class Derived : public Base { ... };

Base* basePtr = new Derived();
Derived* derivedPtr = dynamic_cast<Derived*>(basePtr); 
// 将基类指针转换为派生类指针

if (derivedPtr != nullptr) {
    // 转换成功，可以使用 derivedPtr 访问派生类特有的成员函数或成员变量
} else {
    // 转换失败，basePtr 并非指向 Derived 对象
}

2. 判断指针或引用的实际类型：

可以使用 dynamic_cast 进行类型检查，判断指针或引用所指对象的实际类型。如果转换成功，则指针或引用指向的对象是目标类型；如果转换失败，则指针或引用指向的对象不是目标类型。

if (Derived* derivedPtr = dynamic_cast<Derived*>(basePtr)) {
    // basePtr 指向 Derived 对象
} else if (OtherDerived* otherDerivedPtr = dynamic_cast<OtherDerived*>(basePtr)) {
    // basePtr 指向 OtherDerived 对象
} else {
    // basePtr 指向其他类型的对象
}

使用 dynamic_cast 进行指针或引用的类型转换时，被转换的类必须具有至少一个虚函数。此外，对于不完整类型（比如尚未定义完的类），或者无法访问其运行时类型信息（RTTI）的对象，dynamic_cast 也无法进行转换。

在执行 dynamic_cast 时，如果转换失败且返回指针类型，返回结果为 nullptr；如果转换失败且返回引用类型，将抛出 std::bad_cast 异常，从而避免未定义的行为。

3. reinterpret_cast

reinterpret_cast 用于进行底层的重新解释（reinterpret）类型转换， 可以将一个指针或引用转换为其他任意类型的指针或引用，而无需执行标准的类型检查。
它提供了最底层的类型转换，并且通常用于处理非常特殊的转换情况。

reinterpret_cast的语法如下：

reinterpret_cast<目标类型>(表达式)

使用场景：

1. 不同类型之间的指针或引用转换：

reinterpret_cast 可以将一个指针或引用转换为其他类型的指针或引用，而无需进行类型检查。
这可以用于不同类型之间的指针或引用的转换，但需要注意该转换可能会产生未定义行为。

int* intPtr = new int(42);
double* doublePtr = reinterpret_cast<double*>(intPtr); 
// 将 int 指针转换为 double 指针

int& intRef = *intPtr;
double& doubleRef = reinterpret_cast<double&>(intRef);  
// 将 int 引用转换为 double 引用

2. 整数和指针之间的转换

reinterpret_cast 还可以用于将整数类型转换为指针类型，或者将指针类型转换为整数类型。这种转换通常用于底层操作，例如将内存地址表示为整数。

uintptr_t address = reinterpret_cast<uintptr_t>(intPtr); 
// 将 int 指针转换为无符号整数

int* intPtr2 = reinterpret_cast<int*>(address);  
// 将无符号整数转换为 int 指针

需要注意的是，整数和指针之间的转换在不同平台、不同编译器之间可能具有不确定行为，并且可能导致安全问题和错误结果。

4. const_cast

const_cast 用于去除指针或引用的 const 或 volatile 修饰符，以便进行修改。
主要用于处理对象的常量性（constness）或易变性（volatility），允许在某些情况下对常量对象进行修改操作。

const_cast<目标类型>(表达式)

使用场景

1. 去除指针或引用的 const 修饰符：

const_cast 可以将一个指向常量对象的指针转换为指向非常量对象的指针，以便对其进行修改。需要注意的是，如果尝试修改本身是常量的对象，则会导致未定义行为。

const int* constPtr = new int(42);
int* mutablePtr = const_cast<int*>(constPtr);  // 去除 const 修饰符

*mutablePtr = 24;  // 可以修改 mutablePtr 指向的对象

2. 去除指针或引用的 volatile 修饰符：

const_cast 也可以用于去除指向易变对象（volatile object）的指针或引用的 volatile 修饰符，以便进行非易变操作。

volatile int count = 0;
int& nonVolatileRef = const_cast<int&>(count);  // 去除 volatile 修饰符

nonVolatileRef = 10;  // 可以对 nonVolatileRef 进行非易变操作