devbox
小桥流水78
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

指针详解（四）

作者：小桥流水78 | 2024-08-22 19:30:24

赞

踩

指针详解（四）

目录

1. 字符指针变量

2. 数组指针变量

3. 数组指针变初始化

4. 二维数组传参的本质

5. 函数指针变量

1）函数指针变量的创建

2）函数指针变量的使用

3）代码解析

6. typedef关键字

7.  函数指针数组

8. 转移表

1. 字符指针变量
  1. int main()
  2. {
  3.     char ch = 'w';
  4.     char *pc = &ch;//一般使用方式
  5.     *pc = 'w';
  6.     return 0;
  7. }
  8.  
  9. int main()
  10. {
  11.     const char* pstr = "hello bit.";//这里是把一个字符串放到pstr指针变量里了吗？
  12.     printf("%s\n", pstr);
  13.     return 0;
  14. }

代码const char* pstr = "hello bit."; 不是把字符串 hello bit 放到字符指针 pstr 里，而是把字符串hello bit.的首字符的地址放到了pstr中

我们通过一道例题加深理解

  1. #include <stdio.h>
  2.  
  3. int main()
  4. {
  5.     char str1[] = "hello bit.";
  6.     char str2[] = "hello bit.";
  7.     const char *str3 = "hello bit.";
  8.     const char *str4 = "hello bit.";
  9.  
  10.     if(str1 ==str2)
  11.         printf("str1 and str2 are same\n");
  12.     else
  13.         printf("str1 and str2 are not same\n");
  14.  
  15.     if(str3 ==str4)
  16.         printf("str3 and str4 are same\n");
  17.     else
  18.         printf("str3 and str4 are not same\n");
  19.     return 0;
  20. }

  • str1 和 str2 在内存中分别存储了字符串"hello bit." 所以地址不同
  • str3和 str4指向 const char 的指针，它们都被初始化为指向字符串字面量 "hello bit." 的地址。在C语言中，相同的字符串字面量（在相同的编译单元内）会被存储在内存中的同一个位置，以节省空间。因此，str3和 str4 实际上指向的是同一个内存地址，输出 "str3 and str4 are same"。

 

2. 数组指针变量
  • 整形指针变量： int * pint; 存放的是整形变量的地址，能够指向整形数据的指针
  • 浮点型指针变量： float * pf; 存放浮点型变量的地址，能够指向浮点型数据的指针

所以数组指针变量：存放的应该是数组的地址，能够指向数组的指针变量

  1. int *p1[10];
  2. int (*p2)[10];
  • int *p1[10] 定义了一个名为p1的数组，该数组包含10个元素，每个元素都是一个指向int的指针（int *）。换句话说，p1是一个数组，可以存储10个地址，每个地址都指向一个 int 类型的值。这个数组可以用来存储指向不同 int 变量的指针，或者指向 int 数组首元素的指针。
  • int (*p2)[10] 定义了一个名为p2的指针，该指针指向一个包含10个 int 的数组（即 int [10]）这意味着p2存储的是一个地址，这个地址指向的是一个数组，该数组包含10个int类型的元素

数组指针变量:

int (*p)[10];

 

3. 数组指针变初始化
  1. int arr[10] = {0};
  2. &arr;//得到的就是数组的地址
  3.  
  4. int(*p)[10] = &arr;//数组指针变量

  1. int  (*p)  [10] = &arr;// &arr 和 p 的类型相同
  2.  |    |     |
  3.  |    |     |
  4.  |    |     p指向数组的元素个数
  5.  |    p是数组指针变量名
  6. p指向的数组的元素类型

 

4. 二维数组传参的本质
  1. #include <stdio.h>
  2.  
  3. void test(int a[3][5], int r, int c)  //二维数组的传参给一个函数
  4. {
  5.     int i = 0;
  6.     int j = 0;
  7.     for(i=0; i<r; i++)
  8.     {
  9.         for(j=0; j<c; j++)
  10.         {
  11.             printf("%d ", a[i][j]);
  12.         }
  13.         printf("\n");
  14.     }
  15. }
  16.  
  17. int main()
  18. {
  19.     int arr[3][5] = {{1,2,3,4,5}, {2,3,4,5,6},{3,4,5,6,7}};
  20.     test(arr, 3, 5);
  21.     return 0;
  22. }

