详解类型转换

类型转换

隐式类型转换（Implicit Type Conversion）

隐式类型转换是在不需要显式指定的情况下自动发生的类型转换。这种类型转换通常发生在以下情况下：

1. 小类型提升（Promotion）：当较小的数据类型转换为较大的数据类型时，编译器会自动执行隐式类型转换。例如，将一个 int 赋值给一个 double 变量。

int a = 10;
double b = a; // 隐式转换：int 转换为 double

2. 算术运算中的类型转换：当两个不同类型的操作数参与算术运算时，会自动进行隐式类型转换，使它们具有相同的类型。

int a = 5;
double b = 2.5;
double c = a + b; // 隐式转换：int 转换为 double

3. 赋值转换：当将一个表达式的值赋给一个变量时，会自动进行隐式类型转换。

int a = 10;
long b = a; // 隐式转换：int 转换为 long

4. 在函数调用中的类型转换：当调用函数时，如果参数的类型与函数声明的参数类型不匹配，会进行隐式类型转换。

double func(double x);
int a = 5;
double result = func(a); // 隐式转换：int 转换为 double

显式类型转换（Explicit Type Conversion）

显式类型转换是在代码中显式地指定将一个数据类型转换为另一个数据类型的过程。C++ 提供了四种显式类型转换的方式：

1. C 风格转换：使用 C 风格的类型转换，也称为旧式类型转换。

int a = 10;
double b = (double)a; // C 风格的显式转换：int 转换为 double

2. static_cast：static_cast 是 C++ 中较为推荐的类型转换方式，用于编译时的类型转换。

int a = 10;
double b = static_cast<double>(a); // static_cast 的显式转换：int 转换为 double

3. dynamic_cast：dynamic_cast 主要用于类层次结构中的向下转换，即将指向基类的指针或引用转换为指向派生类的指针或引用。

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

Base* basePtr = new Derived;
Derived* derivedPtr = dynamic_cast<Derived*>(basePtr); // dynamic_cast 的显式转换

4. const_cast：const_cast 用于去除指针或引用的 const 或 volatile 限定符。

const int x = 10;
int* y = const_cast<int*>(&x); // const_cast 的显式转换

5. reinterpret_cast：reinterpret_cast 用于进行不同类型之间的位模式重解释，通常用于处理底层的类型转换，比如将一个整数指针转换为一个字符指针。

int* ptrToInt = new int(10);
char* ptrToChar = reinterpret_cast<char*>(ptrToInt); // reinterpret_cast 的显式转换

显式类型转换能够提高代码的可读性，使类型转换更加明确，但同时也需要开发者保证转换的安全性和正确性。因此，在使用显式类型转换时需要谨慎。

静态类型转换与动态类型转换

静态类型转换 (static_cast)

静态类型转换是在编译时进行的类型转换，它通常用于执行相对安全的转换，比如基本数据类型之间的转换，指针之间的转换，以及类之间的转换。静态类型转换具有以下特点：

1. 编译时确定：静态类型转换在编译时进行，因此不会在运行时引入额外的性能开销。

2. 基本类型转换：可以在不同的基本数据类型之间进行转换，比如将整数转换为浮点数。

double d = 3.14;  
int i = static_cast<int>(d); // 将double转换为int，丢失小数部分

3. 指针转换：可以进行指针类型之间的转换，但需要开发者确保转换的安全性。

struct Base {};  
struct Derived : Base {};  
  
Derived d;  
Base* basePtr = &d;  
Derived* derivedPtr = static_cast<Derived*>(basePtr); // 假设basePtr确实指向Derived对象，否则会有未定义行为

注意：这个转换是不安全的，因为basePtr可能并不指向Derived类型的对象。如果它不是，那么derivedPtr的使用将导致未定义行为。

转换到void*和从void* 转换

int x = 10;  
void* ptr = static_cast<void*>(&x);  
int* xPtr = static_cast<int*>(ptr);

4. 类层次结构中的转换：可以在类的继承层次结构中进行向上或向下的转换，但不会进行运行时的类型检查。

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

Base* basePtr = new Derived;
Derived* derivedPtr = static_cast<Derived*>(basePtr); // 静态类型转换

5. 用于隐式类型转换：静态类型转换可以用于执行隐式类型转换，比如将整数转换为浮点数。

