If you give someone a program , you will frustrate them for a day ; if you teach them how to program , you will frustrate them for a lifetime , but for you , maybe I just this person .我是你们的圣彬老师 , 希望接下来的一段时间能够和大家一起探讨、学习 !

C语言是一门面向过程的语言 , 相比现在比较流行的面向对象 , 它更多的让我们理解 , 体会其中的奥义 , 在学习C语言过程中 , 大家要多思考 , 多理解 , 多敲 ,往往大家会有几个症状 :

• 上课能听懂 , 但是就是敲不出来,简称难产! 那是因为你听懂我的中国话 , 并没有听懂我的编程思想
• 写作业代码难产 , 怎么破 :
  
  • 尝试把思路用伪代码的方式写出来
    
    • 写不出来 : 没有思路
    • 能写出来 : 有思路,但是基本语法基础不扎实
      
  • 对着伪代码写代码 :
    
    • 如果能写出来说明只是思路不清晰
    • 如果还是不行说明基础语法也不懂 所以要对症下药 , 但是唯一的药就是 先模仿 , 先学习 , 增强代码感觉 , 再敲出来 , 输入输出相结合.
      
    
    
  
  

最后 , 我想对哪些已经开始自学的同学说 , 可能你们会困惑 , 不懂 , 不理解 , 不会应用 , 甚至不知所云 . 可实际上 , 无论学什么 , 都是努力才可以学到真东西, 只有真正掌握技术的人 , 才有可能去享用它 , 如果你中途放弃了 , 之前所有的努力和付出都会变得没有价值 . 学习游泳难吗 ? 掌握英语口语难吗 ? 可能难 , 但在掌握了的人眼中 , 这根本不算什么 , "就这么回事呀" 只要你相信自己一定可以学得会 , 学得好 , 最终的结果一定是 , 你对着别人说 : "学编程---就这么回事 !

附件是Markdown的笔记 , 大家可以直接下来看, 有目录
指针入门

• 什么是指针
  
  
  • 指针就是地址
    
• 什么是指针变量
  
  
  • 存放地址的变量 、 变量的内容是地址
    
• 为什么要用指针
  
  

直接获取/修改变量的值 :

1. int num = 10;
   
2. 
   
3. num = 20;
   
4. 
   
5. 请问num的值是否有改变 ?  有

复制代码

使用指针可以 间接的获取/修改变量的值 :

1. int num = 10;
   
2. 
   
3. num = 20;
   
4. 
   
5. 请问num的值是否有改变 ?  有

复制代码

认清指针 :

1. int num = 10;
   
2. int *p = &num
   
3. *p = 20;
   
4. 为什么  int *p = 地址 ?
   
5. 而         *p = 值 ?
   
6. 在定义的时候 :
   
7. int *p; 的   *    是类型说明符   说明定义的这个变量是一个指针变量
   
8. 在使用的时候 :
   
9. *p   的 *     是操作符     p所指向的地址对应的内容
   
10. 再解释一次  :
    
11.     int *p;   //定义一个指针变量
    
12.     p = &num ;   //  p指向num变量的地址  / p这个指针变量存放的是num的地址
    
13.     *p ;        //    p指向的地址 (num的地址)  *一下 , 拿到地址对应的内容

复制代码

二级指针

What : 指针的指针就是二级指针 / 存放指针的地址的指针变量就是二级指针

1. int num = 10;
   
2. 
   
3. int *p = #
   
4. 
   
5. int **p1 = &p;   // 这个就是二级指针
   
6. 
   
7. p1  ---->   指针变量p的地址
   
8. 
   
9. *p1  ------>   指针变量p的地址所对应的内容啊 ?  --->  &num
   
10. 
    
11. **p1  ------>   *p / *&num  ---->  10

复制代码

指针与数组

• 数组指针 / 指针数组
  
  
  • xxx指针 : 指向xxx的指针
    
    • 数组指针 : 指向数组的指针
    • 函数指针 : 指向函数的指针
    • 结构体指针 : 指向结构体的指针
    • 字符串指针 : 指向字符串的指针
    • 常量指针 : 指向常量的指针
      
    
    

1. * 指针数组 :  
   
2.         是一个指针还是数组 ? 数组 !  什么数组 ?  数组元素是地址(指针)的数组
   
3. 学习方法 :
   
4.     要学习数组指针 , 就得了解数组名的本质
   
5. 
   
6.     我们说过使用指针就是间接的获取或者修改变量的值
   
7. 
   
8.     那么数组指针也是同样道理
   
9. 
   
10. 
    