实参是二维数组，形参也写成二维数组的形式，其实，二维数组起始可以看做是每个元素是一维数组的数组，也就是二维数组的每个元素是一个一维数组。那么二维数组的首元素就是第一行，是个一维数组

根据数组名是数组首元素的地址，二维数组的数组名表示的就是第一行的地址，是一维数组的地址。根据上面的例子，第一行的一维数组的类型就是int [5] ，所以第一行的地址的类型就是数组指针类型int(*)[5] 。所以二维数组传参本质上是传递的是第一行这个一维数组的地址，那么形参也可以写成指针形式

  1. #include <stdio.h>
  2.  
  3. void test(int (*p)[5], int r, int c)
  4. {
  5.     int i = 0;
  6.     int j = 0;
  7.     for(i=0; i<r; i++)
  8.     {
  9.         for(j=0; j<c; j++)
  10.         {
  11.             printf("%d ", *(*(p+i)+j));
  12.         }
  13.     printf("\n");
  14.     }
  15. }
  16.  
  17. int main()
  18. {
  19.     int arr[3][5] = {{1,2,3,4,5}, {2,3,4,5,6},{3,4,5,6,7}};
  20.     test(arr, 3, 5);
  21.     return 0;
  22. }

总结：二维数组传参，形参的部分可以写成数组，也可以写成指针形式

 

5. 函数指针变量

函数指针变量应该是用来存放函数地址的，并通过地址能够调用函数

  1. #include <stdio.h>
  2.  
  3. void test()
  4. {
  5.     printf("hehe\n");
  6. }
  7.  
  8. int main()
  9. {
  10.     printf("test: %p\n", test);//函数是否有地址
  11.     printf("&test: %p\n", &test);
  12.     return 0;
  13. }

 

函数有地址并且 test 和 &test 相同

1）函数指针变量的创建

函数指针类型解析：

  1. int     (*pf3)   (int x, int y)
  2. |         |       ------------
  3. |         |            |
  4. |         |           pf3指向函数的参数类型和个数的交代
  5. |         函数指针变量名
  6. pf3指向函数的返回类型
  7.  
  8. int (*) (int x, int y) //pf3函数指针变量的类型
  1. void test()
  2. {
  3.     printf("hehe\n");
  4. }
  5.  
  6. void (*pf1)() = &test;
  7. void (*pf2)()= test;
  8.  
  9. int Add(int x, int y)
  10. {
  11.     return x+y;
  12. }
  13.  
  14. int(*pf3)(int, int) = Add;
  15. int(*pf3)(int x, int y) = &Add;//x和y写上或者省略都是可以的

 

2）函数指针变量的使用
  1. //通过函数指针调用指针指向的函数
  2. #include <stdio.h>
  3.  
  4. int Add(int x, int y)
  5. {
  6.     return x+y;
  7. }
  8.  
  9. int main()
  10. {
  11.     int(*pf3)(int, int) = Add;
  12.     printf("%d\n", (*pf3)(2, 3));//5
  13.     printf("%d\n", pf3(3, 5));//8
  14.     return 0;
  15. }

 

3）代码解析
  1. //代码1
  2. (*(void (*)())0)();
  3.  
  4.  
  5.         (          )0//强制类型转换
  6.         (void (*)())0//函数指针 返回值为void 参数为void
  7. (      *(void (*)())0     )
  8. (      *(void (*)())0     ) ();//调用地址为 0 的函数
  13. //代码2
  14. void (*signal(int , void(*)(int)))(int);
  15.  
  16.                     void(*)(int)//函数指针 返回值为void 参数为int
  17.        signal(int , void(*)(int))//signal 函数返回值为void 参数为int
  18. void (*signal)(int);

 

6. typedef关键字

typedef 是用来类型重命名

  1. //将unsigned int 重命名为uint
  2. typedef unsigned int uint;
  3.  
  4. //将int* 重命名为ptr_t
  5. typedef int* ptr_t;
  6.  
  7. //数组指针类型int(*)[5]重命名为parr_t
  8. typedef int(*parr_t)[5]; //新的类型名必须在*的右边
  9.  
  10. //void(*)(int) 类型重命名为pf_t
  11. typedef void(*pfun_t)(int);//新的类型名必须在*的右边

