Difference between const int * PI and INT const * PI and int * const pi

1 start with const int I
You know, when declaring a variable, int I is like this; this I may be re-assigned to it. As follows:
Int I = 0;
//...
I = 20; // The value is assigned again here.
However, one day my program may need such a variable (temporarily called its variable) and assign an initial value when declaring it. Then, my program will not assign a value to it in any other place. What should I do? Use Const.
//**************
Const int Ic = 20;
//...
Ic = 40; // This is not acceptable. It cannot be passed during compilation, because we cannot re-assign values to the const modified IC.
// In this way, our program will be more likely to discover problems earlier.
//**************
With the const modified IC, we do not call it a variable, but a symbolic constant, representing the number of 20. This is the role of Const. An IC cannot be re-assigned to it.
After understanding the role of const, we also need to know the format. There are two types: const int Ic = 20; and INT const Ic = 20 ;. They are identical. We need to be clear about this. In short, you must remember the meaning of const and INT before writing. With this concept, let's look at the two guys: const int * PI and INT const * pi. According to your logic, are their meanings different? Well, you just need to remember that int and const are the same before and after the put, just like const int IC; and INT const IC. That is to say, they are the same.
Now we have fixed the problem of "dual-pack. So what is the difference between int * const PI and the first two formulas? Let me analyze their formats and semantics in detail!

2 const int * PI Semantics
Let me first talk about the role of the const int * Pi (of course, the int const * pi is the same, as we have said before, they are actually the same ). See the following example:
// ************** Code start ***************
Int I1 = 30;
Int I2 = 40;
Const int * Pi = & I1;
Pi = & I2; // 4. Note that pi can assign a new memory address at any time.
I2 = 80; // 5. Think about it: Can I use * Pi = 80; instead? Of course not.
Printf ("% d", * PI); // 6. The output is 80
***************
Semantic Analysis:
No. The pI value can be modified. That is, it can point to another address again, but it cannot use * pi to modify the i2 value. Does this rule comply with the logic we mentioned earlier? Of course!
First, const modifies the entire * Pi (note that I am writing * PI instead of PI ). So * pi is a constant and cannot be assigned a value (although PI refers to I2 as a variable, not a constant ).
Second, Pi is not modified with const, so pi is a pointer variable and can be assigned to another memory address. You may wonder: how can I use const to modify pi? In fact, you can understand the position of the const In the int * const pi. Remember to view the semantics through the format. Haha, you may have seen the rule, right? Then there is no need to read the following section. But I have to continue my battle!

3. Look at int * const pi.
Indeed, int * const PI and the previous int const * Pi are easy to confuse. Note: The const in the previous sentence is written before and after PI, not before * pi. Obviously, it modifies and limits pi. Let me show you the example first:
// ************** Code start ***************
Int I1 = 30;
Int I2 = 40;
Int * const Pi = & I1;
// Pi = & I2; 4. Note that here, PI cannot be assigned again, that is, it cannot point to another address.
// So I have commented on it.
I1 = 80; // 5. Think about it: Can I use * Pi = 80; instead? Yes. Here, you can modify the i1 value through * pi.
// Compare it with the previous example.
Printf ("% d", * PI); // 6. The output is 80
*********************
Semantic Analysis:
After reading this code, What do you understand? Is it found that the PI value cannot be re-assigned and modified. It can only always point to the memory address during initialization. Instead, you can use * pi to modify the i1 value this time. Compare it with the previous example! See the following two points for analysis:
1 ). pi has the const modifier, so it is just a pointer constant: that is, the PI value cannot be modified (that is, PI cannot point to the i2 variable again) (see row 4th ).
2). There is no const modification before the entire * pi. That is to say, * pi is a variable rather than a constant, so we can use * pi to modify the value of memory I1 (see the comments of five rows)
In a word, this pi is a pointer constant pointing to the int variable type data.
I will summarize the following two sentences:
1). If const is modified before * Pi, it cannot be changed to * Pi (that is, it cannot be like this: * Pi = 50; Value assignment) instead of pi.
2). If const is directly written before Pi, the PI cannot be changed (that is, it cannot be like this: Pi = & I; assignment ).
Please remember these two points first. I believe you will not be confused by them. Now, when I look at the two declarative statements int const * PI and int * const Pi, will you feel dizzy or relaxed? What can be modified and cannot be modified by their respective declared pi? Ask yourself again, tell me your understanding, can post can also be sent to my mailbox (my mailbox yyf977@163.com )! I will definitely reply.

3. Add three cases.
Here, I will add the following three cases. In fact, as long as the above semantics is clear, these three situations have already been included. But as three specific forms, I 'd like to mention it briefly!

Case 1: int * When the PI Pointer Points to the const int I constant
// *********** Begin *****************
Const int I1 = 40;
Int * PI;
Pi = & I1; // can this be done? No. It is a compilation error in VC.
// The I1 address of the const int type cannot be assigned to the pointer PI pointing to the int type. Otherwise, won't pi be able to modify the i1 value!
Pi = (int *) & I1; // can this be done? Forced type conversion is supported by C.
// The I1 value is compiled in VC, but still cannot be modified by * Pi = 80. Try it! Let's see how it works.
// ************ End ***************

Case 2: When the const int * PI Pointer Points to const int I1
// ********** Begin ****************
Const int I1 = 40;
Const int * PI;
Pi = & I1; // The two types are the same. You can assign values like this. Obviously, neither PI nor I1 can be modified.
// ********** End *****************

Case 3: pointer declared with const int * const pi
// ************ Begin ****************
Int I
Const int * const Pi = & I; // can you imagine what operations pi can perform? The pI value cannot be changed or the I value cannot be changed through pi. Because both * PI and PI are const.
// ************* End ****************