11. int main(){
    
12. 
    
13.     int arr[5] = {1,2,3,4,5};
    
14. 
    
15.     int *p = arr;
    
16. 
    
17.     //3中方法遍历数组元素
    
18. 
    
19.     //1 . 下标法
    
20. 
    
21.     for(int i = 0 ; i < 5 ; i++){
    
22. 
    
23.         printf("%d",arr[i]);
    
24. 
    
25.     }
    
26.     //2.  数组名发
    
27.     for(int i = 0 ; i < 5 ; i++){
    
28. 
    
29.         printf("%d",*(arr+i);
    
30. 
    
31.     }
    
32. 
    
33.     //3.  指针法
    
34.     for(int i = 0 ; i < 5 ; i++){
    
35. 
    
36.         printf("%d",*(p+i);   //  *(p+i) ==  *p++  
    
37. 
    
38. 
    
39.     }
    
40. 
    
41.     return 0;
    
42. 
    
43. }

复制代码

总结 :

如果你能用以上3总方法遍历数组元素 , 那么这个总结由你们来写

整型数组 对比 指针数组

1. 
   
2. //int类型的数组 , 数组名为arr , 元素个数为3
   
3. int arr[3] = {1,2,3};
   
4. 
   
5. 
   
6. 
   
7. //定义3个整型变量
   
8. int num1 = 10 , num2 = 20 , num3 = 30;
   
9. 
   
10. //指针数组
    
11. int *pArr[3] = {&num1,&num2,&num3};
    
12. 
    
13. for(int i = 0;i < 3 ;i++){
    
14. 
    
15.     printf("%d\n",*pArr[i]);  //除了这个方法还有吗?
    
16. 
    
17. 
    
18. /*   
    
19.     pArr  数组名 : 指向的第一个元素的地址 :  那么问题来了  是不是就是&num1的 ?  肯定不是
    
20. 
    
21.     正确的是 :
    
22.         pArr  数组名 : 指向的第一个元素的地址 : &pArr[0]   
    
23. 
    
24.         *pArr  ---->  * &pArr[0] ---> pArr[0]  --->  &num1
    
25. 
    
26.         **pArr  ---->   * &num1  --->  num1
    
27. 
    
28. */
    
29. 
    
30.         printf("%d\n",**(pArr+i));
    
31. 
    
32.         //   *pArr[i] == **(pArr+i)
    
33. 
    
34. 
    
35. }

复制代码

二维数组指针

what : 指向二维数组的指针

1. int arr[2][3] = {1,2,3,4,5,6};
   
2. 
   
3. int (*pa)[3] = arr;
   
4. 
   
5. for(int i = 0 ; i < 2 ; i++){
   
6. 
   
7.     for(int j = 0 ; j < 3 ; j++){
   
8. 
   
9. 
   
10.         //直接遍历 :  下标法遍历  /  数组名法遍历
    
11. 
    
12.         printf("%d",arr[i][j]);
    
13. 
    
14.         printf("%d",*(*(arr+i)+j));
    
15. 
    
16.         //间接遍历 :   二维数组指针遍历
    
17.          printf("%d",*(*(pa+i)+j));
    
18. 
    
19.     }
    
20. 
    
21. }

复制代码

指针数组进阶

1. //二维数组
   
2. int arr[2][3] = {1,2,3,4,5,6};
   
3. 
   
4. //指针数组
   
5. int *pArr[2] = {arr[0],arr[1]};
   
6. 
   
7. 
   
8. //  使用二维数组直接遍历
   
9. for(int i = 0 ; i < 2 ; i++){
   
10. 
    
11.     for(int j = 0; j < 3 ; j++){
    
12. 
    
13.         printf("%d\t",arr[i][j]);
    
14. 
    
15. 
    
16.     }
    
17. 
    
18.     printf("\n");
    
19. 
    
20. }
    
21. 
    
22. //   使用指针数组间接遍历
    
23. 
    
24. for(int i = 0;i < 2;i++){
    
25. 
    
26.     for(int j = 0 ; j< 3 ; j++){
    
27. 
    
28.         printf("%d\n",*(pArr[i]+j);
    
29. 
    
30.         //   pArr[i] ---> arr[i]
    
31.         //   pArr[i]+j  --->  arr[i]+j
    
32.         //   *(pArr[i]+j) ---->  *(arr[i]+j)  --->  arr[i][j]
    
33. 
    
34.         //  pArr  --->   &pArr[0]
    
35.         //   *(pArr+i)  --->   pArr[i]
    
36. 
    
37.     }
    
38. 
    
39.         //   *(pArr[i]+j)  ==  *(*(pArr+i)+j)
    
40. 
    
41. }

复制代码

指针与函数的关系

• 指针变量作为函数的参数
  

1. 使用一个函数交换两个变量的值
   
2. 
   
3. void changeNum(int *pNum1,int *pNum2){
   
4. 
   
5.     int temp = *pNum1;
   
6. 
   
7.     *pNum1 = *pnum2;
   
8. 
   
9.     *pNum2 = temp;
   
10. 
    
11. }
    
12. 
    
13. 
    
14. int main(){
    
15. 
    
16.     int num1 = 10 , num2 = 20;
    
17. 
    
18.     changeNum(&num1,&num2);
    
19. 
    
20.     //  此刻 , 你再打印num1 , num2 的值 , 看看是否有被改变 ? 答案是肯定的
    
21. 
    
22.     return 0;
    
23. 
    
24. }

复制代码

• 这就是指针作为函数的参数的体现
  

指针函数

• 指针函数 : 这是一个函数 , 返回值是指针(地址) 的函数
  

1. #include <stdio.h>
   
2. 
   
3. int *getArr(){
   
4. 
   
5.     int arr[5] = {1,2,3,4,5};
   
6. 
   
7. 
   
8.     return arr;
   
9. }
   
10. 
    
11. 
    
12. int main(int argc, const char * argv[]) {
    
13. 
    
14.     int *p = getArr();
    
15. 
    
16.     for (int i = 0; i < 5; i++) {
    
17. 
    
18.         printf("%d\n",*(p+i));
    
19. 
    
20.     }
    
21. 
    
22.     return 0;
    
23. }
    
24. 
    
25. 大家觉得此处能正常输出吗 ? 答案是否定的
    
26. 
    
27. int arr[5] ; 这个是一个局部变量 , 作用域结束后 , 会被释放 , 所以我们保存此地址 , 是没有意义的 , 地址对应的内容已经被释放了

复制代码

• 如何解决 :
  

我这里有2个解决方案 :

方法一 :

1. 1)
   
2. int arr[5] = {1,2,3,4,5};这个地方   加  static修饰
   
3. static int arr[5] = {1,2,3,4,5}; 这样 , 此数组就是静态区的, 也就是全局区 , 生命周期会延长至程序结束.

复制代码

方法二 :

1. 2)   使用malloc方式 , 创建堆区的动态内存空间   
   
2. int *p = (int *)malloc(sizeof(int)*4);
   
3. *(p) = 1;
   
4. *(p+1) = 2;
   
5. *(p+2) = 3;
   
6. *(p+3) = 4;
   
7. *(p+4) = 5;
   
8. 
   
9. 使用此方法别忘了用完以后使用free()函数手动销毁堆区申请的空间欧

复制代码

函数指针

• 函数指针 What : 这到底是怎么鬼 ? 指向函数的指针 , 是一个指针
  

这个跟以后我们学习OC中的block有关联 , 我们要先尽量理解一下

先带大家回忆一下函数 :

• 无参无返回值函数
• 有参无返回值函数
• 无参有返回值函数
• 有参有返回值函数
  

无参无返回值函数 :需求 : 打印一行星星

1. #include <stdio.h>
   
2. 
   
3. void printf_Star(){
   
4. 
   
5.     printf("******\n");
   
6. 
   
7. }
   
8. 
   
9. int main(int argc, const char * argv[]) {
   
10. 
    
11.     //定义函数指针
    
12.     //先定义 , 后赋值
    
13.     void (*p)();
    
14. 
    
15.     //赋值 此处一定是函数名
    
16.     p = printf_Star;
    
17. 
    
18.     //使用函数指针间接调用函数
    
19.     p();
    
20. 
    
21.     return 0;
    
22. }
    
23. 
    
24. 输出结果 : ******

复制代码

有参无返回值函数 :需求 : 打印3行星星

1. void printf_Star(int n){
   
2. 
   
3.     for (int i = 0; i < n; i++) {
   
4. 
   
5.         printf("******\n");
   
6. 
   
7.     }
   
8. 
   
9. }
   
10. 
    
11. int main(int argc, const char * argv[]) {
    
12. 
    
13.     //定义函数指针
    
14.     //定义的同时初始化    此处一定是函数名
    
15.     void (*p)(int) = printf_Star;
    
16. 
    
17.     //使用函数指针间接调用函数
    
18.     p(3);
    
19. 
    
20.     return 0;
    
21. }
    
22. 
    
23. 输出结果 :
    
24. ******
    
25. ******
    
26. ******

复制代码

无参有返回值函数 :需求 : 返回一个1000以内的随机数

1. #include <stdio.h>
   
2. #include <stdlib.h>
   
3. 
   
4. int getRandNum(){
   
5. 
   
6.     int randNum = arc4random_uniform(1000);
   
7. 
   
8.     return randNum;
   
9. }
   
10. 
    
11. int main(int argc, const char * argv[]) {
    
12. 
    
13.     //定义函数指针
    
14.     //定义的同时初始化    此处一定是函数名
    
15.     int (*p)() = getRandNum;
    
16. 
    
17.     //使用函数指针间接调用函数
    
18.     printf("随机数 : %d\n",p());
    
19. 
    
20.     return 0;
    
21. }

复制代码

有参数有返回值函数 :需求 : 传2个值, 返回它们的商

1. float division(int num1,int num2){
   
2. 
   
3.     //   int / int 得到的还是int  所以需要强制类型装换
   
4.     return num1 / (float)num2;
   
5. }
   
6. 
   
7. int main(int argc, const char * argv[]) {
   
8. 
   
9.     //定义函数指针
   
10.     //定义的同时初始化    此处一定是函数名
    
11.     float (*p)(int num1,int num2) = division;
    
12. 
    
13.     //使用函数指针间接调用函数
    
14.     printf("商为 : %.2f\n",p(67,3));
    
15. 
    
16.     return 0;
    
17. }

复制代码

指针与字符串在讲这个指针与字符串之前 , 大家要先了解一下内存的5大区域 :

• 栈区
• 堆区
• 全局区(静态区) 又称之为静态区 , 其中已经初始化的全局(静态)变量在数据段(数据区) , 未初始化的全局(静态)变量在BSS段
• 常量区
• 代码区
  

当然内存的区域远不止这么简单 , 比我们认知的复杂的多 , 所以C语言内存的5大区域也可能有不同说法 , 但是都大同小异 , 但是要确保准确性

验证

1. #include <stdio.h>
   
2. #include <stdlib.h>
   
3. 
   
4. //  全局变量  在全局区
   
5. int a = 1;
   
6. 
   
7. int main(int argc, const char * argv[]) {
   
8. 
   
9.     //局部变量在栈区
   
10.     int num = 10;
    
11. 
    
12.     //malloc函数申请动态内存空间,堆区
    
13.     int *p = malloc(sizeof(int)*4);
    
14. 
    
15.     //static修饰的局部变量为静态变量 , 在静态区(全局区)
    
16.     static int b = 10;
    
17. 
    
18.     // "apple"在常量区
    
19.     char *str = "apple";
    
20. 
    
21. 
    
22.     printf("栈区: %p\n堆区: %p\n静态区:%p\n常量区:%p\n全局区:%p\n代码区:暂不作验证,OC阶段讲解\n",&num,p,&b,str,&a);
    
23. 
    
24.     return 0;
    
25. }
    
26. 
    
27. 栈区: 0x7fff5fbff7cc
    
28. 堆区: 0x1001015b0
    
29. 静态区:0x100001024
    
30. 常量区:0x100000f44
    
31. 全局区:0x100001020
    
32. 代码区:暂不作验证,OC阶段讲解
    
33. 
    
34. 栈区一般都是0x7fff开头的 , 堆区 : 0x100....   后6位有值 , 之前2个0
    
35. 大家注意看静态区和全局区  尾号 : 1024  --->  1020  差4个字节 , 其实静态区和全局区是一个区
    
36. 全局区一般都是 0x10000xxxx   后四位有值 , 之前是4个0
    
37. 常量区 : 一般都是0x100000xxx  后三位有值  , 之前都是5个0

复制代码

学习指针与字符串就3个问题 :

• 定义字符串方式
  

1. 1. 用字符数组的方式
   
2.     char str[6] = "apple";
   
3. 
   
4. 
   
5. 2. 用指针的方式
   
6.     char *str = "apple";

复制代码

• 分别在哪个区域
  

1. 前者保存在栈区 , 数组元素为6个 , 字符串长度为5
   
2. 后者保存在常量区 , 指针变量str指向了常量区的"apple"的地址,字符串长度为5

复制代码

• 值得注意的问题
• 前者字符串内容可改 , 比如说 str[3] = 'p' , 是可以的 , 后者 *(str+3) = 'p' , 是错误的 , 因为常量区的内容是可读不可写的 , 不可改
  

1.    char str[5] = "apple";
   
2. 
   
3.     str[4] = 'p';
   
4. 
   
5.     printf("%s\n",str);   // 这是没问题的
   
6. 
   
7. ----------------------------------------
   
8. 
   
9.     char *str = "apple";
   
10. 
    
11.     *(str+4) = 'p';
    
12. 
    
13.     printf("%s\n",str);  //  这个是错误的

复制代码

• 从键盘输入问题 :
  

1. char str[5];
   
2. 
   
3. scanf("%s",str);
   
4. 
   
5. 此处正确没问题
   
6. 
   
7. ----------------------------------
   
8. 
   
9. char *str;
   
10. 
    
11. scanf("%s",str);
    
12. 
    
13. 此处错误 , 野指针错误 , str没有任何指向
    
14. 
    
15. ------------------------------------
    
16. 解决办法 :
    
17. char *str = (char *)malloc(sizeif(char)*10);
    
18. 
    
19. scanf("%s",str);
    
20. 
    
21. 此处正确没问题

复制代码

const与指针搭配的用法

• const与变量搭配使用
  

1. const int num = 1;
   
2. 
   
3. num++;     //错误
   
4. 
   
5. num = 20;  //错误
   
6. 
   
7. Cannot assign to variable 'num' with const-qualified type 'const int'

复制代码

• 总结 : const修饰的变量 , 可读不可改
  

• const与指针变量搭配使用
  

const 在 * 前面 : 指针的指向可以变 , 地址对应的值不可变

1. int num = 10;
   
2. 
   
3. const int *p = #
   
4. int const *p = #
   
5. 
   
6. 指针的指向可以变 , 地址对应的值不可变
   
7. 
   
8. p = &num2; //这个可以
   
9. 
   
10. 但是 *p = 30;  // 这个错误  Read-only variable is not assignable

复制代码

const 在 * 后面 : 指针的指向不可以变 , 地址对应的值可变

1. int num = 10;
   
2. 
   
3. int * const p = #
   
4. 
   
5. 指针的指向不可以变 , 地址对应的值可变
   
6. 
   
7. p = &num2 ;  //这个错误  Read-only variable is not assignable
   
8. 
   
9. *p = 10;   //  这个可以
   
10. 理解:  1.
    
11. const int *p;    常量指针   指向常量的指针   所以值不能变,指向可变
    
12. int const *p;
    
13. 
    
14. int * const p;   指针常量   这是个常量      指向不可变,值可变

复制代码

最后 , 如果还是没法懂 , 就强行记忆 :

• const 在 * 的左侧 指向可变,值不能变
• const 在 * 的右侧 指向不可变 值可变
• const 在 * 的两侧 指向和值都不可以变
  

结构体与指针

What : 指向结构体变量地址的指针

回顾结构体 : 区分结构体类型 , 结构体变量 , 结构体别名

结构体类型

1. //结构体类型 :  这个仅仅只是定义的类型
   
2. struct Car{
   
3.     int lunzi; //轮子
   
4.     char *pp;  //品牌
   
5. };

复制代码

结构体变量

1. //结构体类型 :  这个仅仅只是定义的类型
   
2. struct Car{
   
3.     int lunzi; //轮子
   
4.     char *pp;  //品牌
   
5. }car;
   
6. 
   
7. 变量名为 : car

复制代码

结构体类型起别名

1. typedef struct Car{
   
2.     int lunzi; //轮子
   
3.     char *pp;  //品牌
   
4. }iCar;
   
5. 
   
6. 对结构体类型 :struct Car 起了别名: iCar

复制代码

到此我们就要用指针给结构体结合使用了
只有结构体指针才有的特殊用法 : p->结构体的成员变量   

1.   struct Car{
   
2. 
   
3.         int lunzi;
   
4. 
   
5.         char *pp;
   
6. 
   
7.     }car;
   
8. 
   
9.     struct Car *p = &car;
   
10. 
    
11.     p->lunzi = 10;
    
12. 
    
13.     p->pp = "BMW";
    
14. 
    
15.     printf("lunzi = %d,pp = %s\n",p->lunzi,p->pp);
    
16.     //   p->lunzi   ==   (*p).linzi

复制代码

游客，如果您要查看本帖隐藏内容请回复

it is a good source

没看到啊，奇怪

nane ,怎么看不到了

看看这个，写的好详细

指针感觉好难的样子

好!!支持!感谢分享!

老师太给力了!!

不错,学习了

这个相当给力啊

大神请收下我的膝盖

好好好好

haoduoya .

论坛真是学习资料宝库啊，之前，没有好好利用。

这块正好不会呢,来的太及时了.我去看去啦

圣彬老师大赞!!!我们会努力~

强强强强强强强强强强强强强强强!

很好很轻大，给你100个赞！

排队报名中

签个到,加油加油

签个到,打个卡,洗洗码代码~~~