程序博客网 > 腾讯分析 没数据

C语言06指针进阶

来源：互联网 发布：腾讯分析 没数据 编辑：程序博客网 时间：2024/05/23 02:07


1 指针的使用

1.1 问题

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

1.2 步骤

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

步骤一：指针的使用

代码如下所示：

  1. #include <stdio.h>
  3. void swap(int *a, int *b)
  4. {
  5.     int tmp = *a;
  6.     *a = *b;
  7.     *b = tmp;
  8. }
  10. int main()
  11. {
  12.     int a = 10;
  13.     int *p = &a;
  14.     printf("a = %d\n", *p);
  15.     
  16.     printf("p = %p\n", p);
  17.     p = p + 1;
  18.     printf("p + 1 = %p\n", p);
  19.     
  20.     p = p - 1;
  21.     printf("p - 1 = %p\n", p);
  22.     
  23.     int b = 20;
  24.     printf("a = %d, b = %d\n", a, b);
  25.     swap(&a, &b);
  26.     printf("a = %d, b = %d\n", a, b);
  28.     const int *p1 = &a;
  29.     //*p1 = 30;
  30.     p1 = &b;
  31.     
  32.     int *const p2 = &a;
  33.     *p2 = 40;
  34.     //p2 = &b;
  35.     
  36.     p = NULL;
  37.     if (p)
  38.         printf("p = %p\n", p);
  40.     return 0;
  41. }

上述代码中，以下代码：

  1. void swap(int *a, int *b)
  2. {
  3.     int tmp = *a;
  4.     *a = *b;
  5.     *b = tmp;
  6. }

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

  1.     int tmp = *a;
  2.     *a = *b;
  3.     *b = tmp;

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

上述代码中，以下代码：

  1.     int a = 10;
  2.     int *p = &a;
  3.     printf("a = %d\n", *p);

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

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

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

上述代码中，以下代码：

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

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

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

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

上述代码中，以下代码：

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

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

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

上述代码中，以下代码：

  1.     int b = 20;
  2.     printf("a = %d, b = %d\n", a, b);
  3.     swap(&a, &b);
  4.     printf("a = %d, b = %d\n", a, b);

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

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

下一步，调用函数swap。

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

上述代码中，以下代码：

  1.     const int *p1 = &a;
  2.     //*p1 = 30;
  3.     p1 = &b;

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

上述代码中，以下代码：

  1.     int *const p2 = &a;
  2.     *p2 = 40;
  3.     //p2 = &b;

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

上述代码中，以下代码：

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

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

1.3 完整代码

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

  1. #include <stdio.h>
  3. void swap(int *a, int *b)
  4. {
  5.     int tmp = *a;
  6.     *a = *b;
  7.     *b = tmp;
  8. }
  10. int main()
  11. {
  12.     int a = 10;
  13.     int *p = &a;
  14.     printf("a = %d\n", *p);
  15.     
  16.     printf("p = %p\n", p);
  17.     p = p + 1;
  18.     printf("p + 1 = %p\n", p);
  19.     
  20.     p = p - 1;
  21.     printf("p - 1 = %p\n", p);
  22.     
  23.     int b = 20;
  24.     printf("a = %d, b = %d\n", a, b);
  25.     swap(&a, &b);
  26.     printf("a = %d, b = %d\n", a, b);
  28.     const int *p1 = &a;
  29.     //*p1 = 30;
  30.     p1 = &b;
  31.     
  32.     int *const p2 = &a;
  33.     *p2 = 40;
  34.     //p2 = &b;
  35.     
  36.     p = NULL;
  37.     if (p)
  38.         printf("p = %p\n", p);
  40.     return 0;
  41. }

2 二级指针的应用

2.1 问题

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

2.2 步骤

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

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

代码如下所示：

  1. #include <stdio.h>
  3. int main()
  4. {
  5.     char *name[] = {"zhangsan", "lisi", "wangwu", "zhaoliu"};
  6.     char **p = name;
  7.     
  8.     for (int i = 0; i < 4; i++)
  9.         printf("%s\n", p[i]);
  11.     return 0;
  12. }

上述代码中，以下代码：

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

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

上述代码中，以下代码：

  1.     char **p = name;

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

上述代码中，以下代码：

  1.     for (int i = 0; i < 4; i++)
  2.         printf("%s\n", p[i]);

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

2.3 完整代码

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

  1. #include <stdio.h>
  3. int main()
  4. {
  5.     char *name[] = {"zhangsan", "lisi", "wangwu", "zhaoliu"};
  6.     char **p = name;
  7.     
  8.     for (int i = 0; i < 4; i++)
  9.         printf("%s\n", p[i]);
  11.     return 0;
  12. }

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

