c++_如何将一个const变量转成非const变量_const_cast

谁借莪１个温暖的怀抱￠ 2022-10-15 01:53 828阅读 0赞

**目录**

C++提供了四个转换运算符

const\_cast (expression)

用const\_cast来去除const限定

传统转换方式实现const\_cast运算符

为何要去除const限定

--------------------

前面讲了[C++继承并扩展C语言的传统类][C_C]型转换方式，最后留下了一些关于指针和引用上的转换问题，没有做详细地讲述。C++相比于C是一门面向对象的语言，面向对象最大的特点之一就是具有“[多态性(Polymorphism)][Polymorphism]”。

要想很好的使用多态性，就免不了要使用指针和引用，也免不了会碰到转换的问题，所以在这一篇，就把导师讲的以及在网上反复查阅了解的知识总结一下。

# C++提供了四个转换运算符 #

*  [const\_cast <new\_type> (expression)][const_cast _new_type_ _expression]
 *  static\_cast <new\_type> (expression)
 *  reinterpret\_cast <new\_type> (expression)
 *  dynamic\_cast <new\_type> (expression)

它们有着相同的结构，看起来像是模板方法。这些方法就是提供给开发者用来进行指针和引用的转换的。

其实我很早就想写这篇内容的，自己不断地查看导师发来的资料，也在网上不停地看相关的知识，却一直迟迟不能完全理解C++转换运算符的用法，倒是看了那些资料后先写了一篇传统转换方面的内容。虽然从字面上很好理解它们大致是什么作用，但是真正像使用起来，却用不知道他们具体的用途，只会不断的被编译器提醒Error。所以如果出现理解不到位或错误的地方，还希望前人或来者能够指正。

在我看来这些标准运算符的作用就是对传统运算符的代替，以便做到统一。就像我们用std::endl来输出换行，而不是'\\n'。我会用代码来说明相应的传统转换可以如何这些标准运算符。当然，这这是大致的理解，在标准运算符上，编译器肯定有做更多的处理，特别是dynamic\_cast是不能用传统转换方式来完全实现的。

在这一篇文章里，我会先讲讲我对const\_cast运算符的理解。

## const\_cast (expression) ##

const\_cast转换符是用来移除变量的const或volatile限定符。对于后者，我不是太清楚，因为它涉及到了多线程的设计，而我在这方面没有什么了解。所以我只来说const方面的内容。

## 用const\_cast来去除const限定 ##

对于const变量，我们不能修改它的值，这是这个限定符最直接的表现。但是我们就是想违背它的限定希望修改其内容怎么办呢？

下边的代码显然是达不到目的的： `const int constant = 10; int modifier = constant;`

因为对modifier的修改并不会影响到constant，这暗示了一点:const\_cast转换符也不该用在对象数据上，因为这样的转换得到的两个变量/对象并没有相关性。

只有用指针或者引用，让变量指向同一个地址才是解决方案，可惜下边的代码在C++中也是编译不过的： `const int constant = 21; int* modifier = &constant // Error: invalid conversion from 'const int*' to 'int*'`

（上边的代码在C中是可以编译的，最多会得到一个warning，所在在C中上一步就可以开始对constant里面的数据胡作非为了）

把constant交给非const的引用也是不行的。 `const int constant = 21; int& modifier = constant; // Error: invalid initialization of reference of type 'int&' from expression of type 'const int'`

于是const\_cast就出来消灭const，以求引起程序世界的混乱。

下边的代码就顺利编译功过了： `const int constant = 21; const int* const_p = &constant; int* modifier = const_cast<int*>(const_p); *modifier = 7;`

## 传统转换方式实现const\_cast运算符 ##

我说过标：准转换运算符是可以用传统转换方式实现的。const\_cast实现原因就在于C++对于指针的转换是任意的，它不会检查类型，任何指针之间都可以进行互相转换，因此const\_cast就可以直接使用显示转换(int\*)来代替： `const int constant = 21; const int* const_p = &constant; int* modifier = (int*)(const_p);`

或者我们还可以把他们合成一个语句，跳过中间变量，用 `const int constant = 21; int* modifier = (int*)(&constant);`

