C语言06指针进阶

1 指针的使用

1.1 问题

写一个程序，回顾指针的基本应用，然后测试空指针和野指针，再加上条件判断进行避免。

1.2 步骤

实现此案例需要按照如下步骤进行。

步骤一：指针的使用

代码如下所示：

    

  1. #include <stdio.h>
    2. 

  2. void swap(int *a, int *b)
    3. 

  3. {
    4. 

  4. int tmp = *a;
    5. 

  5. *a = *b;
    6. 

  6. *b = tmp;
    7. 

  7. }
    8. 

  8. int main()
    9. 

  9. {
    10. 

  10. int a = 10;
    11. 

  11. int *p = &a;
    12. 

  12. printf("a = %d\n", *p);
    13. 

  13. printf("p = %p\n", p);
    14. 

  14. p = p + 1;
    15. 

  15. printf("p + 1 = %p\n", p);
    16. 

  16. p = p - 1;
    17. 

  17. printf("p - 1 = %p\n", p);
    18. 

  18. int b = 20;
    19. 

  19. printf("a = %d, b = %d\n", a, b);
    20. 

  20. swap(&a, &b);
    21. 

  21. printf("a = %d, b = %d\n", a, b);
    22. 

  22. const int *p1 = &a;
    23. 

  23. //*p1 = 30;
    24. 

  24. p1 = &b;
    25. 

  25. int *const p2 = &a;
    26. 

  26. *p2 = 40;
    27. 

  27. //p2 = &b;
    28. 

  28. p = NULL;
    29. 

  29. if (p)
    30. 

  30. printf("p = %p\n", p);
    31. 

  31. return 0;
    32. 

  32. }
    33.

上述代码中，以下代码：

    

  1. void swap(int *a, int *b)
    2. 

  2. {
    3. 

  3. int tmp = *a;
    4. 

  4. *a = *b;
    5. 

  5. *b = tmp;
    6. 

  6. }
    7.

定义了一个函数swap1，该函数有两个参数，为整型指针变量a和b。在该函数中，以下语句：

    

  1. int tmp = *a;
    2. 

  2. *a = *b;
    3. 

  3. *b = tmp;
    4.

通过第三个变量tmp，将整型指针变量a和b指向的地址的值进行交换。

上述代码中，以下代码：

    

  1. int a = 10;
    2. 

  2. int *p = &a;
    3. 

  3. printf("a = %d\n", *p);
    4.

首先，定义一个整型变量a，并初始化为10。

然后，定义一个整型指针变量p，并初始化为变量a的地址。

最后，输出指针变量p指向的地址的内容。

上述代码中，以下代码：

    

  1. printf("p = %p\n", p);
    2. 

  2. p = p + 1;
    3. 

  3. printf("p + 1 = %p\n", p);
    4.

首先，输出指针变量加1前的地址值。

然后，将指针变量p加1。

最后，输出指针变量加1后的地址值。

上述代码中，以下代码：

    

  1. p = p - 1;
    2. 

  2. printf("p - 1 = %p\n", p);
    3.

首先，将指针变量p减1。

然后，输出指针变量减1后的地址值。

上述代码中，以下代码：

    

  1. int b = 20;
    2. 

  2. printf("a = %d, b = %d\n", a, b);
    3. 

  3. swap(&a, &b);
    4. 

  4. printf("a = %d, b = %d\n", a, b);
    5.

首先，定义一个整型变量b，并初始化为20。

然后，输出变量a和b在调用swap函数前的值。

下一步，调用函数swap。

最后，输出变量a和b在调用swap函数后的值。

上述代码中，以下代码：

    

  1. const int *p1 = &a;
    2. 

  2. //*p1 = 30;
    3. 

  3. p1 = &b;
    4.

在*号左边加const关键字，锁定的是指针p1指向的地址的内容，所以第2行是错误的而第3行是正确的。

上述代码中，以下代码：

    

  1. int *const p2 = &a;
    2. 

  2. *p2 = 40;
    3. 

  3. //p2 = &b;
    4.

