强制类型转换(const_cast)

来源：https://www.cnblogs.com/Braveliu/p/3616953.html

强制类型转换

const_cast的作用

1. 常量指针 被强转为 非常量指针，且仍然指向原来的对象；

2. 常量引用 被强转为 非常量引用，且仍然指向原来的对象；

3. 常量对象 被强转为 非常量对象，此过程赋值运算符构造了新的对象，新的对象去掉了源对象的部分const属性。

实列代码
代码如下：

#include <iostream>
using  namespace std;

const int xx = 50;

class A
{
public:
	int m_nNum;

public:
	A(int nValue = 100);
};

A::A(int nValue) : m_nNum(nValue)
{
}
// 1.指向常对象的指针，并不是该对象无法被修改，而是该指针没有修改对象的权限，就算该指针被重新赋值，其仍为指向常对象的指针，无法对新对象进行修改。
//
void TestFun()
{
	// 第一种情况: const修饰指针指向对象
	const A *pA = new A(200);
	// pA->m_nNum = 100;            // compile error ! pA指针指向的对象为常对象，其成员变量值为只读的。
	A* pAA = const_cast<A*>(pA); // 去掉pA指针的const属性,将其赋值给另一个指针pAA，pA仍是指向常对象的指针
	pAA->m_nNum = 199;           // pAA指针指向的对象为一般对象，其成员变量值可读写。
	cout << pA->m_nNum << endl;  // 199

	// 第二种情况: const修饰指针
	A *pB = new A();
	pA = pB;  // pA是指向常对象的指针，pA是可以被赋值的,但pA新指向的对象仍无法被修改
	A* const pC = new A(1);  // 常指针pC，该指针无法被赋值
	cout << pC->m_nNum << endl;  // 1
	A *pD = new A(2);
	//  pC = pD;                     // compile error ! pC指针变量被const修饰，其值是只读的。

		
	A*& pE = const_cast<A*&>(pC); // 去掉pC指针变量的const属性。再赋给指针引用变量
	pE = pD;  // 成功改变了常量指针pC的值
	cout << pC->m_nNum << endl;  // 2 
		

	A* pAS = const_cast<A*>(pC); // 去掉pC指针变量的const属性。再赋给一般指针变量
	pAS = pB;

	// 第三种情况：const修饰指针和指针对象
	const A* const pCC = new A(110);
	const A* pCC2 = const_cast<A*>(pCC);  // 去掉了指针无法修改的const
	//  pCC2->m_nNum = 119; //  error C3490: 由于正在通过常量对象访问“m_nNum”，因此无法对其进行修改
	pCC2 = NULL;
	A* const pCC3 = const_cast<A*>(pCC);  // 去掉了指向对象无法被修改的const
	pCC3->m_nNum = 119;
	//  pCC3 = NULL; error C3892: “pCC3”: 不能给常量赋值
	A* pCC4 = const_cast<A*>(pCC);  // 一次性去掉上述两种const
	pCC4->m_nNum = 120;
	pCC4 = NULL;

	// 第四种情况：const修饰对象，去const属性后赋给一般对象
	const A a;
	//  a.m_nNum = 101; // compile error ! 常对象具有只读属性。
	A b = const_cast<A&>(a);  // 赋值操作构造了新的对象，新对象去掉了元对象的const属性
	b.m_nNum = 101;
	cout << a.m_nNum << endl; // 100
	cout << b.m_nNum << endl; // 101

	// 第五种情况：const修饰对象，去const属性后赋给引用对象
	const A c;
	//  c.m_nNum = 101; // compile error ! 常对象具有只读属性。
	A& d = const_cast<A&>(c);  // 引用对象去掉了原对象的const属性
	d.m_nNum = 102;
	cout << c.m_nNum << endl; // 102
	cout << d.m_nNum << endl; // 102

	// 第六种情况：const修饰对象，对象地址(相当于常指针)去const属性后赋给指针
	const A e;
	//  e.m_nNum = 103; // compile error ! 常对象具有只读属性。
	A* pe = const_cast<A*>(&e);
	pe->m_nNum = 103;
	cout << e.m_nNum << endl; // 103
	cout << pe->m_nNum << endl; // 103

	// 第七种情况：const修饰局部变量
	// 此处需要添加volatile关键字，不加的话，编译器会自动优化xx为50，因为编译器认为常对象不可更改
	// 仅针对内置数据类型，自定义数据类型不会进行这种优化，不加volatile的结果为50，200，50
	const volatile int xx = 50;  
	int* yy = const_cast<int *>(&xx);  // 该指针指向原变量位置，值为50
	*yy = 200;  // 成功修改了常量对象
	cout << xx << endl; // 200
	cout << *yy << endl; // 200
	int aa = xx;
	cout << aa << endl; // 200，

	// 第八种情况：const修饰局部变量。去const属性后赋给一般变量
	const int xxx = 50;  
	int yyy = const_cast<int&>(xxx);  // 赋值操作，一样构造了新的对象
	yyy = 51;
	cout << xxx << endl; // 50
	cout << yyy << endl; // 51

	// 第九种情况：const修饰局部变量。去const属性后赋给引用变量
	const volatile int xxx2 = 50;  // 与第七中情况类似，不加volatile的结果为50，52
	int& yyy2 = const_cast<int&>(xxx2);  // 该引用指向原对象
	yyy2 = 52;  // 通过引用也成功修改了常对象的值
	cout << xxx2 << endl; // 52
	cout << yyy2 << endl; // 52
}

int main()
{
	TestFun();
	system("pause");
	return -1;
}

输出结果：

199
1
2
100
101
102
102
103
103
200
200
200
50
51
52
52