强制类型转换(const_cast)

【1】 const_cast的作用

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

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

三、常量对象 被强转为 非常量对象。

【2】 实例代码

代码如下：

 #include <iostream>
 using  namespace std;
 
 const int xx = ;
 
 class A
 {
 public:
     int m_nNum;
 
 public:
     A(int nValue = );
 };
 
 A::A(int nValue) : m_nNum(nValue)
 {
 }
 
 void TestFun()
 {
     // 第一种情况: const修饰指针指向对象
     const A *pA = new A();
 //  pA->m_nNum = 100;            // compile error ! pA指针指向的对象为常对象，其成员变量值为只读的。
     A* pAA = const_cast<A*>(pA); // 去掉pA指针的const属性
     pAA->m_nNum = ;           // pAA指针指向的对象为一般对象，其成员变量值可读写。
     cout << pA->m_nNum << endl;  // 199
 
     // 第二种情况: const修饰指针
     A *pB = new A();
     pA = pB;  // 思考这个原因。为什么这样子可以呢？且再看下面的这种情况：
     A* const pC = new A();
     cout << pC->m_nNum << endl;  //
     A *pD = new A();
 //  pC = pD;                     // compile error ! pC指针变量被const修饰，其值是只读的。
 
     A*& pE = const_cast<A*>(pC); // 去掉pC指针变量的const属性。再赋给指针引用变量
     pE = pD;
     cout << pC->m_nNum << endl;  //
 
     A* pAS = const_cast<A*>(pC); // 去掉pC指针变量的const属性。再赋给一般指针变量
     pAS->m_nNum = ;             // 通过去掉const属性的指针变量修改其成员变量值
     cout << pC->m_nNum << endl;  // 3
 
     // 第三种情况：const修饰指针和指针对象
     const A* const pCC = new A();
     const A* pCC2 = const_cast<A*>(pCC);
 //  pCC2->m_nNum = 119; //  error C3490: 由于正在通过常量对象访问“m_nNum”，因此无法对其进行修改
     pCC2 = NULL;
     A* const pCC3 = const_cast<A*>(pCC);
     pCC3->m_nNum = ;
 //  pCC3 = NULL; error C3892: “pCC3”: 不能给常量赋值
     A* pCC4 = const_cast<A*>(pCC);
     pCC4->m_nNum = ;
     pCC4 = NULL;
 
     // 第四种情况：const修饰对象，去const属性后赋给一般对象
     const A a;
 //  a.m_nNum = 101; // compile error ! 常对象具有只读属性。
     A b = const_cast<A&>(a);
     b.m_nNum = ;
     cout << a.m_nNum << endl; //
     cout << b.m_nNum << endl; // 101
 
     // 第五种情况：const修饰对象，去const属性后赋给引用对象
     const A c;
 //  c.m_nNum = 101; // compile error ! 常对象具有只读属性。
     A& d = const_cast<A&>(c);
     d.m_nNum = ;
     cout << c.m_nNum << endl; //
     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 = ;
     cout << e.m_nNum << endl; //
     cout << pe->m_nNum << endl; // 103
 
     // 第七种情况：const修饰局部变量
     const int xx = ;
     int* yy = const_cast<int *>(&xx);
     *yy = ;
     cout << xx << endl; //
     cout << *yy << endl; //
     int aa = xx;
     cout << aa << endl; // 50
 
     // 第八种情况：const修饰局部变量。去const属性后赋给一般变量
     const int xxx = ;
     int yyy = const_cast<int&>(xxx);
     yyy = ;
     cout << xxx << endl; //
     cout << yyy << endl; // 51
 
     // 第九种情况：const修饰局部变量。去const属性后赋给引用变量
     const int xxx2 = ;
     int& yyy2 = const_cast<int&>(xxx2);
     yyy2 = ;
     cout << xxx2 << endl; //
     cout << yyy2 << endl; //
 }
 
 void main()
 {
     TestFun();
     system("pause");
 }
 
 // run out:
 /*
 199
 1
 2
 3
 100
 101
 102
 102
 103
 103
 50
 200
 50
 50
 51
 50
 52
 请按任意键继续. . .
 */

Good Good Study, Day Day Up.

顺序 选择 循环 总结