3.1 问题

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

3.2 步骤

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

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

代码如下所示：

  1. #include <stdio.h>
  3. int convert(char **str)
  4. {
  5.     int num = 0;
  6.     while (**str)
  7.     {
  8.         if (**str >= '0' && **str <= '9')
  9.             num = num * 10 + **str - '0';
  10.         else
  11.             break;
  12.         (*str)++;
  13.     }
  14.     
  15.     return num;
  16. }
  18. int main()
  19. {
  20.     char str[] = "1234abc";
  21.     char *p = str;
  22.     printf("%d\n", convert(&p));
  23.     printf("%s\n", p);
  25.     return 0;
  26. }

上述代码中，以下代码：

  1. int convert(char **str)
  2. {
  3.     int num = 0;
  4.     while (**str)
  5.     {
  6.         if (**str >= '0' && **str <= '9')
  7.             num = num * 10 + **str - '0';
  8.         else
  9.             break;
  10.         (*str)++;
  11.     }
  12.     
  13.     return num;
  14. }

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

  1.     int num = 0;

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

  1.         if (**str >= '0' && **str <= '9')
  2.             num = num * 10 + **str - '0';

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

  1.     while (**str)
  2.     {
  3.         if (**str >= '0' && **str <= '9')
  4.             num = num * 10 + **str - '0';
  5.         else
  6.             break;
  7.         (*str)++;
  8.     }

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

  1.     return num;

返回，转换后的数字。

上述代码中，以下代码：

  1. int main()
  2. {
  3.     char str[] = "1234abc";
  4.     char *p = str;
  5.     printf("%d\n", convert(&p));
  6.     printf("%s\n", p);
  8.     return 0;
  9. }

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

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

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

最后，打印剩余的字符。

3.3 完整代码

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

  1. #include <stdio.h>
  3. int convert(char **str)
  4. {
  5.     int num = 0;
  6.     while (**str)
  7.     {
  8.         if (**str >= '0' && **str <= '9')
  9.             num = num * 10 + **str - '0';
  10.         else
  11.             break;
  12.         (*str)++;
  13.     }
  14.     
  15.     return num;
  16. }
  18. int main()
  19. {
  20.     char str[] = "1234abc";
  21.     char *p = str;
  22.     printf("%d\n", convert(&p));
  23.     printf("%s\n", p);
  25.     return 0;
  26. }

4 void*的基本用法

4.1 问题

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

4.2 步骤

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

步骤一：void*的基本用法

代码如下所示：

  1. #include <stdio.h>
  3. int main()
  4. {
  5.     int a = 10;
  6.     int *p = &a;
  7.     
  8.     void *p1 = p;
  9.     //*p1 = 20;
  10.     *(int*)p1 = 20;
  11.     printf("a = %d\n", *(int*)p1);
  13.     return 0;
  14. }

上述代码中，以下代码：

  1.     int a = 10;

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

上述代码中，以下代码：

  1.     int *p = &a;

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

上述代码中，以下代码：

  1.     void *p1 = p;

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

上述代码中，以下代码：

  1.     //*p1 = 20;

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

上述代码中，以下代码：

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

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

4.3 完整代码

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

  1. #include <stdio.h>
  3. int main()
  4. {
  5.     int a = 10;
  6.     int *p = &a;
  7.     
  8.     void *p1 = p;
  9.     //*p1 = 20;
  10.     *(int*)p1 = 20;
  11.     printf("a = %d\n", *(int*)p1);
  13.     return 0;
  14. }

5 函数指针的使用

5.1 问题

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

5.2 步骤

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

步骤一：函数指针的使用

代码如下所示：

  1. #include <stdio.h>
  3. int min(int *buf, int size)
  4. {
  5.     int min = buf[0];
  6.     for (int i = 0; i < size; i++)
  7.         if (buf[i] < min)
  8.             min = buf[i];
  9.     
  10.     return min;
  11. }
  13. int max(int *buf, int size)
  14. {
  15.     int max = buf[0];
  16.     for (int i = 0; i < size; i++)
  17.         if (buf[i] > max)
  18.             max = buf[i];
  19.     
  20.     return max;
  21. }
  23. int main()
  24. {
  25.     int data[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 0};
  26.     int (*p)(int*, int);
  27.     
  28.     p = min;
  29.     printf("data中的最小值是%d\n", p(data, 10));
  30.     
  31.     p = max;
  32.     printf("data中的最大值是%d\n", p(data, 10));
  33.     
  34.     return 0;
  35. }

