#include

using namespace std;

int main()
{
   const int constant = 26;			   // 定义一个常量constant
   const int* const_p = &constant;		   // 只能常量指针，才能指向常量
   int* modifier = const_cast(const_p);
   *modifier = 3;						   // const_cast使得指针指向的值可以修改
   cout<< "constant:  "<

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14

相关的说明我已经写在了注释里，这里需要强调一点，const_cast中type-i必须是指针或是引用类型。

让我感觉奇怪的是，modifier和const_p应该指向的是constant内存区域，我分别打印了constant的地址、const_p指向的地址和modifier指向的地址，他们的地址是相同的，但constant和*modifier输出的值是不一样的（好多博客和我有一样的疑问，但我觉得没有解释清楚，这个疑问待解决）。

参考博客：C++强制类型转换操作符 const_cast

2. static_cast

在这里先说明什么是向上转换和向下转换：

​ 向上转换：指子类向基类转换。

​ 向下转换：指基类向子类转换。

C++调用C#实现Xml读写

rar 5星 超过95%的资源 109KB

下载

​ 这两种转换，子类包含父类，当父类转换成子类时可能出现非法内存访问的问题。

• 子类转换成父类

  dynamic_cast (expression)

  比较安全，不会造成数据的丢失。

• 父类转换成子类

  强制转换，不安全，可能会导致数据的丢失

该类型的转换称为最常用的的类型，从名字中可以看出，这种类型是静态的，除了基本类型转换外，派生类转换成基类(向上转换）是安全的；进行基类转换成派生类（向下转换）时，由于没有动态类型检查，所以是不安全的。那什么是动态类型检查，我理解的动态类型检查就是在程序运行过程中的检查，就像c++多态时用到的虚函数，那么static_cast更多适用在编译时就确定的类型。

以下介绍static_cast的基本使用：

#include
using namespace std;
class Basic {

};
class Derive:public Basic{

};
int main() {
    // 1. 基本类型转换
    int a = 1;
    double b = static_cast(a);
    cout << b << endl;    //1
    // 2. 空指针转换为目标指针
    int *p;
    void *m = malloc(sizeof(int));
    p = static_cast(m);
    *p = 233;
    cout << *p << endl;   // 233
    // 3. 派生类转换成基类（向上转换、向下转换都可，只是向下转换容易出错）
    Basic *bb = nullptr;
    Derive *dd = new Derive;
    bb = static_cast (dd);
    cout << typeid(bb).name() << endl;
    return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

3. dynamic_cast

使用此关键字有以下几个条件：

1. 必须有虚函数(我试了gcc version 9.4.0 (Ubuntu 9.4.0-1ubuntu1~20.04.1)， 不加虚函数也是可以的)

2. 必须打开编译器的RTTI开关

3. 必须有继承关系

dynamic_cast通过判断变量运行时类型和要转换的类型是否相同来判断是否能够进行向下转换。dynamic_cast可以做类之间上下转换，转换的时候会进行类型检查，类型相等成功转换，类型不等转换失败。运用RTTI技术，RTTI是”Runtime Type Information”的缩写，意思是运行时类型信息，它提供了运行时确定对象类型的方法。在c++层面主要体现在dynamic_cast和typeid，vs中虚函数表的-1位置存放了指向type_info的指针，对于存在虚函数的类型，dynamic_cast和typeid都会去查询type_info。

#include
using namespace std;

class A {
public:
        virtual void info() {
        cout << "In A." << endl;
    }
};
class B : public A{
public:
        void info() {
        cout << "In B." << endl;
    }
};

int main() {
        A a1;
        B b1;
        A* a2 = new A;
        A* b2 = new B;

        // B* d = dynamic_cast(a2);
        // d->info();  // 出错，a2指向的是基类，基类转换成了派生类

        B* d1 = dynamic_cast (b2);
        d1->info();     // 可以, In B

        // B &d2 = dynamic_cast (a2);
        // d2->info();  // 出错

        A* d3 = dynamic_cast(&b1);
        d3->info();     // 可以，In B

        return 0;
}  
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

含义：将一个指向基类的指针转换成指向派生类的指针；如果失败，返回空指针。

dynamic_cast (expression) ，该运算符将expression转换成type_name类型的对象。type_name必须是类的指针，类的引用或者空类型的指针。
转换参数的注意事项

1. type_name和expression同类型。如果type_id是一个指针类型，那么expression也必须是一个指针类型，如果type_id是一个引用类型，那么expression也必须是一个引用类型；
2. 如果type_id是一个空类型的指针，在运行的时候，就会检测expression的实际类型，结果是一个由expression决定的指针类型；
3. 如果type_id不是空类型的指针，在运行的时候指向expression对象的指针能否可以转换成type_id类型的指针。
4. 主要用于上下行之间的转换，也可以用于类之间的交叉转换。上行转换时和static_cast效果一样，下行转换时，具有检测功能，比static_cast更安全。

返回值
在运行的时候决定真正的类型，如果向下转换是安全的，就返回一个转换后的指针，若不安全，则返回一个空指针。

4. reinterpret_cast

reinterpret_cast可以做任何类型的转换，不过不对转换结果保证，容易出问题。