C++ 深入理解const_cast转换运算符

const_cast转换运算符我们在RTTI和类型转换运算符中详细介绍过它的用法和使用场景，今天我们对其进一步了解一下。首先我们回忆一下它的作用和用法。

const_cast的基本使用
const_cast运算符用于执行只有一种用途的类型转化，即改变const或volatile。

用法如下：

const_cast <type_name> (expression)
1
返回值为新类型。这里我们需要强调的是 const_cast主要用于更改指针或引用的const或volatile限定符。其中，type_name必须是指针、引用或者成员指针类型。

示例1：

#include<iostream>

struct type {
int i;

type(): i(3) {}

void f(int v) const
{
// this->i = v; // 编译错误：this 是指向 const 的指针
const_cast<type *>(this)->i = v; // 只要该对象不是 const 就 OK
}
};

int main()
{
int i = 3; // 不声明 i 为 const
const int &rci = i;
//rci = 100; //错误
const_cast<int &>(rci) = 4; // OK：修改 i
std::cout << "i = " << i << '\n';

type t; // 如果这是 const type t，那么 t.f(4) 会是未定义行为
t.f(4);
std::cout << "type::i = " << t.i << '\n';

const int j = 3; // 声明 j 为 const
int *pj = const_cast<int *>(&j);
*pj = 4; // 未定义行为
std::cout << "j = " << j << '\n';
std::cout << "*pj = " << *pj << '\n';

void (type::* pmf)(int) const = &type::f; // 指向成员函数的指针
//const_cast<void(type::*)(int)>(pmf); // 编译错误：const_cast 不能用于成员函数指针
}
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
运行输出：

i = 4
type::i = 4
j = 3
*pj = 4
1
2
3
4
示例1介绍了const_cast常用的使用场景和使用的注意事项。其中：

const int j = 3; // 声明 j 为 const
int *pj = const_cast<int *>(&j);
*pj = 4; // 未定义行为
std::cout << "j = " << j << '\n'; //输出结果：j = 3
std::cout << "*pj = " << *pj << '\n'; //输出结果：*pj = 4
1
2
3
4
5
对于&j使用const_cast转换后，进行重新赋值，这种行为在C++语法中是未定义的行为，但实际上是确实可以运行的。但对于打印输出结果却与我们的预期不一致，实际上对于j的值真的没有修改成功吗？下面我们继续做一个实验，代码如下：

#include<iostream>

int main()
{
//未定义的行为，不提倡使用
const int j = 3; // 声明 j 为 const
int *pj = const_cast<int *>(&j);
*pj = 4; // 未定义行为
std::cout << "j = " << j << " ,addr(j):" << &j << '\n';
std::cout << "*pj = " << *pj << " ,addr(*pj):" << pj << '\n';

//正常的行为
int j1 = 3;//最初声明为非const
const int *cpj1 = &j1;
int *pj1 = const_cast<int *>(cpj1);//cpj1最终指向的值（即j1的值）为非const类型，可以使用const_cast
*pj1 = 4;
std::cout << "j1 = " << j1 << " ,addr(j1):" << &j1 << '\n';
std::cout << "*pj1 = " << *pj1 << " ,addr(*pj1):" << pj1 << '\n';
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
运行结果：

j = 3 ,addr(j):0x30932680c
*pj = 4 ,addr(*pj):0x30932680c
j1 = 4 ,addr(j1):0x3093267fc
*pj1 = 4 ,addr(*pj1):0x3093267fc
1
2
3
4
从运行结果可以看出，j和*pj的地址相同，j1和*pj1的地址相同，但是j和*pj显示的值却不同，为什么会出现这种结果呢？实际上这就是因为编译器优化结果造成的，因为在声明j的时候，其类型是const int，在编译阶段，编译器认为它就是不变的类型，当编译到std::cout << "j = " << j << " ,addr(j):" << &j << '\n';时，会将j直接替换为常量3，即std::cout << "j = " << 3 << " ,addr(j):" << &j << '\n';，因此打印出来的就过就是3。也正是由于该行为是未定义的行为，才导致输出结果与我们的预期不一致。所以，在我们日常使用中，const_cast可以用用来修改最初声明非const的值，而且应该尽量避免常量转换，除非我们真的需要使用它。

const_cast在调用第三方函数中的使用
const_cast另外一种使用场景就是：在使用第三方库或API时，它们只提供了非const类型的参数的函数，但我们只有const类型的对象。如示例2所示。

示例2：

#include <iostream>
using namespace std;

int third_lib_fun(int *ptr) {
*ptr = *ptr + 10;
return (*ptr);
}

int main(void) {
int val = 10;
const int *ptr = &val;
int *ptr1 = const_cast<int *>(ptr);
third_lib_fun(ptr1);
cout << val;
return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
输出结果：

20
1
在示例2中，我们在使用第三方库和API的时候，我们只能调用，看不到其具体的实现，为了能够调用成功，需要使用const_cast来去除*ptr的const属性，来保证函数的正常调用，但是需要保证*ptr指向的对象在初始化的时候是非const的。

const_cast去除volatile属性
const_cast的另一个作用就是：const_cast可以用于丢弃volatile属性。例如在下面的示例3中，通过const_cast将b1的类型由volatile int*转换为 int*。

示例3：

#include <iostream>
#include <typeinfo>
using namespace std;

int main(void) {
int a1 = 40;
volatile int* b1 = &a1;
cout << "typeid of b1 " << typeid(b1).name() << '\n';
int* c1 = const_cast<int*>(b1);
cout << "typeid of c1 " << typeid(c1).name() << '\n';
return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
输出结果：

typeid of b1 PVi
typeid of c1 Pi
1
2
从输出结果可以看到，b1的typeid为PVi（pointer to a volatile integer，指向volatile类型的int指针），c1的typeid为Pi（Pointer to integer，指向int的指针），使用const_cast去除了b1的volatile的属性。

总结
综上，我们使用const_cast的原则就是：

仅当实际引用的对象/变量不是常量，才使用const_cast；

当我们调用第三方库和一些API时，它们需要使用非const形式的数据，但我们只有const形式数据时候才能使用const_cast。

总的来说就是：仅在不得不的情况下使用const_cast。
————————————————
原文链接：https://blog.csdn.net/jianmo1993/article/details/129275696