• （c语言进阶）指针的进阶

    一.字符指针

     1.一般应用

    （1）%c的应用

    （2）%s的应用

                                    字符指针没有权限通过解引用去改变指针指向的值 

      

    2.笔试题 

     题目：判断输出结果

    1. int main()
    2. {
    3.     const char* p1 = "abcdef";
    4.     const char* p2 = "abcdef";
    5.  
    6.     char arr1[] = "abcdef";
    7.     char arr2[] = "abcdef";
    8.  
    9.     if (p1 == p2)
    10.     {
    11.         printf("p1==p2\n");
    12.     }
    13.     else
    14.     {
    15.         printf("p1!=p2\n");
    16.     }
    17.  
    18.     if (arr1 == arr2)
    19.     {
    20.         printf("arr1==arr2\n");
    21.     }
    22.     else
    23.     {
    24.         printf("arr1!=arr2\n");
    25.     }
    26.     return 0;
    27. }

     

    解析： 

    1. #include
    2. int main()
    3. {
    4.     const char* p1 = "abcdef";
    5.     const char* p2 = "abcdef";
    6. //常量字符串"zbcdef"被存储在只读区,指针p1、p2存储了这个字符串的首元素地址
    7.     char arr1[] = "abcdef";
    8.     char arr2[] = "abcdef";
    9. //数组arr1、arr2各开辟了一块内存空间，将字符串"zbcdef"存储在开辟的内存中
    10.     if (p1 == p2)
    11.     {
    12.         printf("p1==p2\n");
    13.     }
    14.     else
    15.     {
    16.         printf("p1!=p2\n");
    17.     }
    18. //因为p1和p2都是字符串"abcdef"的地址，是相同的
    19.     if (arr1 == arr2)
    20.     {
    21.         printf("arr1==arr2\n");
    22.     }
    23.     else
    24.     {
    25.         printf("arr1!=arr2\n");
    26.     }
    27. //arr1和arr2为各自开辟的内存空间中，字符串"abcdef"首元素的地址
    28. //两个内存空间不同，所以这两个地址是不同的
    29.     return 0;
    30. }

     

    二.指针数组——元素为指针的数组

    1.指针数组的类型 

    2.指针数组的应用 

     

    三.数组指针——指向数组的指针

    1.数组指针的定义

      

    2.数组指针与指针数组的区别 

    1. #include
    2. int main()
    3. {
    4.     //数组的创建
    5.     int arr1[5] = {1,2,3,4,5};
    6.     int arr2[5] = {2,3,4,5,6};
    7.     int arr3[5]= {3,4,5,6,7};
    8.     //指针数组
    9.     //parr是一个空间为3的数组，其中存储的元素为int*类型的
    10.     //parr的类型为int*[3]
    11.     int* parr[3] = {arr1,arr2,arr3};
    12.     //数组指针
    13.     //p为一个指针，其指向的元素为int[5]类型的
    14.     //为了体现p是一个指针，故将*与p用()圈起来
    15.     //p的类型为int(*)[5]
    16.     int(*p)[5] = &arr1;
    17.     int(*p)[5] = &arr2;
    18.     int(*p)[5] = &arr3;
    19. //——————————————————————————————————————————————————
    20.     //练习
    21.     int* (*pp)[3] = &parr;
    22.     //pp为一个指针，其指向的元素为int*[3]类型的
    23.     //为了体现pp是一个指针，故将*与pp用()圈起来
    24.     //p的类型为int*(*)[3]
    25.     return 0;
    26. }

     

    3.数组名的相关应用 

    4.数组指针的应用 

    例题：

    1. #include
    2. void printf1(int arr[3][5],int h,int l)    //*(*(arr+H)+L)==arr[H][L],故用数组传参和指针传参本质相同
    3. {
    4.     int H,L;
    5.     for (H = 0; H < h; H++)
    6.     {
    7.         for (L = 0; L < l; L++)
    8.         {
    9.             printf("%d ",arr[H][L]);
    10.         }
    11.         printf("\n");
    12.     }
    13. }
    14. void printf2(int(*p)[5],int h,int l)    //二重指针首元素的地址为第一行元素
    15. {
    16.     int H,L;
    17.     for (H = 0; H < h; H++)
    18.     {
    19.         for (L = 0; L < l; L++)
    20.         {
    21.             printf("%d ",*(*(p+H)+L));
    22.           //printf("%d ",p[H][L]);      相同
    23.         }
    24.         printf("\n");
    25.     }
    26. }
    27. //若设arr数组的第一行元素为一维数组brr，数组指针p解引用后为整个数组brr，brr为数组名，相当于首元素地址。
    28. //所以数组指针p解引用后为brr的首个元素，故*(p+H)会依次获取每一行一维数组的首元素地址
    29. //*(p+H)+L会依次获取每一行中的每一个元素的地址,故*(*(p+H)+L)会获取每一行中的每一个元素
    30. int main()
    31. {
    32.     int arr[3][5] = {1,2,3,4,5,2,3,4,5,6,3,4,5,6,7};
    33.     int h = 3;    //行
    34.     int l = 5;    //列
    35.     //数组传参输出
    36.     printf1(arr,h,l);
    37.     printf("\n");
    38.     //指针传参输出
    39.     printf2(arr,h,l);
    40.     return 0;
    41. }

     

    输出结果： 

    5.存放数组指针的数组 

    1. #include
    2. int main()
    3. {
    4.     int arr1[] = {1,2,3,4};
    5.     int arr2[] = {2,3,4,5};
    6.     int arr3[] = {3,4,5,6};
    7.     int(*p1)[4] = &arr1;
    8.     int(*p2)[4] = &arr2;
    9.     int(*p3)[4] = &arr3;
    10.     //数组指针不能没有元素个数，定义数组的时候可以没有
    11.     int(*p[3])[4] = {&arr1,&arr2,&arr3};
    12.     //存放数组指针的数组，其中元素指向的元素类型为int[4]
    13.     //其类型为int(*[3])[4]
    14.     return 0;
    15. }

    四.数组传参和指针传参

    1.一维数组传参

    1. #include
    2.  
    3. void test1(int arr1[])
    4. {}
    5. void test1(int arr1[10])    //形参数组的元素可有可无
    6. {}
    7. void test1(int* arr1)    //接收首元素地址
    8. {}
    9.  
    10.  
    11.  
    12. void test2(int* arr2[])
    13. {}
    14. void test2(int* arr2[20])    //形参数组的元素可有可无
    15. {}
    16. void test2(int** arr2)    //接收首元素地址
    17. {}
    18. int main()
    19. {
    20.     int arr1[10] = {0};
    21.     int* arr2[20] = {0};
    22.  
    23.  
    24.  
    25.     test1(arr1);
    26.     test2(arr2);
    27.     return 0;
    28. }

    2.二维数组传参

    1. #include
    2. void test(int arr[][5])    //二维数组的行可以省略，列不能省略
    3. {}
    4. void test(int arr[3][5])    
    5. {}
    6. void test(int(*arr)[5])    //接收首元素地址-->一个一维数组的地址
    7. {}
    8. int main()
    9. {
    10.     int arr[3][5] = {0};
    11.     test(arr);
    12.     return 0;
    13. } 

    3、一级指针传参

    1. #include
    2. void print(int* p)    //若实参的本质是一个一级整形指针就可以传参
    3. {}
    4. int main()
    5. {
    6.     int a = 10;
    7.     int* ptr = &a;
    8.     int arr[10];
    9.  
    10.     print(&a);
    11.     print(ptr);
    12.     print(arr);
    13.     return 0;
    14. }

    4.二级指针传参

    1. #include
    2. void test(int** p)    //若实参的本质是一个二级整形指针就可以传参
    3. {}
    4. int main()
    5. {
    6.     int* p1;
    7.     int** p2;
    8.     int* arr[10];  //指针数组
    9.  
    10.     test(&p1);
    11.     test(p2);
    12.     test(arr);
    13.     return 0;
    14. }

    五.函数指针

    1.函数指针的定义

    1. #include
    2. int Add(int x, int y)
    3. {
    4.     return x + y;
    5. }
    6. int main()
    7. {
    8.     printf("%p\n",&Add);  //00007FF6991B13E8
    9.     printf("%p\n",Add);  //00007FF6991B13E8
    10.     //&函数名—>取出的是函数的地址
    11.     //对于函数来说，&函数名和函数名都是函数的地址
    12.     int (*p)(int, int) = &Add;
    13.   //int p (int,int) = Add;
    14.     int ret = (*p)(2, 3);
    15.   //int ret = p (2,3);
    16.     //对p解引用后得到函数Add，故(*p)(2, 3)==Add(2,3)
    17.     printf("%d ",ret);
    18.     return 0;
    19. } 

    2.函数指针的应用 

    1.  #include
    2. int Add(int x, int y)
    3. {
    4.     return x + y;
    5. }
    6. void calc(int(*p)(int, int))
    7. {
    8.     int a = 3;
    9.     int b = 5;
    10.     int ret = p(a, b);
    11.     printf("%d\n",ret);
    12. }
    13. int main()
    14. {
    15.     calc(Add);    
    16.     //将函数Add传递给函数calc，使其在函数内用指针调用Add函数
    17.     return 0;
    18. }

    3.特殊的用法——来自《c的陷阱与缺陷》 

    (1)例一 

    1. int main()
    2. {
    3.     //求解如下代码的含义
    4.     (*(void(*)())0)();
    5.   //    void(*)()         返回值为void类型，无参的函数指针
    6.   //  (             )0       将0强制类型转换为函数指针类型
    7.   //(*                 )()    将函数指针类型的0解引用，调用指向地址为0处的函数
    8.  
    9.  //综上可知：这段代码的含义为一次函数调用
    10.     return 0;
    11. }

    （2）例二 

    1.  int main()
    2. {
    3.     //求解如下代码的含义
    4.     void(*signal(int,void(*)(int)))(int);
    5. //           signal(int,void(*)(int))        接收以整形和数组指针为参数的函数的函数指针
    6. //  void(*                                 )(int)  解引用得到函数signal
    7. // 最后得到：void signal (int)——为一次函数声明
    8.     return 0;
    9. }

    4.函数指针的应用

    1.  #include    //简易计算器
    2. void menu()
    3. {
    4.     //add—>加       sub—>减       mul—>乘        div—>除
    5.     printf("*********************************************\n");
    6.     printf("*********     1.add      2.sub    ***********\n");
    7.     printf("*********     3.mul      4.div    ***********\n");
    8.     printf("*********          0.exit         ***********\n");
    9.     printf("*********************************************\n");
    10. }
    11. int add(int x, int y)
    12. {
    13.     return x + y;
    14. }
    15. int sub(int x, int y)
    16. {
    17.     return x - y;
    18. }
    19. int mul(int x, int y)
    20. {
    21.     return x * y;
    22. }
    23. int div(int x, int y)
    24. {
    25.     return x / y;
    26. }
    27. void DiaoYong(int (*p)(int,int))    //使用函数指针 ，减少代码冗余度
    28. {
    29.     int x = 0;
    30.     int y = 0;
    31.     printf("请输入两个整数\n");
    32.     scanf("%d %d",&x,&y);
    33.     int n=p(x,y);
    34.     printf("%d\n",n);
    35. }
    36. int main()
    37. {
    38.     int input = 0;
    39.     do
    40.     {
    41.         menu();
    42.         printf("请输入选项\n");
    43.         scanf("%d",&input);
    44.         switch (input)
    45.         {
    46.         case 1:
    47.             DiaoYong(add);
    48.             break;
    49.         case 2:
    50.             DiaoYong(sub);
    51.             break;
    52.         case 3:
    53.             DiaoYong(mul);
    54.             break;
    55.         case 4:
    56.             DiaoYong(div);
    57.             break;
    58.         case 0:
    59.             printf("退出程序\n");
    60.             break;
    61.         default:
    62.             printf("数值错误，请重新输入\n");
    63.                 break;
    64.         }
    65.     } while (input);
    66.     return 0;
    67. }

    5.typedef对函数指针的用法 

    1.  #include
    2. typedef void(*pt)(int);
    3. //将void(*)(int)改名为pt
    4. int main()
    5. {
    6.     void(*signal(int,void(*)(int)))(int);
    7.     void(*signal(int, pt))(int);
    8.     return 0;
    9. }

    六.函数指针数组

    1.函数指针的形式

    1. #include   //输出两个整数加减乘除的结果
    2. int add(int x, int y)
    3. {
    4.     return x + y;
    5. }
    6. int sub(int x, int y)
    7. {
    8.     return x - y;
    9. }
    10. int mul(int x, int y)
    11. {
    12.     return x * y;
    13. }
    14. int div(int x, int y)
    15. {
    16.     return x / y;
    17. }
    18. int main()
    19. {
    20.     int input = 0;
    21. //    int(*p)(int, int) = add;   //函数指针
    22.     int(*p[4])(int, int) = {add,sub,mul,div};   //函数指针数组
    23.     for (int i=0;i<4;i++)
    24.     {
    25.         printf("%d\n",p[i](8,4));
    26.     }
    27.     return 0;
    28. }

    2.函数指针的应用 

    1. #include    //简易计算器
    2. void menu()
    3. {
    4.     //add—>加       sub—>减       mul—>乘        div—>除
    5.     printf("*********************************************\n");
    6.     printf("*********     1.add      2.sub    ***********\n");
    7.     printf("*********     3.mul      4.div    ***********\n");
    8.     printf("*********          0.exit         ***********\n");
    9.     printf("*********************************************\n");
    10. }
    11. int add(int x, int y)
    12. {
    13.     return x + y;
    14. }
    15. int sub(int x, int y)
    16. {
    17.     return x - y;
    18. }
    19. int mul(int x, int y)
    20. {
    21.     return x * y;
    22. }
    23. int div(int x, int y)
    24. {
    25.     return x / y;
    26. }
    27. int main()
    28. {
    29.     int input = 0;
    30.     int x = 0;
    31.     int y = 0;
    32.     int ret = 0;
    33.     int (*p[5])(int, int) = {0,add,sub,mul,div};
    34.     do
    35.     {
    36.         menu();
    37.         printf("请输入选项\n");
    38.         scanf("%d", &input);
    39.         if (input == 0)
    40.         {
    41.             printf("退出计算器\n");
    42.         }
    43.         else if(input >= 1 && input <= 4)
    44.         {
    45.             printf("请输入两个整数\n");
    46.             scanf("%d %d", &x,&y);
    47.             printf("%d\n", p[input](x,y));
    48.         }
    49.     }while (input);
    50.     return 0;
    51. } 

    七.指向函数指针数组的指针

    1.  int main()
    2. {
    3.     //函数指针数组
    4.     int (*p[5])(int, int) = {0,add,sub,mul,div};
    5.     //指向[函数指针数组]的指针
    6.     int(*(*pr)[5])(int, int) = &p;
    7.     return 0;
    8. }

    八.回调函数

     1.回调函数的定义

    2. 回调函数的应用

    （1）例一：简易计算器

    1.  #include    //简易计算器
    2. void menu()
    3. {
    4.     //add—>加       sub—>减       mul—>乘        div—>除
    5.     printf("*********************************************\n");
    6.     printf("*********     1.add      2.sub    ***********\n");
    7.     printf("*********     3.mul      4.div    ***********\n");
    8.     printf("*********          0.exit         ***********\n");
    9.     printf("*********************************************\n");
    10. }
    11. int add(int x, int y)
    12. {
    13.     return x + y;
    14. }
    15. int sub(int x, int y)
    16. {
    17.     return x - y;
    18. }
    19. int mul(int x, int y)
    20. {
    21.     return x * y;
    22. }
    23. int div(int x, int y)
    24. {
    25.     return x / y;
    26. }
    27. void DiaoYong(int (*p)(int,int))    //使用函数指针 ，减少代码冗余度——回调函数
    28. {
    29.     int x = 0;
    30.     int y = 0;
    31.     printf("请输入两个整数\n");
    32.     scanf("%d %d",&x,&y);
    33.     int n=p(x,y);
    34.     printf("%d\n",n);
    35. }
    36. int main()
    37. {
    38.     int input = 0;
    39.     do
    40.     {
    41.         menu();
    42.         printf("请输入选项\n");
    43.         scanf("%d",&input);
    44.         switch (input)
    45.         {
    46.         case 1:
    47.             DiaoYong(add);
    48.             break;
    49.         case 2:
    50.             DiaoYong(sub);
    51.             break;
    52.         case 3:
    53.             DiaoYong(mul);
    54.             break;
    55.         case 4:
    56.             DiaoYong(div);
    57.             break;
    58.         case 0:
    59.             printf("退出程序\n");
    60.             break;
    61.         default:
    62.             printf("数值错误，请重新输入\n");
    63.                 break;
    64.         }
    65.     } while (input);
    66.     return 0;
    67. }

    （2）例二 ：qsort()函数的应用——整数排序

    1. #include
    2. #include
    3. //void qsort          qsort()函数初始是递增排序
    4. // (void* base,       要排序的初始位置
    5. // size_t num,        待排序的元素个数
    6. // size_t width,      待排序的数据元素的大小（字节）
    7. // int(*cmp)(const void* e1,const void* e2))    函数指针—比较函数
    8. //_cdecl——函数调用约定，约定函数由c语言的语法调用
    9.  
    10. //设置比较函数
    11. int cmp1(const void* x1, const void* x2)
    12. {
    13.     return *(int*)x1 - *(int*)x2;
    14. }
    15. int cmp2(const void* x1, const void* x2)
    16. {
    17.     return *(int*)x2 - *(int*)x1;
    18. }
    19. //函数定义要求e1-e2>0时输出整数，e1-e2=0时输出1=0，e1-e2<0时输出负数
    20. //qsort()函数初始是递增排序，若要变为递减排序，则要交换e1和e2
    21. int main()
    22. {
    23.     //定义数组
    24.     int i = 0;
    25.     int arr[10] = {9,8,7,6,5,4,3,2,1,0};
    26.     int brr[10] = {0,1,2,3,4,5,6,7,8,9};
    27.     //求排序数组的大小
    28.     int sz1 = sizeof(arr) / sizeof(arr[0]);
    29.     int sz2 = sizeof(brr) / sizeof(brr[0]);
    30.     //调用qsort()函数
    31.     qsort(arr,sz1,sizeof(int),cmp1);
    32.     qsort(brr,sz2,sizeof(int),cmp2);
    33.     //输出排序后的数组
    34.     for (i = 0; i < sz1; i++)
    35.     {
    36.         printf("%d ",arr[i]);
    37.     }
    38.     printf("\n");
    39.     for (i = 0; i < sz2; i++)
    40.     {
    41.         printf("%d ", brr[i]);
    42.     }
    43.     return 0;
    44. }

    （3）qsort()函数的应用——结构体排序 

    1. #include
    2. #include
    3. #include
    4. //void qsort          qsort()函数初始是递增排序
    5. // (void* base,       要排序的初始位置
    6. // size_t num,        待排序的元素个数
    7. // size_t width,      待排序的数据元素的大小（字节）
    8. // int(*cmp)(const void* e1,const void* e2))    函数指针—比较函数
    9. //_cdecl——函数调用约定，约定函数由c语言的语法调用
    10.  
    11. //函数定义要求e1-e2>0时输出整数，e1-e2=0时输出1=0，e1-e2<0时输出负数
    12. //qsort()函数初始是递增排序，若要变为递减排序，则要交换e1和e2
    13. struct Stu
    14. {
    15.     char name[20];
    16.     int age;
    17. };
    18. //设置比较函数
    19. int cmp1(const void* x1, const void* x2)
    20. {
    21.     return strcmp(((struct Stu*)x1)->name,((struct Stu*)x2)->name);
    22. }
    23. int cmp2(const void* x1, const void* x2)
    24. {
    25.     return ((struct Stu*)x1)->age - ((struct Stu*)x2)->age;
    26. }
    27.  
    28.  
    29. void test1()        //排序结构体的name元素
    30. {
    31.     struct Stu s[3] = { {"zhangsan",15},{"lisi",30},{"wangwu",25} };
    32.     int sz = sizeof(s) / sizeof(s[0]);
    33.     qsort(s, sz, sizeof(s[0]),cmp1);
    34.     for (int i = 0; i < 3; i++)
    35.     {
    36.         printf("%s ", s[i].name);
    37.     }
    38. }
    39. void test2()    //排序结构体的age元素
    40. {
    41.     struct Stu s[3] = { {"zhangsan",15},{"lisi",30},{"wangwu",25} };
    42.     int sz = sizeof(s) / sizeof(s[0]);
    43.     qsort(s, sz, sizeof(s[0]), cmp2);
    44.     for (int i = 0; i < 3; i++)
    45.     {
    46.         printf("%d ", s[i].age);
    47.     }
    48. }
    49. int main()
    50. {
    51.     test1();
    52.     printf("\n");
    53.     test2();
    54.     return 0;
    55. }

     

    （4）用冒泡排序模拟实现qsort()函数

    1.  #include    
    2. int cmp(const void* x1, const void* x2)
    3. {
    4.     return (*(int*)x1 - *(int*)x2);
    5. }
    6. void Swap(char* x, char* y, int width)  //将两个数改为char*类型，每次只交换一个字节,直到将int*的四个字节全部交换一遍
    7. {
    8.     int i = 0;
    9.     for (i = 0; i < width; i++)
    10.     {
    11.         char tmp = *x;
    12.         *x = *y;
    13.         *y = tmp;
    14.         x++;
    15.         y++;
    16.     }
    17. }
    18. sqort_moni(int* arr,int sz,int width, int (*cmp)(const void*, const void*))
    19. {
    20.     int i,j;
    21.     for (i = 0; i < sz - 1; i++)
    22.     {
    23.         int flag = 1;
    24.         for (j = 0; j < sz - 1 - i; j++)
    25.         {
    26.             if (cmp((char*)arr + j * width, (char*)arr + (j + 1) * width )> 0) //返回值大于0，则说明x1>x2,需要顺序排列则要交换两个数
    27.             {
    28.                 Swap((char*)arr + j * width, (char*)arr + (j + 1) * width, width);
    29.                 flag = 0;
    30.             }
    31.         }
    32.         if (flag == 1)  //如果循环一整遍之后都符合条件，则直接跳出循环
    33.         {
    34.             break;
    35.         }
    36.     }
    37. }
    38. int main()
    39. {
    40.     int arr[10] = {9,8,7,6,5,4,3,2,1,0};
    41.     int sz = sizeof(arr) / sizeof(arr[0]);
    42.     sqort_moni(arr,sz,sizeof(arr[0]), cmp);
    43.     for (int i = 0; i < sz; i++)
    44.     {
    45.         printf("%d ",arr[i]);
    46.     }
    47.     return 0;
    48. }

  • 相关阅读:
    SpringBoot教程三自定义Servlet、Filter、Listener在启动时重写Web相关请求处理类
    JSP JAVA javaweb企业仓库库存管理系统（仓库进销存管理系统ssm库存管理系统仓库管理系统）
    华为云物联网MQTT对接
    C语言学习（八）之指针
    【MySQL数据库】| 索引以及背后的数据结构
    Nacos集群分区
    它突然就不好了 ----Go 调用C++异常
    HashMap面试原理梳理-简单一看就懂
    c++ sort函数cmp比较参数传入
    零拷贝底层剖析
  • 原文地址：https://blog.csdn.net/2301_79580018/article/details/133610383