0
0

C语言：指针（超深度讲解）

学习目标：

**1. 字符指针 **

**2. 指针数组 **

3. 数组指针

**4. 数组传参和指针传参 **

**5. 函数指针 **

**6. 函数指针数组 **

**7. 指向函数指针数组的指针 **

**8. 回调函数 **

指针：

指针可以理解为：

字符指针：

定义：字符指针 char*。

字符指针的使用：

//使用1

int main()

{

char ch = 'w';

char *pc = &ch;

*pc = 'w';

return 0;

}

//使用2

int main()

{

const char* pstr = "hello bit.";//把一个常量字符串的首字符 h 的地址存放到指针变量 pstr 中

printf("%s\n", pstr);

return 0;

}

练习：

指针数组：

概念：指针数组是一个存放指针的数组。

int* arr1[10]; //整形指针的数组

char *arr2[4]; //一级字符指针的数组

char **arr3[5];//二级字符指针的数组

实现模拟二维数组：

数组指针：

概念：能够指向数组的指针。(可以理解为先与指针结合再与数组结合)

  1. **  int**** (*p)[10]; **

//解释：p先和*结合，说明p是一个指针变量，然后指着指向的是一个大小为10个整型的数组。所以p是一个指针，指 向一个数组，叫数组指针。

//这里要注意：[ ]的优先级要高于号的，所以必须加上（）来保证p先和结合。

值得注意的是：

**数组名的理解:数组名是数组首元素的地址
有2个例外：

  1. sizeof(数组名)，这里的数组名不是数组首元素的地址，数组名表示整个数组，sizeof(数组名)计算的是整个数组的大小，单位是字节
  2. &数组名，这里的数组名表示整个数组， &数组名取出的是整个数组的地址
    除此之外，所有的地方的数组名都是数组首元素的地址**

数组指针一般用于二维数组：

数组的传参：

  1.     二维数组的**每一行可以理解为二维数组的一个元素**，**每一行又是一个一维数组**，所以二维数组其实是一维数组的数组。
  3.     二维数组的数组名，也是数组名，数组名就是数组首元素的地址。

arr----首元素的地址；

arr----第一行的地址；
arr----一维数组的地址即数组的地址。

一维数组传参：

**二维数组的传参： **

总结:二维数组传参，函数形参的设计只能省略第一个[ ]的数字因为对一个二维数组，可以不知道有多少行，但是必须知道一行多少元素这样才方便运算。

指针的传参：

一级指针传参：

二级指针的传参：

函数指针：

概念：指向函数的指针。

** int (*pf)(int, int) **= &Add;

  1. //pf是函数指针变量
  2.  //int (*)(int, int) 是函数指针类型
  1. void test(char* pc, int arr[10])
  2. {
  4. }
  5. int main()
  6. {
  7.     void (*pf)(char *, int [10]) = test;
  9.     return 0;
  10. }

**由上图可知： **

  1.     函数名是函数的地址；
  3.     &函数名也是函数的地址。

阅读两段有趣的代码：

**//代码1 **

((void ()())0)();

解析：调用0地址处的函数 

  1.          1. 将0强制类型转换为void (*)()  类型的函数指针 
  3.          2. 调用0地址处的这个函数

**//代码2 **

void (signal(int , void()(int)))(int);

解析：

  1. 1.signal 是一个函数声明
  2.  2.signal 函数有2个参数，第一个参数的类型是int，第二个参数的类型是 void(*)(int) 函数指针类型
  3.  3.该函数指针指向的函数有一个int类型的参数，返回类型是void
  4.  4.signal 函数的返回类型也是void(*)(int) 函数指针类型,该函数指针指向的函数有一个int类型的参数，返回类型是void

类型重定义：typedef

  1. //类型重定义1
  2. typedef unsigned int uint;
  3. typedef int* ptr_t;
  5. int main()
  6. {
  7.     uint u1;
  8.     ptr_t p1;
  9.     int* p2;
  10.     return 0;
  11. }
  13. //类型重定义2
  14. typedef int(*parr_t)[10];
  15. typedef int (*pf_t)(int, int) ;
  17. int main()
  18. {
  19.     typedef void(*pf_t)(int);
  20.     pf_t signal(int, pf_t);
  21.     //上方两句将下方的语句简化，效果相同
  22.     void (* signal(int, void(*)(int) ) )(int);
  24.     return 0;
  25. }

函数指针数组：

定义：int (*parr1[10])(); 每个元素都是函数指针类型。

