C + + type conversion detailed--const_cast (reprint)

Transferred from: http://blog.csdn.net/lwbeyond/article/details/6213382

A. Function Description:
Const_cast < Type-id > (expression)
The main use is to remove the const attribute, but you can also add the const attribute. Mainly use the former, the latter is seldom used.

Remove the const attribute:const_case<int*> (&num), often, because a const variable cannot be assigned directly to a non-const variable and must be converted.

Add the Const attribute: const int* k = Const_case<const int*> (j), which is rarely used because a non-const variable can be assigned directly to a const variable, such as: const int* k = j;

Two. Scope of use:
1. The constant pointer is converted to a non-const pointer, and the converted pointer points to the original variable (that is, the converted pointer address does not change).

[CPP]View Plaincopy

2. Class A
4. {
6. Public
8. A ()
10. {
12. M_inum = 0;
14. }
18. Public
20. int m_inum;
22. };
26. void Foo ()
28. {
30. //1. Pointer to class
32. const A *PCA1 = new A;
34. A *PA2 = const_cast<a*> (PCA1); //Constant object converted to a very mass object
36. Pa2->m_inum = 200; //fine
40. //The pointer points to the original object after conversion
42. cout<< Pca1->m_inum <<pa2->m_iNum<<endl; //200
46. //2. Pointers to basic types
48. const int ica = 100;
50. int * ia = const_cast<int *> (&ica);
52. *ia = 200;
54. cout<< *ia <<ica<<endl; //200
56. }

2. A constant reference is converted to a very good reference.

[CPP]View Plaincopy

2. Class A
4. {
6. Public
8. A ()
10. {
12. M_inum = 1;
14. }
18. Public
20. 　　int m_inum;
22. };
26. void Foo ()
28. {
32. A A0;
34. 　　Const A &A1 = a0;
36. A A2 = const_cast<a&> (A1); //constant reference to a very reference
40. A2.m_inum = 200; //fine
44. cout<< a0.m_inum << a1.m_inum << a2.m_inum << Endl; //1 1
46. }

2. A constant object (or base type) cannot be converted to a non-const object (or base type).

[C-sharp] view Plaincopy

2. void Foo ()
4. {
6. An error occurred when//constant object was converted to a very mass object
8. Const A CA;
10. A = const_cast<a> (CA); //Not allowed
14. const int i = 100;
16. int j = const_cast<int> (i); //Not allowed
20. }

Remember that this conversion only opens an interface, not a substantial conversion. (In fact, it is actually converted, but the expression is not allowed to write this)

3. Add a const attribute

[C-sharp] view Plaincopy

2. int main (int argc, char * * argv_)
4. {
6. int i = 100;
8. int *j = &i;
10. const int *k = const_cast<const int*> (j);
12. //const int *m = j; It's almost like it's written .
16. //refers to the same address
18. cout <<i<<"," <<&i<<endl; //100, 0012ff78
20. cout <<*j<<"," <<j<<endl; //100, 0012ff78
22. cout <<*k<<"," <<k<<endl; //100, 0012ff78
26. *j = 200;
28. //*k = 200; Error
32. return 0;
34. }

Three. Summary:
1. Using Const_cast to remove the const attribute does not really change the const property of the original class type (or base type), it simply provides an interface (pointer or reference) that allows you to change the value of the type through this interface. Maybe that's one reason const_case can only convert pointers or references.

2. Adding a const attribute using Const_case also provides an interface to not modify its value, but this added const operation has no practical purpose (perhaps I know too shallow).

C + + type conversion detailed--const_cast (reprint)