替代 `const int constant = 21; int* modifier = const_cast<int*>(&constant);`

## 为何要去除const限定 ##

从前面代码中已经看到，我们不能对constant进行修改，但是我们可以对modifier进行重新赋值。

但是但是，程序世界真的混乱了吗？我们真的通过modifier修改了constatn的值了吗？修改const变量的数据真的是C++去const的目的吗？

如果我们把结果打印出来： `cout << "constant: "<< constant <<endl; cout << "const_p: "<< *const_p <<endl; cout << "modifier: "<< *modifier <<endl; /** constant: 21 const_p: 7 modifier: 7 **/`

constant还是保留了它原来的值。

可是它们的确指向了同一个地址呀：  
`cout << "constant: "<< &constant <<endl; cout << "const_p: "<< const_p <<endl; cout << "modifier: "<< modifier <<endl; /** constant: 0x7fff5fbff72c const_p: 0x7fff5fbff72c modifier: 0x7fff5fbff72c **/`

这真是一件奇怪的事情，但是这是件好事：说明C++里是const，就是const，外界千变万变，我就不变。不然真的会乱套了，const也没有存在的意义了。

[IBM的C++指南][IBM_C]称呼“\*modifier = 7;”为“未定义行为（Undefined Behavior）”。所谓未定义，是说这个语句在标准C++中没有明确的规定，由编译器来决定如何处理。

位运算的左移操作也可算一种未定义行为，因为我们不确定是逻辑左移，还是算数左移。

再比如下边的语句：v\[i\] = i++; 也是一种未定义行为，因为我们不知道是先做自增，还是先用来找数组中的位置。

对于未定义行为，我们所能做的所要做的就是避免出现这样的语句。对于const数据我们更要这样保证：绝对不对const数据进行重新赋值。

如果我们不想修改const变量的值，那我们又为什么要去const呢？

原因是，我们可能调用了一个参数不是const的函数，而我们要传进去的实际参数确实const的，但是我们知道这个函数是不会对参数做修改的。于是我们就需要使用const\_cast去除const限定，以便函数能够接受这个实际参数。

#include <iostream>
    using namespace std;
    
    void Printer (int* val,string seperator = "\n")
    {
    	cout << val<< seperator;
    }
    
    int main(void) 
    {	
    	const int consatant = 20;
    	//Printer(consatant);//Error: invalid conversion from 'int' to 'int*'
    	Printer(const_cast<int *>(&consatant));
    	
    	return 0;
    }

出现这种情况的原因，可能是我们所调用的方法是别人写的。还有一种我能想到的原因，是出现在const对象想调用自身的非const方法的时候，因为在类定义中，const也可以作为函数重载的一个标示符。有机会，我会专门回顾一下我所知道const的用法，C++的const真的有太多可以说的了。

在[IBM的C++指南][IBM_C]中还提到了另一种可能需要去const的情况：

#include <iostream>
    using namespace std;
    
    int main(void) {
    	int variable = 21;
    	int* const_p = &variable;
    	int* modifier = const_cast<int*>(const_p);
    	
    	*modifier = 7
    	cout << "variable:" << variable << endl;
    	
    	return 0;
    } 
    /**
    variable:7
    **/

我们定义了一个非const的变量，但用带const限定的指针去指向它，在某一处我们突然又想修改了，可是我们手上只有指针，这时候我们可以去const来修改了。上边的代码结果也证实我们修改成功了。

不过我觉得这并不是一个好的设计，还是应该遵从这样的原则：使用const\_cast去除const限定的目的绝对不是为了修改它的内容，只是出于无奈。（如果真像我说是种无奈，似乎const\_cast就不太有用到的时候了，但的确我也很少用到它）

[C_C]: http://www.cnblogs.com/ider/archive/2011/07/03/cpp_cast_operator_part1.html
[Polymorphism]: http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming
[const_cast _new_type_ _expression]: http://www.cnblogs.com/ider/archive/2011/07/22/cpp_cast_operator_part2.html%20
[IBM_C]: http://publib.boulder.ibm.com/infocenter/compbgpl/v9v111/index.jsp?topic=/com.ibm.xlcpp9.bg.doc/language_ref/keyword_const_cast.htm