int a = 10;
double b = static_cast<double>(a); // 静态类型转换：int 转换为 double

动态类型转换 (dynamic_cast)

动态类型转换是在运行时进行的类型转换，主要用于处理类的继承层次结构中的转换。它具有以下特点：

1. 运行时确定：动态类型转换在运行时执行，并且会进行类型检查。

2. 类层次结构中的转换：主要用于在类的继承层次结构中进行向上或向下的转换。如果转换是合法的，即源类型指向的对象实际上是目标类型的对象，转换成功；否则，转换失败，返回空指针或抛出 std::bad_cast 异常（在指针转换中返回空指针，引用转换中抛出异常）。

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

Base* basePtr = new Derived;
Derived* derivedPtr = dynamic_cast<Derived*>(basePtr); // 动态类型转换

class Base {  
public:  
    virtual ~Base() {} // 需要虚析构函数来启用RTTI  
};  
  
class Derived : public Base {};  
  
Base* basePtr = new Derived();  
Derived* derivedPtr = dynamic_cast<Derived*>(basePtr); // 安全转换，如果basePtr确实指向Derived对象  
  
if (derivedPtr != nullptr) {  
    // 转换成功，现在可以使用derivedPtr  
} else {  
    // 转换失败，basePtr不指向Derived对象  
}

注意：动态类型转换依赖于虚函数表（vtable）和运行时类型信息（RTTI），因此被转换的类（在此例中是Base）必须有至少一个虚函数（通常是虚析构函数）。

3. 安全性检查：动态类型转换会进行类型检查，因此可以确保转换的安全性。如果类型不匹配，转换失败。

Base& baseRef = *basePtr;  
try {  
    Derived& derivedRef = dynamic_cast<Derived&>(baseRef); // 尝试安全转换  
    // 如果成功，现在可以使用derivedRef  
} catch (const std::bad_cast& e) {  
    // 转换失败，处理异常  
}

在这个例子中，如果baseRef不引用Derived类型的对象，dynamic_cast将抛出std::bad_cast异常。

4. 虚函数的支持：dynamic_cast 在进行向下转换时，要求基类中有至少一个虚函数，以确保能够正确地识别对象的动态类型。

class Base {
public:
    virtual ~Base() {}
};
class Derived : public Base {};

Base* basePtr = new Derived;
Derived* derivedPtr = dynamic_cast<Derived*>(basePtr); // 动态类型转换

总的来说，静态类型转换适用于编译时已知的转换，而动态类型转换适用于运行时确定的转换，并提供了类型安全检查的功能。因此，静态类型转换应该在开发者明确知道转换是安全的情况下使用，而动态类型转换适用于需要进行类型检查的场景。

区别

静态类型转换（static_cast）和动态类型转换（dynamic_cast）在C++中都是类型转换的方式，但它们之间存在明显的区别。

1. 转换时机：

   • 静态类型转换（static_cast）在编译期就进行类型转换，不进行运行时检查。这意味着，如果类型转换在逻辑上是不安全的，编译器不会报错，但运行时可能会出错。
   • 动态类型转换（dynamic_cast）会在运行期检查要转换的类型是否正确。这种检查是基于运行时类型信息（RTTI）的，可以确保类型转换的安全性。

2. 使用场景：

   • 静态类型转换（static_cast）主要用于非多态类型的转换，例如基本数据类型之间的转换、非多态类的上下转型、空指针和空类型的转换、枚举和整数之间的转换等。
   • 动态类型转换（dynamic_cast）主要用于类继承的安全转换，特别是涉及多态的情况。它主要用于在继承层次结构中，将基类指针或引用安全地转换为派生类指针或引用。

3. 错误处理：

   • 如果静态类型转换（static_cast）不安全，但编译器无法检查出来（例如，基类指针指向的对象不是派生类实例，但进行了向下转型），那么运行时会出现未定义行为，如程序崩溃。
   • 动态类型转换（dynamic_cast）在转换失败时，会返回空指针（对于指针类型）或抛出异常（对于引用类型），从而避免了未定义行为。

4. 性能：

   • 由于静态类型转换（static_cast）在编译期进行，因此通常具有更好的性能。
   • 动态类型转换（dynamic_cast）由于需要在运行期进行类型检查，因此可能具有额外的性能开销。