• C语言-指针的进阶

    前言

    本文主要讲解了c语言中指针的进阶内容，在初阶的基础上进行延伸.

    内存会划分为一个个的内存单元

    每个内存单元都有一个独立的编号，-编号也称为地址

    地址在C语言中也被称为指针

    指针(地址)需要存储起来-存储到变量中，这个变量也就被称为指针变量

    指针(地址)的大小固定说4/8个字节（32位平台/64位平台）

    地址是物理的电线上产生

    32为机器-32根地址线 -1/0

    32个0/1组成的二进制序列，把这个二进制序列作为地址，32bit位才能存储这个地址

    也就是需要4个字节才能存储，所以指针变量的大小是4个字节

    同理64位机器上，地址的大小是64个0/1组成的二进制序列，需要64bit位存储，也就是8个字节。所以指针变量的大小是8个字节。

    一、字符指针 

    在指针的类型中我们知道有一种指针类型为字符指针char*

    1. //在指针的类型中我们知道有一种指针类型为字符指针char*
    2. int main()
    3. {
    4.     char ch = 'w';
    5.     char* pc = &ch; //pc就是字符指针
    6.     *pc = 'a';  
    7.  
    8.     char arr[] = "abcdef"; //[a b c d e f \0]
    9.     const char*p = "abcdef";  //常量字符串
    10.     printf("%s\n",p);  //abcdef
    11.     printf("%c\n",*p); //a
    12.  
    13.     return 0;
    14. }

     经典面试题小试牛刀

    1. int main()
    2. {
    3.     char str1[] = "hello xiaofan.";
    4.     char str2[] = "hello xiaofan.";
    5.  
    6.     const char* str3 = "hello xiaofan.";
    7.     const char* str4 = "hello xiaofan.";
    8.  
    9.     if (str1 == str2)
    10.     {
    11.         printf("str1 and str2 are same\n"); //数组名是数组首元素地址
    12.     }
    13.     else 
    14.     {
    15.         printf("str1 and str2 are not same\n");
    16.     }
    17.     if(str3 == str4)
    18.     {
    19.         printf("str3 and str4 are same\n");
    20.     }
    21.     else
    22.     {
    23.         printf("str3 and str4 are not same\n");
    24.     }
    25.     
    26.     return 0;
    27. }

    二、数组指针

    数组指针是数组还是指针 ----是指针哦

    数组指针类比：

    整型指针-指向整型变量的指针，存放整型变量的地址的指针变量

    字符指针-指向字符变量的指针，存放字符变量的地址的指针变量

    数组指针-指向数组的指针，存放的是数组的地址的指针变量

    1. //数组指针
    2. //数组名的理解
    3. //数组名是数组首元素的地址
    4. //2个例外：1.sizeof(数组名)，这里的数组名不是数组首元素的地址，数组名表示整个数组，sizeof(数组名)计算的是整个数组的大小，单位是字节
    5. //2.&数组名，这里的数组名表示整个数组，&数组名取出的是整个数组的地址
    6. //除此之外，所有的地方的数组名都是数组首元素的地址
    7. // int main()
    8. // {
    9. //     int arr[10] = {0};
    10. //     printf("%p\n",arr); // int*
    11. //     printf("%p\n",arr+1); 
    12.  
    13. //     printf("%p\n",&arr[0]); //int*
    14. //     printf("%p\n",&arr[0]+1); 
    15.  
    16. //     printf("%p\n",&arr); //int(*)[10]
    17. //     printf("%p\n",&arr+1); 
    18.  
    19. //     return 0;
    20. // }
    21.  
    22. //对于数组名来说
    23. //&数组名得到的是数组的地址
    24. // int main()
    25. // {
    26. //     int arr[10] = {1,2,3,4,5,6,7,8,9,10};
    27. //     //数组的地址，存储到数组指针变量
    28. //     //int[10] *p = &arr;   //err
    29. //     int(*p)[10] = &arr;
    30. // }
    31.  
    32. // int main()
    33. // {
    34. //     int arr[10] = {1,2,3,4,5,6,7,8,9,10};
    35. //     int* p = arr;
    36. //     int i = 0;
    37. //     for (i = 0;i<10;i++)
    38. //     {
    39. //         printf("%d ",*(p+i));
    40. //     }
    41. // }
    42.  
    43. // int main()
    44. // {
    45. //     int arr[10] = {1,2,3,4,5,6,7,8,9,10};
    46. //     int (*p)[10] = &arr; //*&arr -> arr
    47. //     int i = 0;
    48. //     for (i = 0;i<10;i++)
    49. //     {
    50.         
    51. //         printf("%d ",*((*p)+i));
    52. //         printf("%d ",(*p)[i]);
    53. //     }
    54. // }
    55.  
    56. //数组指针怎么使用呢？一般在二维数组上才方便
    57.  
    58. //二维数组传参，形参是二维数组的形式
    59. // void Printf(int arr[3][5],int r,int c)
    60. // {
    61. //     int i = 0;
    62. //     for (i = 0; i<3;i++)
    63. //     {
    64. //         int j = 0;
    65. //         for(j = 0;j < 5;j++)
    66. //         {
    67. //             printf("%d ",arr[i][j]);
    68. //         }
    69. //         printf("\n");
    70. //     }
    71. // }
    72. // int main()
    73. // {
    74. //     int arr[3][5] = {1,2,3,4,5, 2,3,4,5,6, 3,4,5,6,7};
    75. //     Printf(arr,3,5);
    76. //     return 0;
    77. // }
    78.  
    79. //二维数组传参，形参是指针的形式
    80. // void Printf(int (*p)[5],int r,int c)
    81. // {
    82. //     int i = 0;
    83. //     for(i = 0; i < r; i++)
    84. //     {
    85. //         int j = 0;
    86. //         for (j = 0; j < c; j++)
    87. //         {
    88. //             printf("%d ",*(*(p+i)+j));
    89. //         }
    90. //     }
    91. // }
    92. // //二维数组的每一行可以理解为二维数组的一个元素
    93. // //每一行又是一个一维数组
    94. // //二维数组其实是一维数组的数组
    95. // //二维数组的数组名，也是数组名，数组名就是数组首元素地址
    96. // //arr - 首元素地址    - 第一行的地址   -一维数组的地址 -数组的地址
    97. // int main()
    98. // {
    99. //     int arr[3][5] = {1,2,3,4,5, 2,3,4,5,6, 3,4,5,6,7};
    100. //     //arr数组名是首元素地址
    101. //     Printf(arr,3,5);
    102.  
    103. //     return 0;
    104.  
    105. // }
    106.  
    107.  
    108. //一维数组传参，形参的部分可以是数组，也可以是指针
    109.  
    110. // void test1(int arr[5],int sz)
    111. // {
    112.  
    113. // }
    114.  
    115. // void test2(int* p,int sz)
    116. // {
    117.  
    118. // }
    119.  
    120. // int main()
    121. // {
    122. //     int arr[5] = {0};
    123. //     test1(arr,5);
    124. //     test2(arr,5);
    125.  
    126. //     return 0;
    127. // }
    128.  
    129. //二维数组传参，形参的部分可以数组，也可以是指针
    130. void test3(char arr[3][5],int r,int c)
    131. {
    132. }
    133.  
    134. void test4(char(*p)[5],int r,int c)
    135. {
    136. }
    137. int main()
    138. {
    139.     char arr[3][5] = {0};
    140.     test3(arr,4,5);
    141.     test4(arr,3,5);
    142.     return 0;
    143. }

    三、指针数组

    指针数组

    整型数组-存放整型的数组

    字符数组-存放字符的数组

    指针数组-存放指针的数组

    1. // int main()
    2. // {
    3. //     int* arr[10];//存放整型指针的数组
    4. //     char* arr2[10]; //一级字符指针的数组
    5. //     char **arr3[10];//二级字符指针的数组
    6.  
    7. //     return 0;
    8. // }
    9.  
    10. //使用指针数组模拟实现二维数组
    11. int main()
    12. {
    13.     int arr1[] = {1,2,3,4,5};
    14.     int arr2[] = {2,3,4,5,6};
    15.     int arr3[] = {3,4,5,6,7};
    16.  
    17.     //指针数组
    18.     int* arr4[3] = {arr1,arr2,arr3};
    19.     printf("%d\n",arr4[1][1]);
    20.  
    21.     int i = 0;
    22.     for ( i = 0; i < 3; i++)
    23.     {
    24.         /* code */
    25.         int j = 0;
    26.         for(j=0;j<5;j++)
    27.         {
    28.             printf("%d ",arr4[i][j]);
    29.             //printf("%d ",*(arr4+i));
    30.         }
    31.         printf("\n");
    32.     }
    33.     
    34.  
    35.     return 0;
    36. }

    四、数组传参和指针传参

    在写代码的时候难免要把数组或者指针传给函数，那函数的参数该如何设计呢？

    一维数组传参

    二维数组传参

    一级指针传参

    二级指针传参

    1.  
    2. //二维数组传参，形参是二维数组的形式
    3. // void Printf(int arr[3][5],int r,int c)
    4. // {
    5. //     int i = 0;
    6. //     for (i = 0; i<3;i++)
    7. //     {
    8. //         int j = 0;
    9. //         for(j = 0;j < 5;j++)
    10. //         {
    11. //             printf("%d ",arr[i][j]);
    12. //         }
    13. //         printf("\n");
    14. //     }
    15. // }
    16. // int main()
    17. // {
    18. //     int arr[3][5] = {1,2,3,4,5, 2,3,4,5,6, 3,4,5,6,7};
    19. //     Printf(arr,3,5);
    20. //     return 0;
    21. // }
    22.  
    23. //二维数组传参，形参是指针的形式
    24. // void Printf(int (*p)[5],int r,int c)
    25. // {
    26. //     int i = 0;
    27. //     for(i = 0; i < r; i++)
    28. //     {
    29. //         int j = 0;
    30. //         for (j = 0; j < c; j++)
    31. //         {
    32. //             printf("%d ",*(*(p+i)+j));
    33. //         }
    34. //     }
    35. // }
    36. // //二维数组的每一行可以理解为二维数组的一个元素
    37. // //每一行又是一个一维数组
    38. // //二维数组其实是一维数组的数组
    39. // //二维数组的数组名，也是数组名，数组名就是数组首元素地址
    40. // //arr - 首元素地址    - 第一行的地址   -一维数组的地址 -数组的地址
    41. // int main()
    42. // {
    43. //     int arr[3][5] = {1,2,3,4,5, 2,3,4,5,6, 3,4,5,6,7};
    44. //     //arr数组名是首元素地址
    45. //     Printf(arr,3,5);
    46.  
    47. //     return 0;
    48.  
    49. // }
    50.  
    51.  
    52. //一维数组传参，形参的部分可以是数组，也可以是指针
    53.  
    54. // void test1(int arr[5],int sz)
    55. // {
    56.  
    57. // }
    58.  
    59. // void test2(int* p,int sz)
    60. // {
    61.  
    62. // }
    63.  
    64. // int main()
    65. // {
    66. //     int arr[5] = {0};
    67. //     test1(arr,5);
    68. //     test2(arr,5);
    69.  
    70. //     return 0;
    71. // }
    72.  
    73. //二维数组传参，形参的部分可以数组，也可以是指针
    74. // void test3(char arr[3][5],int r,int c)
    75. // {
    76. // }
    77.  
    78. // void test4(char(*p)[5],int r,int c)
    79. // {
    80.  
    81. // }
    82. // int main()
    83. // {
    84. //     char arr[3][5] = {0};
    85. //     test3(arr,4,5);
    86. //     test4(arr,3,5);
    87. //     return 0;
    88. // }
    89.  
    90. //一维数组传参
    91. // void test(int arr[])  //true
    92. // {}
    93. // void test(int arr[10])  //true
    94. // {}
    95. // void test(int* arr) //true
    96. // {}
    97. // void test2(int* arr[20]) //true
    98. // {}
    99. // void test2(int** arr)
    100. // {}
    101.  
    102. // int main()
    103. // {
    104. //     int arr[10] = {0};   //存放整型
    105. //     int *arr2[20] = {0};  //存放地址
    106. //     test(arr);
    107. //     test2(arr2);
    108. // }
    109.  
    110. //一级指针传参
    111. // void print(int* p,int sz)
    112. // {
    113. //     int i = 0;
    114. //     for(i = 0;i
    115. //     {
    116. //         printf("%d\n",*(p+i));
    117. //     }
    118. // }
    119.  
    120. // int main()
    121. // {
    122. //     int arr[10] = {1,2,3,4,5,6,7,8,9};
    123. //     int *p = arr;
    124. //     int sz = sizeof(arr)/sizeof(arr[0]);
    125. //     //一级指针p，传给函数
    126. //     print(p,sz);
    127. //     return 0;
    128. // }
    129.  
    130. //二级指针传参
    131. void test(int** ptr)
    132. {
    133.     printf("num = %d\n",**ptr);
    134. }
    135.  
    136. int main()
    137. {
    138.     int n = 10;
    139.     int* p = &n;
    140.     int** pp = &p;
    141.     test(pp);  //10
    142.     test(&p);  //10
    143.  
    144.     return 0;
    145. }

    五、函数指针

    函数指针-指向函数的指针

    数组指针-指向函数的指针

    1. //函数指针
    2. // int Add(int x,int y)
    3. // {
    4. //     return x+y;
    5. // }
    6.  
    7. // int main()
    8. // {
    9. //     int arr[10] = {0};
    10. //     int (*pa)[10] = &arr;
    11. //     // //&arr;
    12. //     // printf("%p\n",&Add);
    13. //     // printf("%p\n",Add);
    14. //     //函数名是函数的地址
    15. //     //&函数名也是函数的地址
    16.  
    17. //     int (*pf)(int,int) =&Add; //pf是函数指针变量   int(*)(int int)是函数指针类型
    18. // }
    19.  
    20. // void test(char* pc,int arr[10])
    21. // {}
    22.  
    23. // int main()
    24. // {
    25. //     void (*pf)(char*,int[10]) = &test;
    26.  
    27. //     return 0;
    28. // }
    29.  
    30.  
    31. int Add(int x,int y)
    32. {
    33.     return x+y;
    34. }
    35.  
    36. int main()
    37. {
    38.     //int (*pf)(int,int) = &Add;
    39.     int (*pf)(int,int) = Add;
    40.     int r = Add(3,5);
    41.     printf("%d\n",r);
    42.  
    43.     int m = (*pf)(4,5);
    44.     printf("%d\n",m);
    45.  
    46.  
    47.     return 0;
    48. }
    49.  
    50. //void (*p)() -p是函数指针
    51. //void (*)()是函数指针类型
    52. // int main()
    53. // {
    54. //     //调用0地址处的函数
    55. //     //1.将0强制类型转换为void(*)() 类型的函数指针
    56. //     //2.调用0地址处的这个函数
    57. //     ( *( void (*)())0)();
    58. // }
    59.  
    60. // typedef unsigned int uint;
    61. // typedef int* ptr_t;
    62.  
    63. // //typedef int(*)[10] parr_t; //err
    64. // typedef int(*parr_t)[10] ;  //true
    65. // typedef int (*pf_t)(int,int);
    66. // int main()
    67. // {
    68. //     uint u1;
    69. //     ptr_t p1;
    70. //     int* p2;
    71. //     //parr_t[10];
    72. //     //pf_t(2,3);
    73.  
    74. //     return 0;
    75. // }
    76.  
    77. int main()
    78. {
    79.     //signal是一个函数声明
    80.     //signal函数有2个参数，第一个参数是int，第二个参数类型是void(*)(int) 函数指针类型
    81.     //该函数指针指向的函数有一个int类型的参数，返回类型是void
    82.     //signal 函数的返回类型也是 void(*)(int) ,该函数指针指向的函数有一个int类型的参数，返回类型是void
    83.     typedef void(*pf_t)(int);
    84.     pf_t signal(int ,pf_t);
    85.     void (* signal(int,void(*)(int)))(int);
    86.  
    87.     return 0;
    88. }

    六、函数指针数组

    整型指针放在一个数组中

    int* arr[5];  //整型指针数组

    char* arr2[5];//字符指针数组

    函数指针数组：数组的每个元素是函数指针类型

    1. //函数指针数组
    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 (*pf1)(int , int) = Add;
    21. //     int (*pf2)(int , int) = Sub;
    22. //     int (*pf3)(int , int) = Mul;
    23. //     int (*pf4)(int , int) = Div;
    24. //     //函数指针数组
    25. //     int (*pfArr[4])(int , int) = {Add,Sub,Mul,Div};
    26.  
    27. //     return 0;
    28. // }
    29.  
    30. void menu()
    31. {
    32.     printf("**********************************\n");
    33.     printf("*******  1.add  2.sub ************\n");
    34.     printf("*******  3.mul  4.div ************\n");
    35.     printf("*******        0.exit ************\n");
    36.     printf("**********************************\n");
    37. }
    38.  
    39. // int main()
    40. // {
    41. //     int input = 0;
    42. //     int x = 0;
    43. //     int y = 0;
    44. //     int ret = 0;
    45. //     do
    46. //     {
    47. //         menu();
    48. //         printf("请选择:>");
    49. //         scanf("%d",&input);
    50. //         switch (input)
    51. //         {
    52. //         case 1:
    53. //             printf("请输入两个操作数:");
    54. //             scanf("%d %d",&x,&y);
    55. //             ret = Add(x,y);
    56. //             printf("ret = %d\n",ret);
    57. //             break;
    58. //         case 2:
    59. //             printf("请输入两个操作数:");
    60. //             scanf("%d %d",&x,&y);
    61. //             ret = Sub(x,y);
    62. //             printf("ret = %d\n",ret);
    63. //             break;
    64. //         case 3:
    65. //             printf("请输入两个操作数:");
    66. //             scanf("%d %d",&x,&y);
    67. //             ret = Mul(x,y);
    68. //             printf("ret = %d\n",ret);
    69. //             break;
    70. //         case 4:
    71. //             printf("请输入两个操作数:");
    72. //             scanf("%d %d",&x,&y);
    73. //             ret = Div(x,y);
    74. //             printf("ret = %d\n",ret);
    75. //             break;
    76. //         case 0:
    77. //             printf("退出计算器\n");
    78. //             break; 
    79. //         default:
    80. //             printf("选择错误重新选择");
    81. //             break;
    82. //         }
    83. //     } while(input);
    84.  
    85. //     return 0;
    86. // }
    87.  
    88. //函数指针的方式
    89. int main()
    90. {
    91.     int input = 0;
    92.     int x = 0;
    93.     int y = 0;
    94.     int ret = 0;
    95.     //函数指针数组的使用 - 转移表
    96.     int (*pfArr[5])(int,int) = {NULL,Add,Sub,Mul,Div};
    97.     do
    98.     {
    99.         menu();
    100.         printf("请选择:>");
    101.         scanf("%d",&input);
    102.         if(input >=1 && input <=4)
    103.         {
    104.             printf("请输入两个操作数:");
    105.             scanf("%d %d",&x,&y);
    106.             ret = pfArr[input](x,y);
    107.             printf("ret = %d\n",ret);
    108.         }
    109.         else if(input == 0)
    110.         {
    111.             printf("退出计算器\n");
    112.         }
    113.         else
    114.         {
    115.             printf("选择错误，重新选择\n");
    116.         }
    117.         
    118.     } while(input);
    119.  
    120.     return 0;
    121. }

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

    int(*pf)(int,int);//函数指针

    int(*pfArr[4])(int,int);//函数指针数组

    int(*(*p)[4](int,int) = &pfArr);//函数指针数组的地址

    p就是指向函数指针数组的指针

    1. void test(const char* str)
    2. {
    3.     printf("%\n",str);
    4. }
    5.  
    6. int main()
    7. {
    8.     //函数指针pfun
    9.     void (*pfun)(const char*) = test;
    10.     //函数指针的数组pfunArr
    11.     void (*pfunArr[5])(const char* str);
    12.     pfunArr[0] = test;
    13.     //指向函数指针数组pfunArr的指针ppfunArr
    14.     void (*(*ppfunArr)[5])(const char*) = &pfunArr;
    15.     return 0;
    16. }

    八、回调函数

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

    1. //回调函数
    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.  
    19. // void menu()
    20. // {
    21. //     printf("**********************************\n");
    22. //     printf("*******  1.add  2.sub ************\n");
    23. //     printf("*******  3.mul  4.div ************\n");
    24. //     printf("*******        0.exit ************\n");
    25. //     printf("**********************************\n");
    26. // }
    27.  
    28. // void Calc(int (*pf)(int x,int y))
    29. // {
    30. //     int x = 0;
    31. //     int y = 0;
    32. //     int ret = 0;
    33. //     printf("请输入两个操作数:\n");
    34. //     scanf("%d %d",&x,&y);
    35. //     ret = pf(x,y);
    36. //     printf("ret = %d\n",ret);
    37.  
    38. // }
    39.  
    40. // int main()
    41. // {
    42. //     int input = 0;
    43. //     int x = 0;
    44. //     int y = 0;
    45. //     int ret = 0;
    46. //     do
    47. //     {
    48. //         menu();
    49. //         printf("请选择:>");
    50. //         scanf("%d",&input);
    51. //         switch (input)
    52. //         {
    53. //         case 1:
    54. //             Calc(Add);
    55. //             break;
    56. //         case 2:
    57. //             Calc(Sub);
    58. //             break;
    59. //         case 3:
    60. //             Calc(Mul);
    61. //             break;
    62. //         case 4:
    63. //             Calc(Div);
    64. //             break;
    65. //         case 0:
    66. //             printf("退出计算器\n");
    67. //             break; 
    68. //         default:
    69. //             printf("选择错误重新选择");
    70. //             break;
    71. //         }
    72. //     } while(input);
    73.  
    74. //     return 0;
    75. // }
    76.  
    77. //冒泡排序 　　　　　   
    78. //有一组整数，需要排序为升序
    79. //1.两两相邻的元素比较
    80. //2.如果不满足顺序就交换
    81.  
    82. // int main()
    83. // {
    84. //     int arr[10] = {9,8,7,6,5,4,3,2,1,0};
    85. //     int sz = sizeof(arr)/sizeof(arr[0]);
    86. //     int i = 0;
    87. //     //int a = qsort(arr[10]);
    88. //     //bubble_sort(arr,sz);
    89. //     //趟数
    90. //     for(i = 0;i < sz-1; i++)
    91. //     {
    92. //         //一趟比较
    93. //         //两两元素比较
    94. //         int j = 0;
    95. //         for (j = 0;j 
    96. //         {
    97. //             if(arr[j] > arr[j+1])
    98. //             {
    99. //                 int tmp = arr[j];
    100. //                 arr[j] = arr[j+1];
    101. //                 arr[j+1] = tmp;
    102. //             }
    103. //         }
    104. //     }
    105.  
    106. //     for (i = 0; i
    107. //     {
    108. //         printf("%d ",arr[i]);
    109. //     }
    110.  
    111.  
    112.  
    113. //     return 0;
    114. // }
    115.  
    116. //qsort  函数的特点
    117. //1.快速排序的方法quick
    118. //2.适用于任何类型数据的排序
    119.  
    120. // void qsort(void *__base, //指向了需要排序的数组的第一个元素
    121. //             size_t __nel, //排序的元素个数
    122. //             size_t __width,//一个元素的大小，单位是字节
    123. // 	    int (* _Nonnull __compar)(const void *, const void *));//函数指针类型-这个函数指针指向的函数，能够比较base指向数组中的两个元素
    124.  
    125. int cmp_int(const void*p1,const void*p2)
    126. {
    127.    return  (*(int*)p1 - *(int*)p2);
    128. }
    129. void print(int arr[],int sz)
    130. {
    131.     int i = 0;
    132.     for(i = 0;i
    133.     {
    134.         printf("%d ",arr[i]);
    135.     }
    136. }
    137.  
    138. //测试qsort排序整型数据
    139. void test1()
    140. {
    141.     int arr[10] = {9,8,7,6,5,4,3,2,1};
    142.     int sz = sizeof(arr)/sizeof(arr[0]);
    143.     //默认是升序的
    144.     qsort(arr,sz,sizeof(int),cmp_int);
    145.     print(arr,sz);
    146. }
    147.  
    148.  
    149. //测试qsort排序结构体数据
    150. struct Stu
    151. {
    152.     char name[20];
    153.     int age;
    154. };
    155.  
    156. int cmp_stu_by_age(const void* p1,const void* p2)
    157. {
    158.     return ((struct Stu*)p1)->age - ((struct Stu*)p2)->age;
    159. }
    160.  
    161. int cmp_stu_by_name(const void* p1,const void* p2)
    162. {
    163.     return strcmp(((struct Stu*)p1)->name,((struct Stu*)p2)->name);
    164. }
    165.  
    166. void test2()
    167. {
    168.     struct Stu arr[] = { {"张三",18}, {"李四,20"},{"王五,16"}};
    169.     int sz = sizeof(arr)/sizeof(arr[0]);
    170.     qsort(arr,sz,sizeof(arr[0]),cmp_stu_by_age);
    171. }
    172.  
    173. void test3()
    174. {
    175.     struct Stu arr[] = { {"张三",18}, {"李四,20"},{"王五,16"}};
    176.     int sz = sizeof(arr)/sizeof(arr[0]);
    177.     qsort(arr,sz,sizeof(arr[0]),cmp_stu_by_name);
    178. }
    179.  
    180.  
    181. int main()
    182. {
    183.     //test1();
    184.     //test2();
    185.     test3();
    186.  
    187.     return 0;
    188. }
    189.  
    190. //void* 指针
    191. //void*类型的指针可以接受任意类型的地址
    192. //这种类型的指针是不能直接解引用操作的
    193. //也不能直接进行指针运算的
    194.  
    195. // int main()
    196. // {
    197. //     int a = 10;
    198. //     float f = 3.14f;
    199. //     int* pa = &a;
    200. //     char* pc = &a;
    201. //     void* pv = &a;
    202.  
    203. // }

    //使用冒泡排序的思想，实现一个功能类似qsort函数 bubble_sort()

    //1.使用冒泡排序的思想

    //2.适用于任意类型数据的排序

    1. //使用冒泡排序的思想，实现一个功能类似qsort函数   bubble_sort()
    2. //1.使用冒泡排序的思想
    3. //2.适用于任意类型数据的排序
    4.  
    5. void Swap(char* buf1,char* buf2,int size)//交换arr[j],arr[j+1]这两个元素
    6. {
    7.     int i = 0;
    8.     int tmp = 0;
    9.     for(i = 0;i < size;i++)
    10.     {
    11.         tmp = *buf1;
    12.         *buf1 = *buf2;
    13.         *buf2 = tmp;
    14.         //char*指针一次只能交换一个字节，但是char有四个字节
    15.         buf1++;
    16.         buf2++;
    17.     }
    18. }
    19.  
    20. void bubble_sort(void* base,int num,int size,int (*cmp)(const void*,const void*))
    21. {
    22.     int i = 0;
    23.     //趟数
    24.     for (i = 0; i < num - i; i++)
    25.     {
    26.         int j = 0;
    27.         //一趟内部比较的对数
    28.         for(j = 0; j < num - 1; j++)
    29.         {
    30.             //假设需要升序，cmp返回>0,交换
    31.             if(cmp((char*)base+j*size,(char*)base+(j+1)*size) > 0)    //两个元素比较,需要将arr[j],arr[j+1]的地址要传给cmp
    32.             {
    33.                 //交换
    34.                 Swap((char*)base + j * size,(char*)base + (j+1) * size,size);
    35.             }
    36.         }
    37.     }
    38. }
    39.  
    40. int cmp_int(const void*p1,const void*p2)
    41. {
    42.    return  (*(int*)p1 - *(int*)p2);
    43. }
    44.  
    45.  
    46. //测试bubble_sort()排序整型数据
    47. void test1()
    48. {
    49.     int arr[10] = {9,8,7,6,5,4,3,2,1};
    50.     int sz = sizeof(arr)/sizeof(arr[0]);
    51.     bubble_sort(arr,sz,sizeof(arr[0]),cmp_int);
    52. }
    53.  
    54. //测试bubble_sort()排序结构体数据
    55.  
    56. struct Stu
    57. {
    58.     char name[20];
    59.     int age;
    60. };
    61.  
    62.  
    63. int cmp_stu_by_age(const void* p1,const void* p2)
    64. {
    65.     return ((struct Stu*)p1)->age - ((struct Stu*)p2)->age;
    66. }
    67.  
    68. int cmp_stu_by_name(const void* p1,const void* p2)
    69. {
    70.     return strcmp(((struct Stu*)p1)->name,((struct Stu*)p2)->name);
    71. }
    72.  
    73. void test2()
    74. {
    75.     struct Stu arr[] = { {"张三",18}, {"李四,20"},{"王五,16"}};
    76.     int sz = sizeof(arr)/sizeof(arr[0]);
    77.     bubble_sort(arr,sz,sizeof(arr[0]),cmp_stu_by_age);
    78. }
    79.  
    80. void test3()
    81. {
    82.     struct Stu arr[] = { {"zhangsan",18}, {"lisi,20"},{"wangwu,16"}};
    83.     int sz = sizeof(arr)/sizeof(arr[0]);
    84.     bubble_sort(arr,sz,sizeof(arr[0]),cmp_stu_by_name);
    85. }
    86.  
    87. int main()
    88. {
    89.     //test1();
    90.     //test2();
    91.     test3();
    92.     return 0;
    93. }

    九、指针和数组面试题的解析

    // 数组名的理解

    // 数组名是数组首元素的地址

    // 但是有2个例外：

    // 1.sizeof(数组名)，这里的数组名表示整个数组，计算的是整个数组的大小，单位是字节

    // 2.&数组名，这里的数组名表示整个数组，取出的是整个数组的地址

    // int main()

    // {

    // //一维数组

    // int a[] = {1, 2, 3, 4};

    // printf("%d\n", sizeof(a)); // 4*4=16

    // printf("%d\n", sizeof(a + 0)); //数组名a是数组首元素的地址，a+0还是首元素地址，地址的大小4/8

    // printf("%d\n", sizeof(*a));//数组名a是数组首元素的地址，*a就是首元素，int类型大小4个字节

    // printf("%d\n", sizeof(a + 1));//数组名a是数组首元素的地址，a+1是第二个元素的地址，地址的大小是4/8

    // printf("%d\n", sizeof(a[1]));//4

    // printf("%d\n", sizeof(&a));//&a是数组的地址，数组的地址也是地址，是4/8个字节

    // printf("%d\n", sizeof(*&a));// --> sizeof(a) ,*&a,取地址解引用a就是a 16

    // printf("%d\n", sizeof(&a + 1)); //8

    // printf("%d\n", sizeof(&a[0]));// 首元素地址 4/8字节

    // printf("%d\n", sizeof(&a[0] + 1));//&a[0]是首元素的地址，&a[0]+1就是第二个元素的地址，地址就是4/8个字节

    // }

    int main()

    {

    // 字符数组

    char arr[] = {'a', 'b', 'c', 'd', 'e', 'f'};

    // printf("%d\n", sizeof(arr)); //计算的是整个数组的大小，单位是字节，总共6个字节

    // printf("%d\n", sizeof(arr + 0)); //arr表示数组首元素地址，arr+0还是数组首元素地址，地址就是4/8字节

    // printf("%d\n", sizeof(*arr));//arr是首元素地址，*arr是首元素，大小1个字节

    // printf("%d\n", sizeof(arr[1]));//1

    // printf("%d\n", sizeof(&arr));//&arr是数组的地址 地址就是4/8

    // printf("%d\n", sizeof(&arr + 1)); //地址就是4/8

    // printf("%d\n", sizeof(&arr[0] + 1)); //地址是4/8

    printf("%d\n", strlen(arr)); //因为字符数组arr中没有\0，所以求字符串长度的时候，会一直往后找，产生的结构就是随机值

    printf("%d\n", strlen(arr + 0));// arr+0 是首元素的地址，和第一个一样，也是随机值

    //printf("%d\n", strlen(*arr));//arr是数组首元素的地址，*arr就是数组首元素 就是'a'-97

    //strlen函数参数的部分需要传一个地址，当我们传递的是'a'时，‘a’的ASCII码值就是97，那就是将97作为地址传参

    //strlen就会从97这个地址开始统计字符串长度，这就非法访问内存了

    //printf("%d\n", strlen(arr[1])); //err

    printf("%d\n", strlen(&arr));//&arr是数组的地址，数组的地址和数组首元素的地址，值是一样的，传递给strlen函数后，依然是从数组的第一个元素的位置，还是往后统计

    printf("%d\n", strlen(&arr + 1));//跳过这个数组 ，随机值

    printf("%d\n", strlen(&arr[0] + 1));//&arr[0] + 1是第二个元素的地址，随机值-1

    }

    1. #include 
    2. #include 
    3.  
    4. // 数组名的理解
    5. // 数组名是数组首元素的地址
    6. // 但是有2个例外：
    7. // 1.sizeof(数组名)，这里的数组名表示整个数组，计算的是整个数组的大小，单位是字节
    8. // 2.&数组名，这里的数组名表示整个数组，取出的是整个数组的地址
    9.  
    10. // int main()
    11. // {
    12. //     //一维数组
    13. //     int a[] = {1, 2, 3, 4};
    14. //     printf("%d\n", sizeof(a)); // 4*4=16
    15. //     printf("%d\n", sizeof(a + 0)); //数组名a是数组首元素的地址，a+0还是首元素地址，地址的大小4/8
    16. //     printf("%d\n", sizeof(*a));//数组名a是数组首元素的地址，*a就是首元素，int类型大小4个字节
    17. //     printf("%d\n", sizeof(a + 1));//数组名a是数组首元素的地址，a+1是第二个元素的地址，地址的大小是4/8
    18. //     printf("%d\n", sizeof(a[1]));//4
    19. //     printf("%d\n", sizeof(&a));//&a是数组的地址，数组的地址也是地址，是4/8个字节
    20. //     printf("%d\n", sizeof(*&a));// -->  sizeof(a) ,*&a,取地址解引用a就是a   16
    21. //     printf("%d\n", sizeof(&a + 1)); //8
    22. //     printf("%d\n", sizeof(&a[0]));// 首元素地址 4/8字节
    23. //     printf("%d\n", sizeof(&a[0] + 1));//&a[0]是首元素的地址，&a[0]+1就是第二个元素的地址，地址就是4/8个字节
    24. // }
    25.  
    26. // int main()
    27. // {
    28. //     // 字符数组
    29. //     char arr[] = {'a', 'b', 'c', 'd', 'e', 'f'};
    30. //     // printf("%d\n", sizeof(arr)); //计算的是整个数组的大小，单位是字节，总共6个字节
    31. //     // printf("%d\n", sizeof(arr + 0)); //arr表示数组首元素地址，arr+0还是数组首元素地址，地址就是4/8字节
    32. //     // printf("%d\n", sizeof(*arr));//arr是首元素地址，*arr是首元素，大小1个字节
    33. //     // printf("%d\n", sizeof(arr[1]));//1
    34. //     // printf("%d\n", sizeof(&arr));//&arr是数组的地址 地址就是4/8
    35. //     // printf("%d\n", sizeof(&arr + 1)); //地址就是4/8
    36. //     // printf("%d\n", sizeof(&arr[0] + 1)); //地址是4/8
    37. //     printf("%d\n", strlen(arr)); //因为字符数组arr中没有\0，所以求字符串长度的时候，会一直往后找，产生的结构就是随机值
    38. //     printf("%d\n", strlen(arr + 0));// arr+0 是首元素的地址，和第一个一样，也是随机值
    39. //     //printf("%d\n", strlen(*arr));//arr是数组首元素的地址，*arr就是数组首元素 就是'a'-97
    40. //     //strlen函数参数的部分需要传一个地址，当我们传递的是'a'时，‘a’的ASCII码值就是97，那就是将97作为地址传参
    41. //     //strlen就会从97这个地址开始统计字符串长度，这就非法访问内存了
    42. //     //printf("%d\n", strlen(arr[1])); //err
    43. //     printf("%d\n", strlen(&arr));//&arr是数组的地址，数组的地址和数组首元素的地址，值是一样的，传递给strlen函数后，依然是从数组的第一个元素的位置，还是往后统计
    44. //     printf("%d\n", strlen(&arr + 1));//跳过这个数组 ，随机值
    45. //     printf("%d\n", strlen(&arr[0] + 1));//&arr[0] + 1是第二个元素的地址，随机值-1
    46. //     return 0;
    47. // }
    48.  
    49. // int main()
    50. // {
    51. //     char arr[] = "abcdef"; //[a b c d e f \0]
    52. //     // printf("%d\n", sizeof(arr));  //7
    53. //     // printf("%d\n", sizeof(arr + 0)); //arr+0是首元素地址 4/8
    54. //     // printf("%d\n", sizeof(*arr)); // *arr首元素  char类型是1
    55. //     // printf("%d\n", sizeof(arr[1]));//下标1的元素b   1
    56. //     // printf("%d\n", sizeof(&arr)); //地址就是4/8
    57. //     // printf("%d\n", sizeof(&arr + 1));//地址 4/8
    58. //     // printf("%d\n", sizeof(&arr[0] + 1));//地址4/8
    59.  
    60. //     printf("%d\n", strlen(arr));//6
    61. //     printf("%d\n", strlen(arr + 0)); //6
    62. //     //printf("%d\n", strlen(*arr)); //err
    63. //     //printf("%d\n", strlen(arr[1])); //err
    64. //     printf("%d\n", strlen(&arr)); //6
    65. //     printf("%d\n", strlen(&arr + 1));//随机值
    66. //     printf("%d\n", strlen(&arr[0] + 1));//5
    67. //     return 0;
    68. // }
    69.  
    70. // int main()
    71. // {
    72. //     char *p = "abcdef"; //[a b c d e f \0]
    73. // //     printf("%d\n", sizeof(p));  //p是一个指针变量，大小就要4/8个字节
    74. // //     printf("%d\n", sizeof(p + 1)); //p+1是b的地址，是地址大小就是4/8个字节
    75. // //     printf("%d\n", sizeof(*p)); //*p首元素，字符a  1个字节
    76. // //     printf("%d\n", sizeof(p[0]));//p[0] = *(p+0) = *p  1
    77. // //     printf("%d\n", sizeof(&p)); //   4/8  p = char*  &p = char**
    78. // //     printf("%d\n", sizeof(&p + 1));// 4/8
    79. // //     printf("%d\n", sizeof(&p[0] + 1));// 4/8
    80.  
    81. //     printf("%d\n", strlen(p)); //6
    82. //     printf("%d\n", strlen(p + 1));//5
    83. //     //printf("%d\n", strlen(*p));// err *p = a
    84. //     //printf("%d\n", strlen(p[0]));// p[0] = *(p+0) = *p err
    85. //     printf("%d\n", strlen(&p));//随机值
    86. //     printf("%d\n", strlen(&p + 1));//随机值
    87. //     printf("%d\n", strlen(&p[0] + 1));//&p[0]+1 是b  5
    88.     //return 0;
    89. // }
    90.  
    91. int main()
    92. { 
    93.     // 二维数组
    94.     int a[3][4] = {0}; 
    95.     printf("%d\n", sizeof(a)); //3*4*4
    96.     printf("%d\n", sizeof(a[0][0]));//4
    97.     printf("%d\n", sizeof(a[0])); //4*4
    98.     printf("%d\n", sizeof(a[0] + 1)); // 4/8
    99.     //a[0]作为第一行的数组名，没有单独放在sizeof内部，没有&
    100.     //a[0]表示数组首元素的地址，也就是a[0][0]的地址
    101.     //a[0]+1是第一行第二个元素的地址
    102.     //地址就是4/8
    103.     printf("%d\n", sizeof(*(a[0] + 1)));//计算的就是第一行第2个元素的大小  4个字节
    104.     printf("%d\n", sizeof(a + 1)); // 4/8
    105.     //a是数组首元素的地址，是第一行的地址
    106.     //a+1就是第二行的地址
    107.     printf("%d\n", sizeof(*(a + 1)));  //4*4
    108.     //*(a+1)--> a[1]  -> sizeof(a[1]),计算第二行的大小
    109.     //a+1就是第二行的地址，*(a+1)计算第二行的大小
    110.     printf("%d\n", sizeof(&a[0] + 1));// 4/8
    111.     //&a[0]第一行的地址
    112.     //&[0]+1第二行的地址
    113.     printf("%d\n", sizeof(*(&a[0] + 1)));  //第二行的大小 4*4
    114.     printf("%d\n", sizeof(*a));  //4*4
    115.     //a是数组首元素地址，就是第一行地址
    116.     //*a就是第一行
    117.     //*a -->  *(a+0)   --> a[0]
    118.     printf("%d\n", sizeof(a[3])); //4*4
    119.     //a[3] --> int[4]
    120.  
    121.     return 0;
    122. }

    //总结：数组名的意义

    //1sizeof(数组名)，这里的数组名表示整个数组，计算的是整个数组的大小

    //2.&数组名，这里的数组名表示整个数组，取出的是整个数组的地址

    //3.除此之外所有的数组名都表示首元素的地址

    1. // 笔试题1
    2. //  int main()
    3. //  {
    4. //      int a[5] = { 1, 2, 3, 4, 5 };
    5. //      int *ptr = (int *)(&a + 1);
    6. //      printf( "%d,%d", *(a + 1), *(ptr - 1)); //2 5
    7. //      return 0;
    8. //  }
    9.  
    10. // 笔试题2
    11. // 由于还没学习结构体，这里告知结构体的大小是20个字节
    12. // struct Test
    13. // {
    14. //     int Num;
    15. //     char *pcName;
    16. //     short sDate;
    17. //     char cha[2];
    18. //     short sBa[4];
    19. // } *p = (struct Test*)0x100000;
    20. // // 假设p 的值为0x100000。 如下表表达式的值分别为多少？
    21. // int main()
    22. // {
    23. //     printf("%p\n", p + 0x1); //0x100020  +1跳过一个结构体就是20个字节
    24. //     printf("%p\n", (unsigned long)p + 0x1);//0x100001
    25. //     printf("%p\n", (unsigned int *)p + 0x1); //0x100004
    26. //     return 0;
    27. // }
    28.  
    29.  
    30. //笔试题3
    31. // int main()
    32. // {
    33. //     int a[4] = {1, 2, 3, 4};
    34. //     int *ptr1 = (int *)(&a + 1);
    35. //     int *ptr2 = (int *)((int)a + 1);
    36. //     printf("%x\n,%x\n", ptr1[-1], *ptr2);
    37. //     return 0;
    38. // }
    39.  
    40. //笔试题4
    41. // #include 
    42. // int main()
    43. // {
    44. //     int a[3][2] = { (0, 1), (2, 3), (4, 5) };
    45. //     int *p;
    46. //     p = a[0]; //a[0] -->  &a[0][0]
    47. //     printf( "%d", p[0]);//p[0] --> *(p+0) -->*p   1
    48. //     return 0;
    49. // }
    50.  
    51. //笔试题5
    52. // int main()
    53. // {
    54. //     int a[5][5]; 
    55. //     int(*p)[4];
    56. //     //p --> int(*)4   a -->int(*)5
    57. //     p = a;
    58. //     printf( "%p,%d\n",
    59. //      &p[4][2] - &a[4][2], 
    60. //      &p[4][2] - &a[4][2]);
    61. //     return 0;
    62. // }
    63.  
    64. //笔试题6
    65. // int main()
    66. // {
    67. //     int aa[2][5] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
    68. //     int *ptr1 = (int *)(&aa + 1);
    69. //     int *ptr2 = (int *)(*(aa + 1));
    70. //     printf( "%d,%d", *(ptr1 - 1), *(ptr2 - 1));//10 5
    71. //     return 0;
    72. // }
    73.  
    74. //笔试题7
    75. // int main()
    76. // {
    77. //     char *a[] = {"work","at","alibaba"};//char* work   char* at   char* alibaba  
    78. //     char**pa = a;
    79. //     pa++;  //0 work  1 at  2 alibaba
    80. //     printf("%s\n", *pa);  //at
    81. //     return 0;
    82. // }
    83.  
    84. //笔试题8
    85. int main()
    86. {
    87.     char *c[] = {"ENTER","NEW","POINT","FIRST"};
    88.     char**cp[] = {c+3,c+2,c+1,c};
    89.     char***cpp = cp;
    90.     printf("%s\n", **++cpp);
    91.     printf("%s\n", *--*++cpp+3);
    92.     printf("%s\n", *cpp[-2]+3);
    93.     printf("%s\n", cpp[-1][-1]+1);
    94.     return 0;
    95. }

    笔试题3

    笔试题5

     

     笔试题6

    总结：本章主要对指针在初阶的基础上更深一步的进行了研究，对指针地址和解引用都有详细的讲解，如需初阶可以观看C语言基础-指针_小凡喜编程的博客-CSDN博客

  • 相关阅读:
    计算机网络复习——第四章网络层
    【Azure Redis 缓存】 Python连接Azure Redis, 使用redis.ConnectionPool 出现 "ConnectionResetError: [Errno 104] Connection reset by peer"
    JavaWeb——IDEA操作：Project最终新建module
    【图像处理与机器视觉】灰度变化与空间滤波
    spring boot 整合 itextpdf 导出 PDF，写入大文本，写入HTML代码，分析当下导出PDF的几个工具
    SpringMVC入门宝典（六）SpringMVC文件上传（上）
    爱上开源之DockerUI-xterm.js实现Web控制台
    有限域的Fast Multiplication和Modular Reduction算法实现
    HTTPS双向认证和如何生成证书
    c#中单例模式详解
  • 原文地址：https://blog.csdn.net/qq_61658398/article/details/133294546