在*号右边加const关键字，锁定的是指针p1本身，所以第2行是正确的而第3行是错误的。

上述代码中，以下代码：

    

  1. p = NULL;
    2. 

  2. if (p)
    3. 

  3. printf("p = %p\n", p);
    4.

为防止野指针的出现，在不再使用指针p后，应将其置空，这样可以通过条件p是否为空来判断指针是否有效。

1.3 完整代码

本案例的完整代码如下所示：

    

  1. #include <stdio.h>
    2. 

  2. void swap(int *a, int *b)
    3. 

  3. {
    4. 

  4. int tmp = *a;
    5. 

  5. *a = *b;
    6. 

  6. *b = tmp;
    7. 

  7. }
    8. 

  8. int main()
    9. 

  9. {
    10. 

  10. int a = 10;
    11. 

  11. int *p = &a;
    12. 

  12. printf("a = %d\n", *p);
    13. 

  13. printf("p = %p\n", p);
    14. 

  14. p = p + 1;
    15. 

  15. printf("p + 1 = %p\n", p);
    16. 

  16. p = p - 1;
    17. 

  17. printf("p - 1 = %p\n", p);
    18. 

  18. int b = 20;
    19. 

  19. printf("a = %d, b = %d\n", a, b);
    20. 

  20. swap(&a, &b);
    21. 

  21. printf("a = %d, b = %d\n", a, b);
    22. 

  22. const int *p1 = &a;
    23. 

  23. //*p1 = 30;
    24. 

  24. p1 = &b;
    25. 

  25. int *const p2 = &a;
    26. 

  26. *p2 = 40;
    27. 

  27. //p2 = &b;
    28. 

  28. p = NULL;
    29. 

  29. if (p)
    30. 

  30. printf("p = %p\n", p);
    31. 

  31. return 0;
    32. 

  32. }
    33.

2 二级指针的应用

2.1 问题

使用二级指针操作字符串数组。

2.2 步骤

实现此案例需要按照如下步骤进行。

步骤一：二级指针的应用（指针数组：本质为数组，存放的是指针）

代码如下所示：

    

  1. #include <stdio.h>
    2. 

  2. int main()
    3. 

  3. {
    4. 

  4. char *name[] = {"zhangsan", "lisi", "wangwu", "zhaoliu"};
    5. 

  5. char **p = name;
    6. 

  6. for (int i = 0; i < 4; i++)
    7. 

  7. printf("%s\n", p[i]);
    8. 

  8. return 0;
    9. 

  9. }
    10.

上述代码中，以下代码：

    

  1. char *name[] = {"zhangsan", "lisi", "wangwu", "zhaoliu"};
    2.

定义一个指针数组name，并初始化为四个字符串。

上述代码中，以下代码：

    

  1. char **p = name;
    2.

定义一个二级指针p，并初始化为指针数组名name。

上述代码中，以下代码：

    

  1. for (int i = 0; i < 4; i++)
    2. 

  2. printf("%s\n", p[i]);
    3.

设置循环，将二级指针p指向的字符指针数组内的内容输出。其中，p等效于name，p[i]等效于name[i]。

2.3 完整代码

本案例的完整代码如下所示：

    

  1. #include <stdio.h>
    2. 

  2. int main()
    3. 

  3. {
    4. 

  4. char *name[] = {"zhangsan", "lisi", "wangwu", "zhaoliu"};
    5. 

  5. char **p = name;
    6. 

  6. for (int i = 0; i < 4; i++)
    7. 

  7. printf("%s\n", p[i]);
    8. 

  8. return 0;
    9. 

  9. }
    10.

3 二级指针的应用(续1)

3.1 问题

定义一个函数，要求实现字符串转换成int，要求一个字符一个字符的转换，如果遇到不是数字字符的就返回前面的整数和后面的字符串。

3.2 步骤

实现此案例需要按照如下步骤进行。

步骤一：二级指针的应用(续1)

