来源:https://www.cnblogs.com/Braveliu/p/3616953.html
强制类型转换
const_cast的作用
-
常量指针 被强转为 非常量指针,且仍然指向原来的对象;
-
常量引用 被强转为 非常量引用,且仍然指向原来的对象;
-
常量对象 被强转为 非常量对象,此过程赋值运算符构造了新的对象,新的对象去掉了源对象的部分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