用途：转移表。

函数指针数组的使用：

  1. #include <stdio.h>
  2. #include <string.h>
  4. int Add(int x, int y)
  5. {
  6.     return x + y;
  7. }
  9. int Sub(int x, int y)
  10. {
  11.     return x - y;
  12. }
  14. int Mul(int x, int y)
  15. {
  16.     return x * y;
  17. }
  19. int Div(int x, int y)
  20. {
  21.     return x / y;
  22. }
  24. void menu()
  25. {
  26.     printf("***************************\n");
  27.     printf("*****  1.add  2.sub  ******\n");
  28.     printf("*****  3.mul  4.div  ******\n");
  29.     printf("*****  0.exit        ******\n");
  30.     printf("***************************\n");
  31. }
  32. //实现int类型的加减乘除
  33. int main()
  34. {
  35.     int input = 0;
  36.     int x = 0;
  37.     int y = 0;
  38.     int ret = 0;
  39.     //函数指针数组的使用 - 转移表
  40.     int (* pfArr[5])(int, int) = {NULL, Add, Sub, Mul, Div};
  41.                                    0     1    2    3    4
  42.     do
  43.     {
  44.         menu();
  45.         printf("请选择:>");
  46.         scanf("%d", &input);
  47.         if (input >= 1 && input <= 4)
  48.         {
  49.             printf("请输入两个操作数:");
  50.             scanf("%d %d", &x, &y);
  51.             ret = pfArr[input](x, y);
  52.             printf("ret = %d\n", ret);
  53.         }
  54.         else if(input == 0)
  55.         {
  56.             printf("退出计算器\n");
  57.         }
  58.         else
  59.         {
  60.             printf("选择错误，重新选择\n");
  61.         }
  62.     } while (input);
  64.     return 0;
  65. }

指向函数指针数组的指针：

定义：

指向函数指针数组的指针是一个 指针 指针指向一个 数组 ，数组的元素都是 函数指针 ; （一般不直接写，通过函数指针一步一步变化得到，可以减少失误操作）

void (pf)(const char) = test; //pf是函数指针变量
void (pfArr[10])(const char); //pfArr是存放函数指针的数组
void ( (p) [10])(const char) = &pfArr;*//p指向函数指针数组的指针

回调函数：

概念：

  1.     回调函数就是一个**通过函数指针调用的函数**。如果你把函数的指针（地址）作为参数传递给另一个函数，当这个指针被用来调用其所指向的函数时，我们就说这是**回调函数**。回调函数不是由该函数的实现方直接调用，而是在特定的事件或条件发生时由另外的一方调用的，用于对该事件或条件进行响应。

//回调函数的使用

void Calc**(int (pf)(int, int))*
{
int x = 0;
int y = 0;
int ret = 0;
printf("请输入两个操作数:");
scanf("%d %d", &x, &y);
ret = pf(x, y);
printf("ret = %d\n", ret);
}

使用回调函数模拟实现qsort()函数：

base:指向要排序的数组的第一个对象的指针，转换为 .

  1. void*。

num:数组中由指向的元素个数。是无符号整型。

size:数组中每个元素的大小（以字节为单位），是无符号整型。

compar:指向比较两个元素的函数的指针，重复调用此函数以比较两个元素。

qsort()运用：

  1. #include <stdio.h>
  2. //qosrt函数的使用者得实现一个比较函数
  3. int int_cmp(const void * p1, const void * p2)
  4. {
  5.  return (*( int *)p1 - *(int *) p2);
  6. }
  7. int main()
  8. {
  9.  int arr[] = { 1, 3, 5, 7, 9, 2, 4, 6, 8, 0 };
  10.  int i = 0;
  11.  
  12.  qsort(arr, sizeof(arr) / sizeof(arr[0]), sizeof (int), int_cmp);
  13.  for (i = 0; i< sizeof(arr) / sizeof(arr[0]); i++)
  14.  {
  15.  printf( "%d ", arr[i]);
  16.  }
  17.  printf("\n");
  18.  return 0;
  19. }