代码如下所示：

    

  1. #include <stdio.h>
    2. 

  2. int convert(char **str)
    3. 

  3. {
    4. 

  4. int num = 0;
    5. 

  5. while (**str)
    6. 

  6. {
    7. 

  7. if (**str >= ‘0‘ && **str <= ‘9‘)
    8. 

  8. num = num * 10 + **str - ‘0‘;
    9. 

  9. else
    10. 

  10. break;
    11. 

  11. (*str)++;
    12. 

  12. }
    13. 

  13. return num;
    14. 

  14. }
    15. 

  15. int main()
    16. 

  16. {
    17. 

  17. char str[] = "1234abc";
    18. 

  18. char *p = str;
    19. 

  19. printf("%d\n", convert(&p));
    20. 

  20. printf("%s\n", p);
    21. 

  21. return 0;
    22. 

  22. }
    23.

上述代码中，以下代码：

    

  1. int convert(char **str)
    2. 

  2. {
    3. 

  3. int num = 0;
    4. 

  4. while (**str)
    5. 

  5. {
    6. 

  6. if (**str >= ‘0‘ && **str <= ‘9‘)
    7. 

  7. num = num * 10 + **str - ‘0‘;
    8. 

  8. else
    9. 

  9. break;
    10. 

  10. (*str)++;
    11. 

  11. }
    12. 

  12. return num;
    13. 

  13. }
    14.

定义一个函数convert，用于将字符串中的前面数字字符转换成数字并输出后面的字符串。在该函数中，以下代码：

    

  1. int num = 0;
    2.

定义一个整型变量num，用于存储转换后的数字。在该函数中，以下代码：

    

  1. if (**str >= ‘0‘ && **str <= ‘9‘)
    2. 

  2. num = num * 10 + **str - ‘0‘;
    3.

判断字符**str是否是数字字符，若是，则将其进行转换。在该函数中，以下代码：

    

  1. while (**str)
    2. 

  2. {
    3. 

  3. if (**str >= ‘0‘ && **str <= ‘9‘)
    4. 

  4. num = num * 10 + **str - ‘0‘;
    5. 

  5. else
    6. 

  6. break;
    7. 

  7. (*str)++;
    8. 

  8. }
    9.

设置循环，逐个检查字符串*str中的每个字符，如果是数字字符，则将其进行转换。否则，退出循环。在该函数中，以下代码：

    

  1. return num;
    2.

返回，转换后的数字。

上述代码中，以下代码：

    

  1. int main()
    2. 

  2. {
    3. 

  3. char str[] = "1234abc";
    4. 

  4. char *p = str;
    5. 

  5. printf("%d\n", convert(&p));
    6. 

  6. printf("%s\n", p);
    7. 

  7. return 0;
    8. 

  8. }
    9.

首先定义一个字符数组str，并初始化一个字符串。

然后，定义一个字符指针p，并初始化为字符数组str。

下一步，打印转换后的数字。

最后，打印剩余的字符。

3.3 完整代码

本案例的完整代码如下所示：

    

  1. #include <stdio.h>
    2. 

  2. int convert(char **str)
    3. 

  3. {
    4. 

  4. int num = 0;
    5. 

  5. while (**str)
    6. 

  6. {
    7. 

  7. if (**str >= ‘0‘ && **str <= ‘9‘)
    8. 

  8. num = num * 10 + **str - ‘0‘;
    9. 

  9. else
    10. 

  10. break;
    11. 

  11. (*str)++;
    12. 

  12. }
    13. 

  13. return num;
    14. 

  14. }
    15. 

  15. int main()
    16. 

  16. {
    17. 

  17. char str[] = "1234abc";
    18. 

  18. char *p = str;
    19. 

  19. printf("%d\n", convert(&p));
    20. 

  20. printf("%s\n", p);
    21. 

  21. return 0;
    22. 

  22. }
    23.

4 void*的基本用法

4.1 问题

定义一个int*，然后赋值给void*，并对void*的基本用法进行测试。

4.2 步骤

实现此案例需要按照如下步骤进行。