简化代码2，可以这样写

  1. typedef void(*pfun_t)(int);
  2.  
  3. pfun_t signal(int, pfun_t);

 

7.  函数指针数组

函数的地址存到一个数组

int (*parr1[3])();

int (*)() 类型的函数指针

 

8. 转移表

计算器的一般实现:

  1. #include <stdio.h>
  2. int add(int a, int b)
  3. {
  4.     return a + b;
  5. }
  6.  
  7. int sub(int a, int b)
  8. {
  9.     return a - b;
  10. }
  11.  
  12. int mul(int a, int b)
  13. {
  14.     return a * b;
  15. }
  16.  
  17. int div(int a, int b)
  18. {
  19.     return a / b;
  20. }
  21.  
  22. int main()
  23. {
  24.     int x, y;
  25.     int input = 1;
  26.     int ret = 0;
  27.     do
  28.     {
  29.         printf("*************************\n");
  30.         printf(" 1:add 2:sub \n");
  31.         printf(" 3:mul 4:div \n");
  32.         printf(" 0:exit \n");
  33.         printf("*************************\n");
  34.         printf("请选择：");
  35.         scanf("%d", &input);
  36.         switch (input)
  37.         {
  38.         case 1:
  39.             printf("输入操作数：");
  40.             scanf("%d %d", &x, &y);
  41.             ret = add(x, y);
  42.             printf("ret = %d\n", ret);
  43.             break;
  44.         case 2:
  45.             printf("输入操作数：");
  46.             scanf("%d %d", &x, &y);
  47.             ret = sub(x, y);
  48.             printf("ret = %d\n", ret);
  49.             break;
  50.         case 3:
  51.             printf("输入操作数：");
  52.             scanf("%d %d", &x, &y);
  53.             ret = mul(x, y);
  54.             printf("ret = %d\n", ret);
  55.             break;
  56.         case 4:
  57.             printf("输入操作数：");
  58.             scanf("%d %d", &x, &y);
  59.             ret = div(x, y);
  60.             printf("ret = %d\n", ret);
  61.             break;
  62.         case 0:
  63.             printf("退出程序\n");
  64.             break;
  65.         default:
  66.             printf("选择错误\n");
  67.             break;
  68.         }
  69.     } while (input);
  70.     return 0;
  71. }

通过函数指针数组的实现后:

  1. #include <stdio.h>
  2.  
  3. int add(int a, int b)
  4. {
  5.     return a + b;
  6. }
  7.  
  8. int sub(int a, int b)
  9. {
  10.     return a - b;
  11. }
  12.  
  13. int mul(int a, int b)
  14. {
  15.     return a*b;
  16. }
  17.  
  18. int div(int a, int b)
  19. {
  20.     return a / b;
  21. }
  22.  
  23. int main()
  24. {
  25.     int x, y;
  26.     int input = 1;
  27.     int ret = 0;
  28.     int(*p[5])(int x, int y) = { 0, add, sub, mul, div }; //转移表
  29.     do
  30.     {
  31.         printf("*************************\n");
  32.         printf(" 1:add 2:sub \n");
  33.         printf(" 3:mul 4:div \n");
  34.         printf(" 0:exit \n");
  35.         printf("*************************\n");
  36.         printf( "请选择：" );
  37.         scanf("%d", &input);
  38.         if ((input <= 4 && input >= 1))
  39.         {
  40.             printf( "输入操作数：" );
  41.             scanf( "%d %d", &x, &y);
  42.             ret = (*p[input])(x, y);
  43.             printf( "ret = %d\n", ret);
  44.         }
  45.         else if(input == 0)
  46.         {
  47.             printf("退出计算器\n");
  48.         }
  49.         else
  50.         {
  51.             printf( "输入有误\n" );
  52.         }
  53.     }while (input);
  54.     return 0;
  55. }

 

谢谢观看

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/小桥流水78/article/detail/1017697
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号