C++强制类型转换(static_cast、dynamic_cast、const_cast、reinterpret_cast)

下面是关于C++中四种强制类型转换的攻略。

1. static_cast

static_cast是安全的类型转换，主要用于基本数据类型之间的转换，还可以在继承类之间进行类型转换。它可以将一个值从一种数值类型转换为另一种数值类型或提升或降低算术类型的类型。在用于指针时，可以将任何类型的指针转换为void指针，也可以将void指针转换为任何类型的指针。但是，它不能成功执行动态类型检查，也不能在安全性方面进行任何检查。

示例1

以下是一个基本数据类型之间转换的示例：

#include <iostream>

int main() {
    double d = 3.14;
    int i = static_cast<int>(d); //使用静态转换将double转换为int
    std::cout << "d = " << d << ", i = " << i << std::endl;
    //输出：d = 3.14, i = 3
    return 0;
}

示例2

以下是一个继承类之间的类型转换示例：

#include <iostream>

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

class Derived : public Base {
public:
    void func() {
        std::cout << "Derived::func()" << std::endl;
    }
};

int main() {
    Base* b = new Derived();
    Derived* d = static_cast<Derived*>(b); //用静态类型转换将基类指针指向派生类对象的指针，向下转换
    d->func(); //调用派生类函数
    delete b;
    return 0;
}

这里要注意，使用static_cast进行继承类之间的类型转换时，必须确保基类指向的实际是派生类，否则转换后调用派生类函数可能会出错。

2. dynamic_cast

dynamic_cast是一种动态类型转换，可以用于在继承类之间进行类型转换。它可以用于进行向上转换和向下转换。它会根据实际对象的类型来检查转换是否合法并进行安全检查。如果转换无效，则返回nullptr，如果转换有效，则必须再将其转换为正确的类型指针。

示例1

以下是一个向上转换的示例：

#include <iostream>

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

class Derived : public Base {
public:
    void func() {
        std::cout << "Derived::func()" << std::endl;
    }
};

int main() {
    Derived d;
    Base* b = &d;
    Derived* d1 = dynamic_cast<Derived*>(b); //向上转换
    if (d1) {
        d1->func();
    }
    return 0;
}

示例2

以下是一个向下转换的示例：

#include <iostream>

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

class Derived : public Base {
public:
    void func() {
        std::cout << "Derived::func()" << std::endl;
    }
};

int main() {
    Base* b = new Derived();
    Derived* d = dynamic_cast<Derived*>(b); //向下转换
    if (d) {
        d->func();
    }
    delete b;
    return 0;
}

这里要注意，dynamic_cast只能用于类的继承关系中，且要保证基类有虚析构函数。

3. const_cast

const_cast用于将常量指针或常量引用转换为非常量指针或非常量引用。它可以在去除常量性方面进行强制类型转换，但它不能扩大或缩小指针类型，不能在指针类型之间进行转换。

示例1

以下是一个常量引用转换为非常量引用的示例：

#include <iostream>

void func(const int& i) {
    int& j = const_cast<int&>(i);
    j = 10;
    std::cout << "i = " << i << ", j = " << j << std::endl;
}

int main() {
    int n = 5;
    func(n);
    return 0;
}

示例2

以下是一个常量指针转换为非常量指针的示例：

#include <iostream>

int main() {
    const int n = 5;
    const int* p1 = &n;
    int* p2 = const_cast<int*>(p1); //常量指针转换为非常量指针
    *p2 = 10;
    std::cout << "n = " << n << ", *p2 = " << *p2 << std::endl;
    return 0;
}

这里要注意，const_cast用于去除常量性是安全的，但过度使用const_cast可能会引发代码的语义混乱和不良后果。

4. reinterpret_cast

reinterpret_cast可以将一个指针或引用转换为其他类型的指针或引用，包括指向不同类型的指针之间的转换，从任何指针类型到void指针类型的转换等。它只是简单地将指针或引用重新解释为其他类型，而不修改指向的实际对象，因此需要小心使用。

示例1

以下是一个char指针转换为int指针的示例：

#include <iostream>

int main() {
    char c = 'A';
    char* pc = &c;
    int* pi = reinterpret_cast<int*>(pc); //将char指针转换为int指针
    std::cout << "*pi = " << *pi << std::endl;
    return 0;
}

示例2

以下是一个将整数转换为void指针，再将void指针转换回整数的示例：

#include <iostream>

int main() {
    int n = 65;
    void* p = reinterpret_cast<void*>(n); //将整数转换为void指针
    int n2 = reinterpret_cast<int>(p); //将void指针转换为整数
    std::cout << "n2 = " << n2 << std::endl;
    return 0;
}

这里要注意，由于reinterpret_cast可以进行危险的类型转换，因此使用时必须小心，在确保安全的前提下使用。