步骤一：void*的基本用法

代码如下所示：

    

  1. #include <stdio.h>
    2. 

  2. int main()
    3. 

  3. {
    4. 

  4. int a = 10;
    5. 

  5. int *p = &a;
    6. 

  6. void *p1 = p;
    7. 

  7. //*p1 = 20;
    8. 

  8. *(int*)p1 = 20;
    9. 

  9. printf("a = %d\n", *(int*)p1);
    10. 

  10. return 0;
    11. 

  11. }
    12.

上述代码中，以下代码：

    

  1. int a = 10;
    2.

定义一个整型变量a，并初始化为10。

上述代码中，以下代码：

    

  1. int *p = &a;
    2.

定义一个整型指针变量p，并初始化为整型变量a的地址。

上述代码中，以下代码：

    

  1. void *p1 = p;
    2.

定义一个万能指针p1，并初始化为整型指针p的值。万能指针是可以指向任意数据类型的变量的指针。

上述代码中，以下代码：

    

  1. //*p1 = 20;
    2.

万能指针不能直接用*访问指针所指向的地址的内容。

上述代码中，以下代码：

    

  1. *(int*)p1 = 20;
    2. 

  2. printf("a = %d\n", *(int*)p1);
    3.

万能指针必须先转换成其指向的数据类型后，才能用*访问指针所指向的地址的内容。

4.3 完整代码

本案例的完整代码如下所示：

    

  1. #include <stdio.h>
    2. 

  2. int main()
    3. 

  3. {
    4. 

  4. int a = 10;
    5. 

  5. int *p = &a;
    6. 

  6. void *p1 = p;
    7. 

  7. //*p1 = 20;
    8. 

  8. *(int*)p1 = 20;
    9. 

  9. printf("a = %d\n", *(int*)p1);
    10. 

  10. return 0;
    11. 

  11. }
    12.

5 函数指针的使用

5.1 问题

使用函数指针实现对一组数据实现不同的处理方式。

5.2 步骤

实现此案例需要按照如下步骤进行。

步骤一：函数指针的使用

代码如下所示：

    

  1. #include <stdio.h>
    2. 

  2. int min(int *buf, int size)
    3. 

  3. {
    4. 

  4. int min = buf[0];
    5. 

  5. for (int i = 0; i < size; i++)
    6. 

  6. if (buf[i] < min)
    7. 

  7. min = buf[i];
    8. 

  8. return min;
    9. 

  9. }
    10. 

  10. int max(int *buf, int size)
    11. 

  11. {
    12. 

  12. int max = buf[0];
    13. 

  13. for (int i = 0; i < size; i++)
    14. 

  14. if (buf[i] > max)
    15. 

  15. max = buf[i];
    16. 

  16. return max;
    17. 

  17. }
    18. 

  18. int main()
    19. 

  19. {
    20. 

  20. int data[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 0};
    21. 

  21. int (*p)(int*, int);
    22. 

  22. p = min;
    23. 

  23. printf("data中的最小值是%d\n", p(data, 10));
    24. 

  24. p = max;
    25. 

  25. printf("data中的最大值是%d\n", p(data, 10));
    26. 

  26. return 0;
    27. 

  27. }
    28.

上述代码中，以下代码：

    

  1. int min(int *buf, int size)
    2. 

  2. {
    3. 

  3. int min = buf[0];
    4. 

  4. for (int i = 0; i < size; i++)
    5. 

  5. if (buf[i] < min)
    6. 

  6. min = buf[i];
    7. 

  7. return min;
    8. 

  8. }
    9.

定义一个函数min，用于求一组数中的最小值。该函数有两个参数，说明如下：

第一个参数为包含一组数的数组。

第二个参数为数组的个数。

该函数中，以下语句：

    

  1. int min = buf[0];
    2.

定义一个整型变量min，用于保存一组数中的最小值。该函数中，以下语句：

    

  1. for (int i = 0; i < size; i++)
    2. 

  2. if (buf[i] < min)
    3. 

  3. min = buf[i];
    4.

