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

文章首发公众号：iDoitnow

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

const_cast的基本使用

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

用法如下：

const_cast <type_name> (expression)

返回值为新类型。这里我们需要强调的是 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 不能用于成员函数指针
}

运行输出：

i = 4
type::i = 4
j = 3
*pj = 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

对于&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';
}

运行结果：

j = 3 ,addr(j):0x30932680c
*pj = 4 ,addr(*pj):0x30932680c
j1 = 4 ,addr(j1):0x3093267fc
*pj1 = 4 ,addr(*pj1):0x3093267fc

从运行结果可以看出，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;
}

输出结果：

20

在示例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;
}

输出结果：

typeid of b1 PVi
typeid of c1 Pi

从输出结果可以看到，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。