上述代码中，以下代码：

  1. int min(int *buf, int size)
  2. {
  3.     int min = buf[0];
  4.     for (int i = 0; i < size; i++)
  5.         if (buf[i] < min)
  6.             min = buf[i];
  7.     
  8.     return min;
  9. }

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

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

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

该函数中，以下语句：

  1.     int min = buf[0];

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

  1.     for (int i = 0; i < size; i++)
  2.         if (buf[i] < min)
  3.             min = buf[i];

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

  1.     return min;

返回最小值。

上述代码中，以下代码：

  1. int max(int *buf, int size)
  2. {
  3.     int max = buf[0];
  4.     for (int i = 0; i < size; i++)
  5.         if (buf[i] > max)
  6.             max = buf[i];
  7.     
  8.     return max;
  9. }

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

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

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

该函数中，以下语句：

  1.     int max = buf[0];

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

  1.     for (int i = 0; i < size; i++)
  2.         if (buf[i] > max)
  3.             max = buf[i];

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

  1.     return max;

返回最大值。

上述代码中，以下代码：

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

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

上述代码中，以下代码：

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

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

上述代码中，以下代码：

  1.     p = min;

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

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

上述代码中，以下代码：

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

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

上述代码中，以下代码：

  1.     p = max;

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

上述代码中，以下代码：

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

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

5.3 完整代码

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

  1. #include <stdio.h>
  3. int min(int *buf, int size)
  4. {
  5.     int min = buf[0];
  6.     for (int i = 0; i < size; i++)
  7.         if (buf[i] < min)
  8.             min = buf[i];
  9.     
  10.     return min;
  11. }
  13. int max(int *buf, int size)
  14. {
  15.     int max = buf[0];
  16.     for (int i = 0; i < size; i++)
  17.         if (buf[i] > max)
  18.             max = buf[i];
  19.     
  20.     return max;
  21. }
  23. int main()
  24. {
  25.     int data[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 0};
  26.     int (*p)(int*, int);
  27.     
  28.     p = min;
  29.     printf("data中的最小值是%d\n", p(data, 10));
  30.     
  31.     p = max;
  32.     printf("data中的最大值是%d\n", p(data, 10));
  33.     
  34.     return 0;
  35. }

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

6.1 问题

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

6.2 步骤

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

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

代码如下：

  1. #include <stdio.h>
  3. int main()
  4. {
  5.     int a[10] = {1,2,3,4,5,6,7,8,9,0};
  6.     
  7.     return 0;
  8. }

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

代码如下：

  1. #include <stdio.h>
  3. void print(int* a, int n)
  4. {
  5.     for (int i=0; i<n; i++) {
  6.         printf("%d ", a[i]);
  7.     }
  8.     printf("\n");
  9. }
  11. int main()
  12. {
  13.     int a[10] = {1,2,3,4,5,6,7,8,9,0};
  14.     print(a, 10);
  15.     
  16.     return 0;
  17. }

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

排序方法采用冒泡方法。

代码如下：

  1. #include <stdio.h>
  3. void print(int* a, int n)
  4. {
  5.     for (int i=0; i<n; i++) {
  6.         printf("%d ", a[i]);
  7.     }
  8.     printf("\n");
  9. }
  10. int rule1(int x, int y)
  11. {
  12.     return x - y;
  13. }
  14. void sort(int* a, int n, int (*f)(int, int))
  15. {
  16.     for (int i=0; i<n-1; i++) {
  17.         for (int j=0; j<n-i-1; j++) {
  18.             if (f(a[j], a[j+1])>0) {
  19.                 int t = a[j];
  20.                 a[j] = a[j+1];
  21.                 a[j+1] = t;
  22.             }
  23.         }
  24.     }
  25. }
  26. int main()
  27. {
  28.     int a[10] = {1,2,3,4,5,6,7,8,9,0};
  29.     print(a, 10);
  30.     
  31.     sort(a, 10, rule1);
  32.     print(a, 10);
  33.     
  34.     return 0;
  35. }

上述代码中，以下代码：

  1. int rule1(int x, int y)
  2. {
  3.     return x - y;
  4. }

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

上述代码中，以下代码：

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

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

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

  1.     sort(a, 10, rule1);

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

上述代码中，以下代码：

  1.             if (f(a[j], a[j+1])>0) {
  2.                 int t = a[j];
  3.                 a[j] = a[j+1];
  4.                 a[j+1] = t;
  5.             }

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

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