遍历数组，找出最小值。该函数中，以下语句：

    

  1. return min;
    2.

返回最小值。

上述代码中，以下代码：

    

  1. int max(int *buf, int size)
    2. 

  2. {
    3. 

  3. int max = buf[0];
    4. 

  4. for (int i = 0; i < size; i++)
    5. 

  5. if (buf[i] > max)
    6. 

  6. max = buf[i];
    7. 

  7. return max;
    8. 

  8. }
    9.

定义一个函数max，用于求一组数中的最大值。该函数有两个参数，说明如下：

第一个参数为包含一组数的数组。

第二个参数为数组的个数。

该函数中，以下语句：

    

  1. int max = buf[0];
    2.

定义一个整型变量max，用于保存一组数中的最大值。该函数中，以下语句：

    

  1. for (int i = 0; i < size; i++)
    2. 

  2. if (buf[i] > max)
    3. 

  3. max = buf[i];
    4.

遍历数组，找出最大值。该函数中，以下语句：

    

  1. return max;
    2.

返回最大值。

上述代码中，以下代码：

    

  1. int main()
    2. 

  2. {
    3. 

  3. int data[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 0};
    4.

在主函数中，定义一个整型数组data，并初始化为10个整数。

上述代码中，以下代码：

    

  1. int (*p)(int*, int);
    2.

定义一个函数指针，该指针指向的函数必须返回整型数，并且包含两个参数，一个是整型指针变量，另一个是整型变量。

上述代码中，以下代码：

    

  1. p = min;
    2.

将函数名min赋值给函数指针p。

注意：赋值时，函数名所对应的函数的返回值和参数类型必须与函数指针要求的一致。

上述代码中，以下代码：

    

  1. printf("data中的最小值是%d\n", p(data, 10));
    2.

使用函数指针p调用函数min。

上述代码中，以下代码：

    

  1. p = max;
    2.

将函数名max赋值给函数指针p。

上述代码中，以下代码：

    

  1. printf("data中的最大值是%d\n", p(data, 10));
    2.

使用函数指针p调用函数max。

5.3 完整代码

本案例的完整代码如下所示：

    

  1. #include <stdio.h>
    2. 

  2. int min(int *buf, int size)
    3. 

  3. {
    4. 

  4. int min = buf[0];
    5. 

  5. for (int i = 0; i < size; i++)
    6. 

  6. if (buf[i] < min)
    7. 

  7. min = buf[i];
    8. 

  8. return min;
    9. 

  9. }
    10. 

  10. int max(int *buf, int size)
    11. 

  11. {
    12. 

  12. int max = buf[0];
    13. 

  13. for (int i = 0; i < size; i++)
    14. 

  14. if (buf[i] > max)
    15. 

  15. max = buf[i];
    16. 

  16. return max;
    17. 

  17. }
    18. 

  18. int main()
    19. 

  19. {
    20. 

  20. int data[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 0};
    21. 

  21. int (*p)(int*, int);
    22. 

  22. p = min;
    23. 

  23. printf("data中的最小值是%d\n", p(data, 10));
    24. 

  24. p = max;
    25. 

  25. printf("data中的最大值是%d\n", p(data, 10));
    26. 

  26. return 0;
    27. 

  27. }
    28.

6 函数指针的使用(续1)

6.1 问题

利用不同的排序规则排序。

6.2 步骤

实现此案例需要按照如下步骤进行。

步骤一：在主程序中，定义一个数组

代码如下：

    

  1. #include <stdio.h>
    2. 

  2. int main()
    3. 

  3. {
    4. 

  4. int a[10] = {1,2,3,4,5,6,7,8,9,0};
    5. 

  5. return 0;
    6. 

  6. }
    7.

步骤二：定义数组打印函数

代码如下：

    

  1. #include <stdio.h>
    2. 

  2. void print(int* a, int n)
    3. 

  3. {
    4. 

  4. for (int i=0; i<n; i++) {
    5. 

  5. printf("%d ", a[i]);
    6. 

  6. }
    7. 

  7. printf("\n");
    8. 

  8. }
    9. 

  9. int main()
    10. 

  10. {
    11. 

  11. int a[10] = {1,2,3,4,5,6,7,8,9,0};
    12. 

  12. print(a, 10);
    13. 

  13. return 0;
    14. 

  14. }
    15.

步骤三：定义带排序规则的排序函数

排序方法采用冒泡方法。

代码如下：

    

  1. #include <stdio.h>
    2. 

  2. void print(int* a, int n)
    3. 

  3. {
    4. 

  4. for (int i=0; i<n; i++) {
    5. 

  5. printf("%d ", a[i]);
    6. 

  6. }
    7. 

  7. printf("\n");
    8. 

  8. }
    9. 

  9. int rule1(int x, int y)
    10. 

  10. {
    11. 

  11. return x - y;
    12. 

  12. }
    13. 

  13. void sort(int* a, int n, int (*f)(int, int))
    14. 

  14. {
    15. 

  15. for (int i=0; i<n-1; i++) {
    16. 

  16. for (int j=0; j<n-i-1; j++) {
    17. 

  17. if (f(a[j], a[j+1])>0) {
    18. 

  18. int t = a[j];
    19. 

  19. a[j] = a[j+1];
    20. 

  20. a[j+1] = t;
    21. 

  21. }
    22. 

  22. }
    23. 

  23. }
    24. 

  24. }
    25. 

  25. int main()
    26. 

  26. {
    27. 

  27. int a[10] = {1,2,3,4,5,6,7,8,9,0};
    28. 

  28. print(a, 10);
    29. 

  29. sort(a, 10, rule1);
    30. 

  30. print(a, 10);
    31. 

  31. return 0;
    32. 

  32. }
    33.

上述代码中，以下代码：

    

  1. int rule1(int x, int y)
    2. 

  2. {
    3. 

  3. return x - y;
    4. 

  4. }
    5.

是排序规则，该函数返回形参x与y的差，如果返回值大于0，代表x大于y；如果返回值等于0，代表x等于y；如果返回值小于0，代表x小于y。

上述代码中，以下代码：

    

  1. void sort(int* a, int n, int (*f)(int, int))
    2.

是排序函数的函数头，该函数是一个无返回值的函数，函数名为sort，函数带有三个形参，第一个形参是一个整型指针变量，它用于接收需要排序的数据；第二个形参是一个整型变量，它用于接收需要排序的数据的个数；第三个形参是一个函数的指针变量，int表示该函数指针变量指向的函数的返回值为整型，f为函数指针变量的变量名，(int,int)代表该函数指针变量指向的函数有两个形参。

在主函数中，使用以下代码调用sort函数：

    

  1. sort(a, 10, rule1);
    2.

其中，第一个实参a为数组a的数组名，第二个实参10为数组a的数组长度，第三个实参rule1为函数名，该函数为排序规则。

上述代码中，以下代码：

    

  1. if (f(a[j], a[j+1])>0) {
    2. 

  2. int t = a[j];
    3. 

  3. a[j] = a[j+1];
    4. 

  4. a[j+1] = t;
    5. 

  5. }
    6.

是使用函数指针调用函数，指针变量f作为形参，接收实参传递过来的函数的入口地址，即rule1函数，使用f(a[j],a[j+1])调用rule1函数，其中，a[j]和a[j+1]是函数指针变量f指向的函数的两个实参，即函数rule1的两个实参。

步骤四：定义其它排序规则函数

代码如下：

    

  1. #include <stdio.h>
    2. 

  2. void print(int* a, int n)
    3. 

  3. {
    4. 

  4. for (int i=0; i<n; i++) {
    5. 

  5. printf("%d ", a[i]);
    6. 

  6. }
    7. 

  7. printf("\n");
    8. 

  8. }
    9. 

  9. int rule1(int x, int y)
    10. 

  10. {
    11. 

  11. return x - y;
    12. 

  12. }
    13. 

  13. int rule2(int x, int y)
    14. 

  14. {
    15. 

  15. return y - x;
    16. 

  16. }
    17. 

  17. int rule3(int x, int y)
    18. 

  18. {
    19. 

  19. return x%3 - y%3;
    20. 

  20. }
    21. 

  21. void sort(int* a, int n, int (*f)(int, int))
    22. 

  22. {
    23. 

  23. for (int i=0; i<n-1; i++) {
    24. 

  24. for (int j=0; j<n-i-1; j++) {
    25. 

  25. if (f(a[j], a[j+1])>0) {
    26. 

  26. int t = a[j];
    27. 

  27. a[j] = a[j+1];
    28. 

  28. a[j+1] = t;
    29. 

  29. }
    30. 

  30. }
    31. 

  31. }
    32. 

  32. }
    33. 

  33. int main()
    34. 

  34. {
    35. 

  35. int a[10] = {1,2,3,4,5,6,7,8,9,0};
    36. 

  36. print(a, 10);
    37. 

  37. sort(a, 10, rule1);
    38. 

  38. print(a, 10);
    39. 

  39. sort(a, 10, rule2);
    40. 

  40. print(a, 10);
    41. 

  41. sort(a, 10, rule3);
    42. 

  42. print(a, 10);
    43. 

  43. return 0;
    44. 

  44. }
    45.

6.3 完整代码

    

  1. #include <stdio.h>
    2. 

  2. void print(int* a, int n)
    3. 

  3. {
    4. 

  4. for (int i=0; i<n; i++) {
    5. 

  5. printf("%d ", a[i]);
    6. 

  6. }
    7. 

  7. printf("\n");
    8. 

  8. }
    9. 

  9. int rule1(int x, int y)
    10. 

  10. {
    11. 

  11. return x - y;
    12. 

  12. }
    13. 

  13. int rule2(int x, int y)
    14. 

  14. {
    15. 

  15. return y - x;
    16. 

  16. }
    17. 

  17. int rule3(int x, int y)
    18. 

  18. {
    19. 

  19. return x%3 - y%3;
    20. 

  20. }
    21. 

  21. void sort(int* a, int n, int (*f)(int, int))
    22. 

  22. {
    23. 

  23. for (int i=0; i<n-1; i++) {
    24. 

  24. for (int j=0; j<n-i-1; j++) {
    25. 

  25. if (f(a[j], a[j+1])>0) {
    26. 

  26. int t = a[j];
    27. 

  27. a[j] = a[j+1];
    28. 

  28. a[j+1] = t;
    29. 

  29. }
    30. 

  30. }
    31. 

  31. }
    32. 

  32. }
    33. 

  33. int main()
    34. 

  34. {
    35. 

  35. int a[10] = {1,2,3,4,5,6,7,8,9,0};
    36. 

  36. print(a, 10);
    37. 

  37. sort(a, 10, rule1);
    38. 

  38. print(a, 10);
    39. 

  39. sort(a, 10, rule2);
    40. 

  40. print(a, 10);
    41. 

  41. sort(a, 10, rule3);
    42. 

  42. print(a, 10);
    43. 

  43. return 0;
    44. 

  44. }
    45.
时间： 2024-11-07 05:24:10

C语言06指针进阶的相关文章

C语言 06 指针

int *p; //第一个*是象征意义. p = &a; 等价于 int *p = &a; //第二个*是不正确的 *p = &a; //第三个*是访问指针变量指向的存储空间. *p = 10; 等价于 a 的变量换成了 10;

C语言中指针和数组

C语言数组与指针的那些事儿 在C语言中,要说到哪一部分最难搞,首当其冲就是指针,指针永远是个让人又爱又恨的东西,用好了可以事半功倍,用不好,就会有改不完的bug和通不完的宵.但是程序员一般都有一种迷之自信,总认为自己是天选之人,明知山有虎,偏向虎山行,直到最后用C的人都要被指针虐一遍. 指针 首先,明确一个概念,指针是什么,一旦提到这个老生常谈且富有争议性的话题,那真是1000个人有1000种看法. 在国内的很多教材中,给出的定义一般就是"指针就是地址",从初步理解指针的角度来说,这种

C#委托与C语言函数指针及函数指针数组

C#委托与C语言函数指针及函数指针数组 在使用C#时总会为委托而感到疑惑,但现在总新温习了一遍C语言后,才真正理解的委托. 其实委托就类似于C/C++里的函数指针,在函数传参时传递的是函数指针,在调用的时候通过指针访问这个函数. 在C语言中函数指针的申明如下: //可以理解为申明一个指着变量 Func ,它的类型是 返回Type(可以为 void )类型的参数,接收 (Type one,Type two,...)类型的//参数(可以不接受参数). Type *Func(Type one,Type

C语言的指针变量

C语言的指针变量 在C语言中,变量是固定范围的存储空间,它存储的是赋给他的值, 比如: int a = 12; /* 这里是定义一个整型变量a,并把12这个值存储在a的地址空间上 这个地址空间是系统随机分配的,对用户是透明的不用关心 */ 指针变量存储的是变量的地址, 比如: int a = 12 , *b; b = &a; /*如上,定义了一个整型变量a并赋值12,一个整型指针变量b 然后 用 & 取值运算符 取到变量a的地址空间值,存储到指针变量b中 此时变量b中存储的是变量a中的地址

黑 马 程 序 员_视频学习总结&lt;c语言&gt;----03 指针

---------------------- ASP.Net+Unity开发..Net培训.期待与您交流! ---------------------- 一.什么是指针? 用来存放变量地址的变量,就称为"指针变量". 二.指针的定义 一般形式:类名标识符  *指针变量名; int *p; float *q; "*"是一个说明符,用来说明这个变量是个指针变量,是不能省略的,但它不属于变量名的一部分 前面的类型标识符表示指针变量所指向的变量的类型,而且只能指向这种类型的

C语言的指针移位问题

先贴代码 #include <stdio.h> int main(void) { double a[]={1.1,2.2,3.3}; unsigned int b,c,d; b=&a[0]+1;c=&a[1];d=&a[2]; printf("diff -- %d", c-b); return 0; } 执行结果是 diff -- 0 这是32位的代码,所以可以用unsigned int类型来储存地址位. 由于a[0]是double类型,所以&

c语言函数指针实例

如果使用typedef 是这样的 //可以把一个小写字母变成大写 //char (*pFun)(char); typedef char (*PTRFUN)(char); PTRFUN pFun; char glFun(char a){ return a & 223;} void print(int a,PTRFUN call){ cout<<call(a)<<endl;}void main() { pFun = glFun; print('a',pFun);} 如果不使用t

go语言之指针

数组 Arrays 数组是内置(build-in)类型,是一组同类型数据的集合,它是值类型,通过从0开始的下标索引访问元素值.在初始化后长度是固定的,无法修改其长度.当作为方法的入参传入时将复制一份数组而不是引用同一指针.数组的长度也是其类型的一部分,通过内置函数len(array)获取其长度. 在开始前先了解指针与地址: Go 语言中指针是很容易学习的,Go 语言中使用指针可以更简单的执行一些任务,变量是一种使用方便的占位符,用于引用计算机内存地址,Go 语言的取地址符是 &,放到一个变量前使

IOS开发系列--C语言之指针

概览 指针是C语言的精髓,但是很多初学者往往对于指针的概念并不深刻,以至于学完之后随着时间的推移越来越模糊,感觉指针难以掌握,本文通过简单的例子试图将指针解释清楚,今天的重点有几个方面: 什么是指针 数组和指针 函数指针 什么是指针 存放变量地址的变量我们称之为"指针变量",简单的说变量p中存储的是变量a的地址,那么p就可以称为是指针变量,或者说p指向a.当我们访问a变量的时候其实是程序先根据a取得a对应的地址,再到这个地址对应的存储空间中拿到a的值,这种方式我们称之为"直接