Shulou(Shulou.com)06/01 Report--

In this article, the editor introduces in detail "how to use C++ constants and pointers". The content is detailed, the steps are clear, and the details are handled properly. I hope this article "how to use C++ constants and pointers" can help you solve your doubts. Let's follow the editor's ideas to learn new knowledge.

Preface

There is some subtlety in using the pointer. I have been dizzy all the time. Now let's continue to study it. Such as the following:

Int const;const int;const int* ptterint const* ptterint* const pten Const int* const p

Const is a way to handle symbolic constants. Variables declared in const are generally capitalized and cannot be modified after declaration. Compared to the specified type explicitly specified by define,const. In addition to defining symbols, it can generally be used for function declarations, indicating that the function does not modify any value; for parameters, indicating that the function does not modify parameters; and even for declaring the length of the array.

Unscramble

Const works on what is left of it by default. When there is nothing on the left, act on what is on the right. one

Const int* p, which only has something on the right, is decorated with int, so the value cannot be changed. In combination with *, it means that * p cannot be modified, anything else is fine. That is, what it points to cannot be changed through the pointer, but the address pointed to by the pointer itself can be changed.

Int const* p, the int that acts on the left first is int const, and the one on the right is superimposed, so the modifier is int p, so * p cannot be modified, anything else is fine. That is, what it points to cannot be changed through the pointer, but the address pointed to by the pointer itself can be changed. That is, it's the same as the one above.

Int* const p, and on the left is *, so const acts on the pointer and points to an int variable. That is, you cannot modify p, but you can modify * p, that is, you cannot change the address you are pointing to.

Const int* const p, for the first const, nothing on the left, modifies the int on the right, and points to a value that cannot be modified; for the second const modifier, the pointer cannot be modified. That is, you can not change the address pointed to by the pointer itself, nor can you change what it points to through the pointer. Same as int const const p.

Int const* const* p, the first const modifies int, the second const modifies the first, that is, the pointer to const int const p, and the last * is not modified, so it can point to other variables. Int const* const* const is not allowed. If this happens again, you can also slowly analyze the const and pointers flying all over the place.

Some examples

In order to better understand the above, here are some examples. There are generally two common choices:

The constant pointer points to a variable to prevent the modification pointer from modifying the variable value

A constant pointer points to a constant

Non-constant pointer points to constant (error)

First, look at the first case: dereferencing only takes out the value that points to the memory area, so the value pointing to the memory area can be modified directly, but not through the pointer.

Int main () {int a {34}; const int * p = & a; / / * p is const and cannot be modified / / error / / * p + +; / / p does not point to a constant, so you can modify an a + +; std::cout return 0;}

For the second case, you cannot modify variables or constants.

Int main () {const int a {34}; / / * p is const and cannot be modified, nor can a be modified const int * p = & a; std::cout return 0;}

In the third case, it would be absurd to modify the pointer to modify the constant, so the compilation would report an error directly:

Int main () {const int a {34}; / / error: invalid conversion from 'const int*' to' int*' int* p = & a; * p + +; std::cout return 0;} second-level pointer

As mentioned earlier, constant pointers can point to variables, but when secondary pointers are involved, the situation is reversed.

Int main () {const int a {12}; const int** p1; int* p2; / / error: invalid conversion from 'int**' to' const int**' p1 = & p2; * p1 = & a; * p2 = 10; return 0;}

If the above code passes, then the constant can be modified through the p2 pointer. Therefore, we can draw the following conclusions:

If the data type itself is not a pointer, you can assign the address of const or non-const data to the pointer to const, but the pointer can be modified to point to a different value. Therefore, const-decorated arrays cannot be passed to non-constant pointers.

If the data type is a pointer, the address of non-const data can only be assigned to a non-const pointer, for example, in the secondary pointer, p1 = & p2 is wrong.

After reading this, the article "how to use C++ constants and pointers" has been introduced. If you want to master the knowledge of this article, you still need to practice and use it. If you want to know more about the article, welcome to the industry information channel.

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.