• C语言指针精简版（三）

    目录

    字符指针变量

    剑指offer中经典题：

    数组指针变量

    ⼆维数组传参的本质

    函数指针变量

    typedef关键字

    函数指针数组

    什么是函数指针数组？

    为什么要使用函数指针数组？

    转移表

    计算器的⼀般实现：

    使用函数指针实现： 

    字符指针变量

    我们先看一行代码： 

    const char* pstr = "hello bit.";//这⾥是把⼀个字符串放到pstr指针变量⾥了吗？

    事实上它的本质是把⼀个字符串常量hello bit的⾸字符 h 的地址存放到指针变量 pstr 中。

    剑指offer中经典题：

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

    会出现以上的结果是因为： C/C++会把常量字符串存储到单独的⼀个内存区域，当⼏个指针指向同⼀个字符串的时候，他们实际会指向同⼀块内存。但是⽤相同的常量字符串去初始化不同的数组的时候就会开辟出不同的内存块。所以str1和str2不同，str3和str4相同。

    数组指针变量

    学习数组指针变量之前请先记住以下两点：

    数组指针  !=  指针数组

    指针数组是存放指针的数组，数组指针是存放整个数组的地址，而非数组首元素地址

    格式：数组类型（*数组指针变量名）[数组元素个数] = &数组名

    ！！！一定要加上（），否则就会变成int* p[10]，这是指针数组而不是数组指针！！！

    作用：存放整个数组的地址

    实例：

    Int arr[10];

    Int(*p)[10] = &arr;

            加上()是因为[]的优先级要⾼于*号，所以必须加上（）来保证p先和*结合形成（*p）,此时p为数组指针变量，指向的是一个元素个数为10个的整型数组

    1. #include 
    2. int main()
    3. {
    4.     int arr[10] = { 0 };
    5.     int(*p)[10] = &arr;
    6.     return 0;
    7. }

    调试也能看到数组指针变量p存储了整型数组arr的地址，且二者的类型也是一样的......

    ⼆维数组传参的本质

    过去我们有⼀个⼆维数组的需要传参给⼀个函数的时候，我们是这样写的： 

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

    上述代码的写法是实参是⼆维数组，形参也写成⼆维数组的形式，那还有什么其他的写法吗？是否可以利用之前学过的数组指针变量的知识来写？

    关于第二种传参方式的书写思路如下：

    ①⼆维数组的⾸元素即第⼀⾏的⼀维数组

    ②由于数组名是数组⾸元素的地址，故⼆维数组的数组名表⽰的就是第一个⼀维数组首元素的地址

    ③我们用一个数组指针变量指向二维数组的数组名，这样就可以遍历二维数组中的每一个元素

    1. #include 
    2. void test(int (*p)[5], int r, int c)
    3. {
    4.  int i = 0;
    5.  int j = 0;
    6.  for(i=0; i
    7.  {
    8.      for(j=0; j
    9.      {
    10.          printf("%d ", *(*(p+i)+j));
    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. }

    结论：⼆维数组传参，形参的部分可以写成数组或指针的形式

    函数指针变量

    格式：函数类型（指针变量）（函数形参类型） =  函数名

    只需要写函数形参类型即可，不需要再写形参名

    我们先来看一段代码：

    1. #include 
    2. void test()
    3. {
    4. 	printf("hehe\n");
    5. }
    6. int main()
    7. {
    8. 	printf("test: %p\n", test);
    9. 	printf("&test: %p\n", &test);
    10. 	return 0;
    11. }

    通过上述代码我们可以发现：函数是有地址的，函数名就是函数的地址 

            与之前的数组指针变量类似，函数指针变量应该是⽤来存放函数地址的，后续可以通过地址来调⽤函数的：

    1. #include 
    2. int Add(int x, int y)
    3. {
    4. 	return x + y;
    5. }
    6. int main()
    7. {
    8. 	int(*pf3)(int, int) = Add;
    9. 	printf("%d\n", (*pf3)(2, 3));
    10. 	printf("%d\n", pf3(3, 5));
    11. 	return 0;
    12. }

    上述代码就是对函数指针变量的使用了......

    《C陷阱和缺陷》中有这样一段代码：

    Void (* signal(int ,void(*)(int) ) (int)

            首先我们可以理解的是signal是一个函数名，(int , void(*)(int))是signal函数的两个参数，一个是int型，另一个是函数指针类型，该函数指针类型指向的函数参数是int型，返回类型是void，signal(int,void(*)(int))就相当于对signal函数的声明，如果我们把这个函数声明的整体假设为m，那么这行代码就会变成void(* m)(int)，*m就是一个新的函数指针，该函数指针指向的函数参数是int型，返回的类型为void型。

    typedef关键字

    作用：类型重命名的，可以将复杂的类型简单化

    ⽐如，你觉得 unsigned int 写起来不⽅便，如果能写成 uint 就⽅便多了，那么我们可以使⽤：

    1. typedef unsigned int uint;
    2. //将unsigned int 重命名为uint

    同样的我们也可以将指针类型重命名，将 int* 重命名为 ptr_t ,这样写：

     Typedef  int* ptr_t;

    但是对于数组指针和函数指针稍微有点区别，⽐如我们有数组指针类型 int(*)[5] ,需要重命名为 parr_t ，那可以这样写：

    typedef int(*parr_t)[5]; //新的类型名必须在*的右边

    函数指针类型的重命名也是⼀样的，⽐如将 void(*)(int) 类型重命名为 pf_t ,就可以这样写：

    typedef void(*pfun_t)(int);//新的类型名必须在*的右边

    函数指针数组

    什么是函数指针数组？

    函数指针数组就是把多个函数的地址存放在一个数组中

    格式:返回类型（*数组名[函数个数]）（形参类型，形参类型） = （函数名，函数名）

    int （*parr1[3]）（int,int） = （Add,Sub）;

            其中，parr1 [3]表示一个有三个元素的数组，数组类型就是 int (*)(int,int) ，指向（int，int）返回值是int型的函数指针变量，数组元素为Add 和 Sub

    为什么要使用函数指针数组？

    当函数的返回值一样时为了简化代码可以将函数指针放在指向同一个指针类型的数组中，比如：

    1. #include 
    2. int Add(int x, int y)
    3. {
    4.         return x + y;
    5. }
    6.  
    7. int Sub(int x, int y)
    8. {
    9.         return x - y;
    10. }
    11.  
    12. int main()
    13. {        
    14.         int* arr[10];
    15.         int (*pArr[4])(int, int) = { Add,Sub };
    16.         return 0;
    17. }

    转移表

    计算器的⼀般实现：

    1. #include 
    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.  
    71. return 0;
    72.  
    73. }

    使用函数指针实现： 

    1. //使⽤函数指针数组的实现：
    2. #include 
    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[])(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. }

    ~over~
     

  • 相关阅读:
    cicids2017数据集训练
    github在线编程
    让你眼前一亮的算法优化技巧总结！！！
    [算法学习笔记](超全)概率与期望
    PMP模拟题 | 每日一练，快速提分
    【亲测】阿里云ECS搭建《幻兽帕鲁》联机服务器
    mac系统安装docker desktop
    2023华为OD统一考试（B卷）题库清单（持续收录中）以及考点说明
    修改树莓派4b密码
    JSON（详解）
  • 原文地址：https://blog.csdn.net/m0_73975164/article/details/133952518