代码如下：

  1. #include <stdio.h>
  3. void print(int* a, int n)
  4. {
  5.     for (int i=0; i<n; i++) {
  6.         printf("%d ", a[i]);
  7.     }
  8.     printf("\n");
  9. }
  10. int rule1(int x, int y)
  11. {
  12.     return x - y;
  13. }
  14. int rule2(int x, int y)
  15. {
  16.     return y - x;
  17. }
  18. int rule3(int x, int y)
  19. {
  20.     return x%3 - y%3;
  21. }
  22. void sort(int* a, int n, int (*f)(int, int))
  23. {
  24.     for (int i=0; i<n-1; i++) {
  25.         for (int j=0; j<n-i-1; j++) {
  26.             if (f(a[j], a[j+1])>0) {
  27.                 int t = a[j];
  28.                 a[j] = a[j+1];
  29.                 a[j+1] = t;
  30.             }
  31.         }
  32.     }
  33. }
  34. int main()
  35. {
  36.     int a[10] = {1,2,3,4,5,6,7,8,9,0};
  37.     print(a, 10);
  38.     
  39.     sort(a, 10, rule1);
  40.     print(a, 10);
  41.     
  42.     sort(a, 10, rule2);
  43.     print(a, 10);
  44.     
  45.     sort(a, 10, rule3);
  46.     print(a, 10);
  47.     
  48.     return 0;
  49. }

6.3 完整代码

  1. #include <stdio.h>
  3. void print(int* a, int n)
  4. {
  5.     for (int i=0; i<n; i++) {
  6.         printf("%d ", a[i]);
  7.     }
  8.     printf("\n");
  9. }
  10. int rule1(int x, int y)
  11. {
  12.     return x - y;
  13. }
  14. int rule2(int x, int y)
  15. {
  16.     return y - x;
  17. }
  18. int rule3(int x, int y)
  19. {
  20.     return x%3 - y%3;
  21. }
  22. void sort(int* a, int n, int (*f)(int, int))
  23. {
  24.     for (int i=0; i<n-1; i++) {
  25.         for (int j=0; j<n-i-1; j++) {
  26.             if (f(a[j], a[j+1])>0) {
  27.                 int t = a[j];
  28.                 a[j] = a[j+1];
  29.                 a[j+1] = t;
  30.             }
  31.         }
  32.     }
  33. }
  34. int main()
  35. {
  36.     int a[10] = {1,2,3,4,5,6,7,8,9,0};
  37.     print(a, 10);
  38.     
  39.     sort(a, 10, rule1);
  40.     print(a, 10);
  41.     
  42.     sort(a, 10, rule2);
  43.     print(a, 10);
  44.     
  45.     sort(a, 10, rule3);
  46.     print(a, 10);
  47.     
  48.     return 0;
  49. }







0 0
腾讯分析 没数据 腾讯分析 没数据
原创粉丝点击
热门IT博客
网络打鱼赌博游戏解密网络打鱼赌博游戏解密
win10游戏优化版win10游戏优化版
php短信接口开发实例
海岛奇兵火炮升级数据
有朋自远方来不亦说乎
网络诈骗包括哪些方面
淘宝四川正品小店售假
日志系统 python
折纸布施知子
单片机最小系统组成
哈利波特三人组 知乎
人工智能不需要约束
小鸡模拟器支持mac吗
单页面优化
咨询师网络教育平台
手机短信同步软件
什么软件照相好看
2016年网络热点事件
ipad越狱必装软件
android读取串口数据
热门问题 老师的惩罚 人脸识别 我在镇武司摸鱼那些年 重生之率土为王 我在大康的咸鱼生活 盘龙之生命进化 天生仙种 凡人之先天五行 春回大明朝 姑娘不必设防，我是瞎子 黄陂木兰 黄陂邮编 黄陂区邮编 武汉黄陂区 黄陂南路 黄陂旅馆 黄陂旅游 湖北黄陂 黄陂区15天预报 黄陂木兰草原 黄陂旅游景点 黎黄陂路街头博物馆 武汉市黄陂区邮编 黄陂热线论坛 武汉黄陂区邮编 黄陂木兰天池 黄陂旅游景点大全 黄陂有什么好玩的地方 武汉市黄陂区 2019年10月1号黄陂火灾事故 黄陵 黄陵县 西安黄陵 黄陵集团 陕西黄陵 黄陵县旅游 黄陵森林公园 黄陵属于哪个市 黄陵矿业集团有限责任公司 延安黄陵酒店 黄陵桥山滨湖酒店 黄雀 黄雀叫声 黄雀在后 黄雀怎么养 黄雀叫声叫声大全 黄雀叫的声音 行动代号黄雀 黄雀叫声大全 黄雀吧 黄雀图片

程序博客网，程序员的互联网技术博客家园。csdn论坛精品 msdn技术资料都在这里