排序int类型：

  1. #include <stdio.h>
  3. //比较int类型的比较函数
  4. int my_compare(const void* q1, const void* q2)
  5. {
  6.     return (*(int*)q1 - *(int*)q2);
  7. }
  8. //交换每一个字节的元素
  9. void Swap(char* b1, char* b2, int size)
  10. {
  11.     int i = 0;
  12.     for (i = 0; i < size; i++)
  13.     {
  14.         char tmp = *b1;
  15.         *b1 = *b2;
  16.         *b2 = tmp;
  17.         b1++;
  18.         b2++;
  19.     }
  20. }
  21. //模拟实现自己的qsort()函数
  22. void my_qsort(void* base, int num, int size, int (*my_compare)(const void* q1, const void* q2))
  23. {
  24.     int i = 0;
  25.     int j = 0;
  26.     for (i = 0; i < num - 1; i++)
  27.     {
  28.         for (j = 0; j < num - 1 - i; j++)
  29.         {
  30.             //从小到大排序
  31.             if (my_compare((char*)base+j*size,(char*)base+(j+1)*size) > 0)
  32.             {
  33.                 Swap((char*)base + j*size, (char*)base + (j + 1)*size, size);
  34.             }
  35.         }
  36.     }
  37. }
  39. int main()
  40. {
  41.     int arr[10] = { 2,4,6,7,8,3,1,0,9,5 };
  42.     int sz = sizeof(arr) / sizeof(arr[0]);
  43.     my_qsort(arr, sz, sizeof(arr[0]), my_compare);
  44.     return 0;
  45. }

排序结构体类型：

  1. #include <string.h>
  2. //创建学生结构体
  3. struct Stu
  4. {
  5.     char name[20];
  6.     int age;
  7. };
  8. //比较int类型的比较函数
  9. int my_compare_age(const void* q1, const void* q2)
  10. {
  11.     return ((struct Stu*)q1)->age - ((struct Stu*)q2)->age;
  12. }
  13. //比较int类型的比较函数
  14. int my_compare_name(const void* q1, const void* q2)
  15. {
  16.     return strcmp( ( (struct Stu*)q1 )->name ,( (struct Stu*)q2 )->name);
  17. }
  18. //交换每一个字节的元素
  19. void Swap(char* b1, char* b2, int size)
  20. {
  21.     int i = 0;
  22.     for (i = 0; i < size; i++)
  23.     {
  24.         char tmp = *b1;
  25.         *b1 = *b2;
  26.         *b2 = tmp;
  27.         b1++;
  28.         b2++;
  29.     }
  30. }
  31. //模拟实现自己的qsort()函数
  32. void my_qsort(void* base, int num, int size, int (*my_compare)(const void* q1, const void* q2))
  33. {
  34.     int i = 0;
  35.     int j = 0;
  36.     //趟数
  37.     for (i = 0; i < num - 1; i++)
  38.     {
  39.         //一趟内部比较的对数
  40.         for (j = 0; j < num - 1 - i; j++)
  41.         {
  42.             //从小到大排序
  43.             if (my_compare((char*)base + j * size, (char*)base + (j + 1) * size) > 0)
  44.             {
  45.                 //交换
  46.                 Swap((char*)base + j * size, (char*)base + (j + 1) * size, size);
  47.             }
  48.         }
  49.     }
  50. }
  52. int main()
  53. {
  54.     struct Stu arr[] = { {"zhangsan",34},{"lisi",27},{"wanwu",20} };
  55.     int sz = sizeof(arr) / sizeof(arr[0]);
  56.     my_qsort(arr, sz, sizeof(arr[0]), my_compare_age);
  57.     my_qsort(arr, sz, sizeof(arr[0]), my_compare_name);
  58.     return 0;
  59. }

以上就是个人学习指针的个人见解和学习的解析，欢迎各位大佬在评论区探讨！

感谢大佬们的一键三连！ 感谢大佬们的一键三连！ 感谢大佬们的一键三连！

  1.                                           ![](https://img-blog.csdnimg.cn/7bad9f1ed1b44b53b34d043644d9965a.png)
标签： c语言 开发语言 算法
本文转载自: https://blog.csdn.net/weixin_71964780/article/details/132365926
版权归原作者 黑夢 所有， 如有侵权，请联系我们删除。
登录后发布评论

“C语言：指针（超深度讲解）”的评论:

还没有评论
关于作者
...
overfit同步小助手
文章同步
相关阅读

网络安全法-网络运行安全

使用selenium/drissionpage时如何阻止chrome自动跳转http到https

docker desktop 里部署的Open WebUI 管理员密码忘记了的处理方法

在ubuntu20.04中搭建onsite比赛运行环境

利用开源的低代码表单设计器FcDesigner高效管理和渲染复杂表单结构

Kafka学习笔记

【前端】浏览器输入url到页面呈现发生了什么？