强制类型转换(const_cast)

【1】 const_cast的做用

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

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

3、常量对象 被强转为 很是量对象。 

【2】 实例代码

代码以下：

  1 #include <iostream>
  2 using  namespace std;
  3 
  4 const int xx = 50;
  5 
  6 class A
  7 {
  8 public:
  9     int m_nNum;
 10 
 11 public:
 12     A(int nValue = 100);
 13 };
 14 
 15 A::A(int nValue) : m_nNum(nValue)
 16 {
 17 }
 18 
 19 void TestFun()
 20 {
 21     // 第一种状况: const修饰指针指向对象
 22     const A *pA = new A(200);
 23 //  pA->m_nNum = 100;            // compile error ! pA指针指向的对象为常对象，其成员变量值为只读的。
 24     A* pAA = const_cast<A*>(pA); // 去掉pA指针的const属性
 25     pAA->m_nNum = 199;           // pAA指针指向的对象为通常对象，其成员变量值可读写。
 26     cout << pA->m_nNum << endl;  // 199
 27 
 28     // 第二种状况: const修饰指针
 29     A *pB = new A();
 30     pA = pB;  // 思考这个缘由。为何这样子能够呢？且再看下面的这种状况：
 31     A* const pC = new A(1);
 32     cout << pC->m_nNum << endl;  // 1
 33     A *pD = new A(2);
 34 //  pC = pD;                     // compile error ! pC指针变量被const修饰，其值是只读的。
 35 
 36     A*& pE = const_cast<A*>(pC); // 去掉pC指针变量的const属性。再赋给指针引用变量
 37     pE = pD;
 38     cout << pC->m_nNum << endl;  // 2
 39 
 40     A* pAS = const_cast<A*>(pC); // 去掉pC指针变量的const属性。再赋给通常指针变量
 41     pAS->m_nNum = 3;             // 经过去掉const属性的指针变量修改其成员变量值
 42     cout << pC->m_nNum << endl;  // 3
 43 
 44     // 第三种状况：const修饰指针和指针对象
 45     const A* const pCC = new A(110);
 46     const A* pCC2 = const_cast<A*>(pCC);
 47 //  pCC2->m_nNum = 119; //  error C3490: 因为正在经过常量对象访问“m_nNum”，所以没法对其进行修改
 48     pCC2 = NULL;
 49     A* const pCC3 = const_cast<A*>(pCC);
 50     pCC3->m_nNum = 119;
 51 //  pCC3 = NULL; error C3892: “pCC3”: 不能给常量赋值
 52     A* pCC4 = const_cast<A*>(pCC);
 53     pCC4->m_nNum = 120;
 54     pCC4 = NULL;
 55 
 56     // 第四种状况：const修饰对象，去const属性后赋给通常对象
 57     const A a;
 58 //  a.m_nNum = 101; // compile error ! 常对象具备只读属性。
 59     A b = const_cast<A&>(a);
 60     b.m_nNum = 101;
 61     cout << a.m_nNum << endl; // 100
 62     cout << b.m_nNum << endl; // 101
 63 
 64     // 第五种状况：const修饰对象，去const属性后赋给引用对象
 65     const A c;
 66 //  c.m_nNum = 101; // compile error ! 常对象具备只读属性。
 67     A& d = const_cast<A&>(c);
 68     d.m_nNum = 102;
 69     cout << c.m_nNum << endl; // 102
 70     cout << d.m_nNum << endl; // 102
 71 
 72     // 第六种状况：const修饰对象，对象指针去const属性后赋给指针
 73     const A e;
 74 //  e.m_nNum = 103; // compile error ! 常对象具备只读属性。
 75     A* pe = const_cast<A*>(&e);
 76     pe->m_nNum = 103;
 77     cout << e.m_nNum << endl; // 103
 78     cout << pe->m_nNum << endl; // 103
 79 
 80     // 第七种状况：const修饰局部变量
 81     const int xx = 50;
 82     int* yy = const_cast<int *>(&xx);
 83     *yy = 200;
 84     cout << xx << endl; // 50
 85     cout << *yy << endl; // 200
 86     int aa = xx;
 87     cout << aa << endl; // 50
 88 
 89     // 第八种状况：const修饰局部变量。去const属性后赋给通常变量
 90     const int xxx = 50;
 91     int yyy = const_cast<int&>(xxx);
 92     yyy = 51;
 93     cout << xxx << endl; // 50
 94     cout << yyy << endl; // 51
 95 
 96     // 第九种状况：const修饰局部变量。去const属性后赋给引用变量
 97     const int xxx2 = 50;
 98     int& yyy2 = const_cast<int&>(xxx2);
 99     yyy2 = 52;
100     cout << xxx2 << endl; // 50
101     cout << yyy2 << endl; // 52
102 }
103 
104 void main()
105 {
106     TestFun();
107     system("pause");
108 }
109 
110 // run out:
111 /*
112 199
113 1
114 2
115 3
116 100
117 101
118 102
119 102
120 103
121 103
122 50
123 200
124 50
125 50
126 51
127 50
128 52
129 请按任意键继续. . .
130 */

 

Good Good Study, Day Day Up.

顺序 选择 循环 总结