Const detail in C + +

Const detail in C + +

From http://blog.csdn.net/lwbeyond/article/details/6187501

I. The role of cons

(1) const constants can be defined

1. const int max=100;
3. int Array[max];

(2) Can protect the modified things, prevent accidental modification, enhance the robustness of the program

If I is modified in the function body, the compiler will make an error;

1. void f (const int i)
2. {
3. i=10;   //error!
4. }

(3) provides a reference for function overloading

1. Class A
2. {
3. ......
4. void f (int i) {...} //a function
5. void f (int i) const {...} //overload of previous function
6. ......
7. };

(4) can save space and avoid unnecessary memory allocation

2. #define PI 3.14159//Macro Constants
4. Const DOULBE pi=3.14159; //The PI is not placed in ROM at this time
6. ......
8. Double I=pi;  //Allocate memory for PI at this time, no longer assign!
10. Double I=pi; //macro substitution during compilation, allocating memory
12. Double J=pi; //No memory allocation
14. Double J=pi;  //Replace the macro again and allocate memory again!

Const definition constants from the assembly point of view, just give the corresponding memory address, instead of the immediate number as given in # define, so the const definition of the constant in the program runs only one copy, and the constant defined by the # # has several copies in memory.

(5) Improved efficiency
The compiler typically does not allocate storage space for ordinary const constants, but instead saves them in the symbol table, which makes it a constant during compilation, without the storage and read memory operations, making it highly efficient.

Two. Using the const
(1) Modifier general constants, constant groups, regular objects
The modifier const can be used before the type specifier, or it can be used in the type description specifier. For example:

2. Constant
4. int const x=2;
6. const int x=2;
10. Constant group
12. int Const A[5]={1, 2, 3, 4, 5};
14. const int A[5]={1, 2, 3, 4, 5};
18. Constant object
20. Class A;
22. const A;
24. a const A;

(2) Modifier pointer

1. const int *a;
2. int const *A; //const the object to which the modifier is directed, a variable, the object a points to is immutable
3. int *const A; //const modifier Pointer A, a is immutable, the object a points to is variable
4. const INT *const A; //The objects pointed to by pointer A and a are immutable

<<effective c++>> has a good way to remember: the const on the left side of the * number is the pointer of the content, the const on the right side of the number is a pointer.
Simple note is: Left content, right pointer.

You can also understand: ignore the type name first, and then see where the const is near, and modify who.

such as: const [INT] *p; First the int is removed, then the const modifier *P, p is the pointer, and *P is the object pointed to by the pointer, not variable

(3) Modifier reference

1. Const Double & V; //The object referenced by the reference cannot be updated

(4) The return value of the modifier function

The const modifier can also modify the return value of the function, and the return value cannot be changed in the following format:

1. const int Fun1 ();
3. Const MyClass FUN2 ();

(5) member functions for decorated classes
The const modifier can also decorate a member function of a class, in the following format:

1. Class ClassName
2. {
3. Public
4. int fun () const;
5. .....
6. }；

In this way, the data inside the class cannot be modified when the function fun is called.

1. Class A
2. {
3. Public
4. A (int i=0): Test (i) {} //Initialize list
5. Private
6. const int i

(6) To reference a const constant in another connection file

1. extern const int i; //Correct reference
3. extern const int j=10; //Error! Constants cannot be assigned again

Three. A few issues to be explained
(1) How do I initialize a constant inside a class?
Method 1: Initialize the list:

1. Class A
2. {
3. Public
4. A (int num): I (NUM) //with num to initialize I
5. {};
7. Private
8. const int i;
9. };

Method 2: External initialization

1. Class A
2. {
3. Public
4. A () {}
5. Private
6. static const int i; //Note must be static
7. }；
8. const int a::i=3; //External initialization

(2) What are the limitations of constants placed inside a class?

2. Error
4. Class A
6. {
8. Public
10. A ()
12. {};
16. Private
18. const INT c1 = 7; //error
20. static const INT c2 = 7; //error
24. static int c3 = 7; //error
26. }
32. Correct
34. Class A
36. {
38. Public
40. A (int num): C1 (num)
42. {};
46. Private
48. const INT C1;
50. static const INT c2;
54. static int c3;
56. }
58. const INT a::c2 = 7; //Do not add static
60. int a::c3 = 7; //Don't add STATCI

Here are three correct initialization methods, note that static cannot be added to the static flag when it is initialized externally.

3) is const an overloaded reference object?
Let's look at an example:

1. Class A
2. {
3. ......
4. void f (int i) {...} //a function
5. void f (int i) const {...} //overload of previous function
6. ......
7. };

The above is overloaded is no problem, then the following?

1. Class A
2. {
3. ......
4. void f (int i) {...} //a function
5. void f (const int i) {...}  //???
6. ......
7. };

This is a mistake, the compilation does not pass. So is it that the const of the internal parameter is not overloaded?

Let's look at the following example:

1. Class A
2. {
3. ......
4. void f (int&) {...} //a function
5. void f (const int&) {...}  //???
6. ......
7. };

This procedure is correct, it seems that the above conclusion is wrong. Why is that? This concerns the transparency of the interface.
When passing by value, this is transparent to the user, and the user does not know what the function does to the formal parameter, in which case overloading is meaningless, so the rules cannot be overloaded!

When a pointer or reference is introduced, the user will have a certain understanding of the operation of the function, is no longer transparent, the overload is meaningful, so the provisions can be overloaded.

Const detail in C + +