《带你学C带你飞》第二十七讲：常量和指针

shuiyu

越努力，越幸运。欢迎大家来看我的笔记，不对的请各位大佬指正，谢谢
一、const 关键字
在 C 语言中，有一种能力可以将变量变成具有常量一样的特（意思就是不能修改了）。这就是 —— const 关键字。在它的修饰下，变量就会失去可修改的特性，也就是变成只读的属性。

1. const int price = 520;
   
2. const char a = 'a';
   
3. const float pi = 3.14;

复制代码

二、指向常量的指针
（1）万能的指针当然也可以指向被 const 修饰过的变量，这就意味着不能通过指针来修改它所引用的值。这时候，如果尝试修改指针引用的值，那么我们将被告知程序无法通过编译；但如果只是修改指针的指向，那么编译器并不会阻止你这么做。

（2）实例：

1. #include <stdio.h>
   
2. int main()
   
3. {
   
4.         int num=520;
   
5.         const int cnum=880;
   
6.         const int *pc=&cnum;
   
7.        
   
8.         printf("cnum:%d,&cnum:%p\n",cnum,&cnum);
   
9.         printf("*pc:%d,pc:%p\n\n",*pc,pc);
   
10. 
    
11.         pc=&num;
    
12.         printf("num:%d,&num:%p\n",num,&num);
    
13.         printf("*pc:%d,pc:%p\n\n",*pc,pc);
    
14. 
    
15.         num=1024;
    
16.         printf("*pc:%d,pc:%p\n",*pc,pc);
    
17. 
    
18.         return 0;
    
19. }

复制代码

（3）总结：
指针可以修改为指向不同的常量
指针可以修改为指向不同的变量（意思就是指针本身可以修改）
可以通过解引用来读取指针指向的数据
不可以通过解引用修改指针指向的数据

三、指向非常量的常量指针
（1）指向常量的指针，不能改变的是指针指向的值（即指针的地址不能改变），但指针本身是可以被修改的（即指针的地址上的值可以改）。如果要让指针也不可变，那么可以使用常量指针。

（2）使用方法：同样是使用 const 关键字修饰即可，只是位置稍微发生了变化，见下面代码

1. 
   
2. #include <stdio.h>
   
3. 
   
4. int main()
   
5. {
   
6.         int num=520;
   
7.         int cnum=880;
   
8.         int * const p=&num;
   
9.        
   
10.         printf("*p:%d\n",*p);
    
11.         printf("p:%p\n",p);
    
12. 
    
13.         *p=1024;
    
14.         printf("*p:%d\n",*p);
    
15.         printf("p:%p\n",p);       
    
16. 
    
17.         //下面的这些行为就不允许了，会报错。
    
18. //        p=&cnum;
    
19. //        printf("*p:%d\n",*p);
    
20. 
    
21.         return 0;
    
22. }
    

复制代码

（3）总结：它有如下特性：
指针自身不可以被修改（即指针的地址不能改变）
指针指向的值可以被修改（即指针的地址上的值可以改）

四、指向常量的常量指针
（1）这样指针自身不能被改变，它所指向的数据也不能通过对指针进行解引用来修改。其实这种霸气十足的限制在平时很少派上用场啦。并且我们发现——如果初始化时，指向的对象不是 const 修饰的变量，那么我们仍然可以通过变量名直接修改它的值：

1. #include <stdio.h>
   
2. int main()
   
3. {
   
4.                 //初始化时，指向的对象应该是const修饰的变量，则这里应该是:const int num=520;
   
5.         int num = 520;
   
6.         int cnum = 880;
   
7.         const int *const p = &num;
   
8. 
   
9.         printf("*p: %d\n", *p);
   
10. 
    
11.         num = 1024;
    
12.         printf("*p: %d\n", *p);
    
13. 
    
14.         /*
    
15.         *p = 1024;
    
16.         printf("*p: %d\n", *p);
    
17. 
    
18.         p = &cnum;
    
19.         printf("*p: %d\n", *p);
    
20.         */
    
21. 
    
22.         return 0;
    
23. }

复制代码

（2）在定义指向常量的常量指针时，如上面代码中的：const int *const p = &num;可以写成： int const * const p = &num；。由此我们可以推论出：const接近谁，就修饰谁，让它不可改变。

（3）总结：
指针自身不可以被修改（即指针的地址不能改变）
指针指向的值也不可以被修改（即指针的地址上的值也不能改）

五、指向“指向常量的常量指针”的指针
（1）标题看起来似乎挺恐怖的，但其实你只要仔细思考，就不难发现：关于指针的那点事儿，永远都是换汤不换药的把戏。

（2）实例：

1. #include <stdio.h>
   
2. 
   
3. int main()
   
4. {
   
5.         const int cnum = 880;
   
6.         const int *const p = &cnum;
   
7.         const int *const *pp = &p;
   
8. 
   
9.         printf("pp: %p, &p: %p\n\n", pp, &p);
   
10.         printf("*pp: %p, p: %p, &cnum: %p\n\n", *pp, p, &cnum);
    
11.         printf("**pp: %d, *p: %d, cnum: %d\n\n", **pp, *p, cnum);
    
12. 
    
13.         return 0;
    
14. }

复制代码

谢谢小甲鱼带来的视频教程，感谢！！

本节结束，多谢览阅！
越努力，越幸运。谢谢大家来看我的笔记，不对的请各位大佬指教，谢谢