C语言05指针基础

最新推荐文章于 2024-05-29 17:38:37 发布
最新推荐文章于 2024-05-29 17:38:37 发布
阅读量1k 收藏
点赞数
分类专栏： C语言 文章标签： c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/opera95/article/details/51201175
版权

1 局部变量和全局变量

1.1 问题

分别定义一个局部变量和全局变量，测试生命期限和作用域。

1.2 步骤

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

步骤一：局部变量和全局变量

代码如下所示：


    
    
  1. #include <stdio.h>
  3. /*auto*/ int x = 1000; 
  5. void f1(int a) 
  6. {
  7.     a = 10;
  8.     auto int x = 20;
  9.     static int y = 30; 
  10.     y++;
  11.     x++;
  12.     printf("in f1(),a=%d,x=%d,y=%d\n",a,x,y);
  13. }
  15. void f2()
  16. {
  17.     printf("in f2(),x=%d\n",x);
  18.     x = 2000;
  19. }
  21. void f3()
  22. {
  23.     printf("in f3(),x=%d\n",x);
  24. }
  26. int main()
  27. {
  28.     int x = 30,b=100;
  29.     f1(b);
  30.     f1(b);
  31.     printf("in main(),b=%d,x=%d\n",b,x);
  32.     f2();
  33.     f3();
  35.     return 0;
  36. }

上述代码中，以下代码：


    
    
  1. /*auto*/ int x = 1000;

定义了一个全局变量x，该变量在所有函数中共享。

上述代码中，以下代码：


    
    
  1. void f1(int a) 
  2. {
  3.     a = 10;
  4.     auto int x = 20;
  5.     static int y = 30; 
  6.     y++;
  7.     x++;
  8.     printf("in f1(),a=%d,x=%d,y=%d\n",a,x,y);
  9. }

定义了一个函数f1，该函数没有返回值，有一个参数是一个整型变量a。该函数中以下语句：


    
    
  1.     a = 10;

将参数a赋值为10，参数a是局部变量，只能用在f1函数中。该函数中以下语句：


    
    
  1.     auto int x = 20;

定义了另一个局部变量x，也只能用在f1函数中。前面的auto关键字可有可无。该函数中以下语句：


    
    
  1.     static int y = 30;

定义了一个static局部变量y，也只能用在f1函数中，但函数返回后该变量不会被释放，直到主函数退出时，它才会被释放。该函数中以下语句：


    
    
  1.     y++;
  2.     x++;

对局部变量x和y进行自增操作。

注意：在函数f1中，定义了局部变量x，而在该函数的上面还定义全局变量x，这样在函数f1中，有两个x，但C语言规定，在这种情况下，局部变量x将隐藏全局变量x，即全局变量x此时不起作用。

该函数中以下语句：


    
    
  1.     printf("in f1(),a=%d,x=%d,y=%d\n",a,x,y);

使用函数printf输出局部变量a和x的值，以及静态局部变量y的值。

上述代码中，以下代码：


    
    
  1. void f2()
  2. {
  3.     printf("in f2(),x=%d\n",x);
  4.     x = 2000;
  5. }

定义了一个无参无返回值的函数f2。该函数中以下语句：


    
    
  1.     x = 2000;

对全局变量x进行赋值。

上述代码中，以下代码：


    
    
  1. void f3()
  2. {
  3.     printf("in f3(),x=%d\n",x);
  4. }

定义了一个无参无返回值的函数f2。该函数中以下语句：


    
    
  1.     printf("in f3(),x=%d\n",x);

对全局变量x进行输出。

上述代码中，以下代码：


    
    
  1. int main()
  2. {
  3.     int x = 30,b=100;

在主函数中，定义了两个局部变量x和b，并分别初始化为30和100。这两个局部变量只能用在main函数中。

上述代码中，以下代码：


    
    
  1.     f1(b);
  2.     f1(b);

两次调用函数f1，并用局部变量b作为实参。

注意：两次调用中，函数f1中的静态局部变量y输出值不一样。因为static关键字使该变量在函数f1返回后并不释放，所以第二次调用时，其值会在上一次调用返回前的基础上发生变化。

上述代码中，以下代码：


    
    
  1.     printf("in main(),b=%d,x=%d\n",b,x);

使用函数printf输出局部变量b和局部变量x的值。

注意：在函数main中，定义了局部变量x，而在该函数的上面还定义全局变量x，这样在函数main中，有两个x，但C语言规定，在这种情况下，局部变量x将隐藏全局变量x，即全局变量x此时不起作用。

上述代码中，以下代码：


    
    
  1.     f2();
  2.     f3();

调用函数f2和f3，从输出的值上可以看出，全局变量可以在所有函数中共享。

1.3 完整代码

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


    
    
  1. #include <stdio.h>
  3. /*auto*/ int x = 1000; 
  5. void f1(int a) 
  6. {
  7.     a = 10;
  8.     auto int x = 20;
  9.     static int y = 30; 
  10.     y++;
  11.     x++;
  12.     printf("in f1(),a=%d,x=%d,y=%d\n",a,x,y);
  13. }
  15. void f2()
  16. {
  17.     printf("in f2(),x=%d\n",x);
  18.     x = 2000;
  19. }
  21. void f3()
  22. {
  23.     printf("in f3(),x=%d\n",x);
  24. }
  26. int main()
  27. {
  28.     int x = 30,b=100;
  29.     f1(b);
  30.     f1(b);
  31.     printf("in main(),b=%d,x=%d\n",b,x);
  32.     f2();
  33.     f3();
  35.     return 0;
  36. }

2 指针的基本用法

2.1 问题

定义一个int类型的指针，指向一个整型变量，然后分别使用&和*取得地址或者数据。

2.2 步骤

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

步骤一：指针的基本用法

代码如下所示：


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

上述代码中，以下代码：


    
    
  1.     int a = 10;

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

上述代码中，以下代码：


    
    
  1.     int *p;
  2.     p = &a;

定义了一个整型指针变量p，并使用取地址运算符&将整型变量a的地址赋值给p。

上述代码中，以下代码：


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

使用函数printf输出指针变量p的值和整型变量a的地址值。从输出结果可以看出，指针变量p中存放的就是整型变量a的地址值。

上述代码中，以下代码：


    
    
  1.     printf("a = %d\n", a);

使用函数printf输出整型变量a的值。

上述代码中，以下代码：


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

使用函数printf输出指针变量p所指向的地址单元的值。由于指针变量p被赋值成了整型变量a的地址值，所以，p就指向a的地址，所以输出的就是a的值。

2.3 完整代码

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


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

3 指针的优势

3.1 问题

使用指针实现交换变量值的函数swap()，同时编写不使用指针交换失败的函数做对比。

3.2 步骤

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

步骤一：指针的优势

代码如下所示：


    
    
  1. #include <stdio.h>
  3. void swap(int a, int b)
  4. {
  5.     printf("in swap()  a = %d, b = %d\n", a, b);
  6.     int tmp = a;
  7.     a = b;
  8.     b = tmp;
  9.     printf("in swap()  a = %d, b = %d\n", a, b);
  10. }
  12. void swap1(int *a, int *b)
  13. {
  14.     printf("in swap1()  *a = %d, *b = %d\n", *a, *b);
  15.     int tmp = *a;
  16.     *a = *b;
  17.     *b = tmp;
  18.     printf("in swap1()  *a = %d, *b = %d\n", *a, *b);
  19. }
  21. int main()
  22. {
  23.     int x = 10, y = 20;
  24.     printf("in main()  x = %d, y = %d\n", x, y);
  25.     swap(x, y);
  26.     printf("in main()  x = %d, y = %d\n", x, y);
  27.     swap1(&x, &y);
  28.     printf("in main()  x = %d, y = %d\n", x, y);
  30.     return 0;
  31. }

上述代码中，以下代码：


    
    
  1. void swap(int a, int b)
  2. {
  3.     printf("in swap()  a = %d, b = %d\n", a, b);
  4.     int tmp = a;
  5.     a = b;
  6.     b = tmp;
  7.     printf("in swap()  a = %d, b = %d\n", a, b);
  8. }

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


    
    
  1.     printf("in swap()  a = %d, b = %d\n", a, b);

使用函数printf输出形参a和b从调用函数传入的值。在该函数中，以下语句：


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

通过第三个变量tmp，将整型变量a和b的值进行交换。在该函数中，以下语句：


    
    
  1.     printf("in swap()  a = %d, b = %d\n", a, b);

使用函数printf输出形参a和b交换后的值。

上述代码中，以下代码：


    
    
  1. void swap1(int *a, int *b)
  2. {
  3.     printf("in swap1()  *a = %d, *b = %d\n", *a, *b);
  4.     int tmp = *a;
  5.     *a = *b;
  6.     *b = tmp;
  7.     printf("in swap1()  *a = %d, *b = %d\n", *a, *b);
  8. }

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


    
    
  1.     printf("in swap1()  *a = %d, *b = %d\n", *a, *b);

使用函数printf输出整型指针变量a和b指向的地址的值。在该函数中，以下语句：


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

通过第三个变量tmp，将整型指针变量a和b指向的地址的值进行交换。在该函数中，以下语句：


    
    
  1.     printf("in swap1()  *a = %d, *b = %d\n", *a, *b);

使用函数printf输出整型指针变量a和b指向地址的值交换后的值。

上述代码中，以下代码：


    
    
  1. int main()
  2. {
  3.     int x = 10, y = 20;

在主函数中定义两个整型变量x和y，并将它们初始化为10和20。

上述代码中，以下代码：


    
    
  1.     printf("in main()  x = %d, y = %d\n", x, y);

使用函数printf输出变量x和y的初始值。

上述代码中，以下代码：


    
    
  1.     swap(x, y);
  2.     printf("in main()  x = %d, y = %d\n", x, y);

首先，调用函数swap。

然后，使用函数printf输出整型变量x和y在调用函数swap后的变化情况。从输出结果可以看出，没有发生变化。因为swap函数定义的参数是整型变量，这时，实参到形参的传递过程是值传递，即仅将实参x和y的值传递给形参a和b，而形参a和b在函数swap中发生的变化并不会传回给实参。

上述代码中，以下代码：


    
    
  1.     swap1(&x, &y);
  2.     printf("in main()  x = %d, y = %d\n", x, y);

首先，调用函数swap1。

然后，使用函数printf输出整型变量x和y在调用函数swap1后的变化情况。从输出结果可以看出，确实发生了变化。因为swap1函数定义的参数是整型指针变量，实参将变量x和y的地址传给了形参a和b，在函数swap1中使用*a和*b操作的是指针a和b指向的地址单元的值，即变量x和y的值。

3.3 完整代码

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


    
    
  1. #include <stdio.h>
  3. void swap(int a, int b)
  4. {
  5.     printf("in swap()  a = %d, b = %d\n", a, b);
  6.     int tmp = a;
  7.     a = b;
  8.     b = tmp;
  9.     printf("in swap()  a = %d, b = %d\n", a, b);
  10. }
  12. void swap1(int *a, int *b)
  13. {
  14.     printf("in swap1()  *a = %d, *b = %d\n", *a, *b);
  15.     int tmp = *a;
  16.     *a = *b;
  17.     *b = tmp;
  18.     printf("in swap1()  *a = %d, *b = %d\n", *a, *b);
  19. }
  21. int main()
  22. {
  23.     int x = 10, y = 20;
  24.     printf("in main()  x = %d, y = %d\n", x, y);
  25.     swap(x, y);
  26.     printf("in main()  x = %d, y = %d\n", x, y);
  27.     swap1(&x, &y);
  28.     printf("in main()  x = %d, y = %d\n", x, y);
  30.     return 0;
  31. }

4 指针的优势(续1)

4.1 问题

使用指针做参数取函数的返回值，写一个函数，找出一个数组中的最大值和最小值。

4.2 步骤

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

步骤一：指针的优势(续1)

代码如下所示：


    
    
  1. #include <stdio.h>
  2. #include <time.h>
  3. #include <stdlib.h>
  5. void maxAndMin(int data[], int size, int *max, int *min)
  6. {
  7.     *max = data[0];
  8.     *min = data[0];
  9.     for (int i = 0; i < size; i++)
  10.     {
  11.         if (*max < data[i])
  12.             *max = data[i];
  13.         if (*min > data[i])
  14.             *min = data[i];
  15.     }
  16. }
  18. int main(int argc, const char * argv[])
  19. {
  20.     int data[10];
  21.     
  22.     srand((unsigned)time(0));
  23.     for (int i = 0; i < 10; i++)
  24.         data[i] = rand() % 100;
  25.     printf("数组中的数据为：");
  26.     for (int i = 0; i < 10; i++)
  27.         printf("%d ", data[i]);
  28.     printf("\n");
  29.     
  30.     int max;
  31.     int min;
  32.     maxAndMin(data, 10, &max, &min);
  33.     printf("最大值为：%d\n", max);
  34.     printf("最小值为：%d\n", min);
  36.     return 0;
  37. }

上述代码中，下面代码行：


    
    
  1. void maxAndMin(int data[], int size, int *max, int *min)

是自定义函数的函数头，该函数为无返回值函数，函数名为maxAndMin，函数有四个形参，第一个形参为一个数组，在此数组中找到最大值和最小值；第二个形参为数组的长度；第三个形参是一个指针变量，此参数用于将数组中的最大值带回主函数；第四个形参也是一个指针变量，此参数用于将数组中的最小值带回主函数。

上述代码中，下面代码行：


    
    
  1.     *max = data[0];
  2.     *min = data[0];

首先假定数组的最大值与最小值都是数组的第一个元素。

上述代码中，下面代码行：


    
    
  1.     for (int i = 0; i < size; i++)
  2.     {
  3.         if (*max < data[i])
  4.             *max = data[i];
  5.         if (*min > data[i])
  6.             *min = data[i];
  7.     }

遍历数组，逐个元素与最大值和最小值对比，如果比最大值大，替换最大值；如果比最小值小，则替换最小值。

上述代码中，下面代码行：


    
    
  1. int main(int argc, const char * argv[])
  2. {
  3.     int data[10];

在主函数中，定义数组data，有10个元素。

上述代码中，下面代码行：


    
    
  1.     srand((unsigned)time(0));
  2.     for (int i = 0; i < 10; i++)
  3.         data[i] = rand() % 100;
  4.     printf("数组中的数据为：");
  5.     for (int i = 0; i < 10; i++)
  6.         printf("%d ", data[i]);
  7.     printf("\n");

首先，为每个数组元素赋值成一个0~99之间的随机数。

然后，将数组中数据显示出来。

上述代码中，下面代码行：


    
    
  1.     int max;
  2.     int min;

定义两个变量，分别用于存储数组中的最大值和最小值。

上述代码中，下面代码行：


    
    
  1.     maxAndMin(data, 10, &max, &min);

调用maxAndMin函数，数组data作为第一个实参，第二个实参是数组data的长度，第三个实参是变量max的地址，这样可以将最大值带回来，第四个实参是变量min的地址，它用于带回最小值。

4.3 完整代码

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


    
    
  1. #include <stdio.h>
  2. #include <time.h>
  3. #include <stdlib.h>
  5. void maxAndMin(int data[], int size, int *max, int *min)
  6. {
  7.     *max = data[0];
  8.     *min = data[0];
  9.     for (int i = 0; i < size; i++)
  10.     {
  11.         if (*max < data[i])
  12.             *max = data[i];
  13.         if (*min > data[i])
  14.             *min = data[i];
  15.     }
  16. }
  18. int main(int argc, const char * argv[])
  19. {
  20.     int data[10];
  21.     
  22.     srand((unsigned)time(0));
  23.     for (int i = 0; i < 10; i++)
  24.         data[i] = rand() % 100;
  25.     printf("数组中的数据为：");
  26.     for (int i = 0; i < 10; i++)
  27.         printf("%d ", data[i]);
  28.     printf("\n");
  29.     
  30.     int max;
  31.     int min;
  32.     maxAndMin(data, 10, &max, &min);
  33.     printf("最大值为：%d\n", max);
  34.     printf("最小值为：%d\n", min);
  36.     return 0;
  37. }

5 指针的算术运算

5.1 问题

测试不同类型的指针的算术运算。

5.2 步骤

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

步骤一：指针的算术运算

代码如下所示：


    
    
  1. #include <stdio.h>
  3. int main()
  4. {
  5.     int a;
  6.     int *pa = &a;
  7.     printf("pa = %p, pa + 1 = %p\n", pa, pa + 1);
  8.     
  9.     short s;
  10.     short *ps = &s;
  11.     printf("ps = %p, ps + 1 = %p\n", ps, ps + 1);
  12.     
  13.     long l;
  14.     long *pl = &l;
  15.     printf("pl = %p, pl + 1 = %p\n", pl, pl + 1);
  16.     
  17.     char c;
  18.     char *pc = &c;
  19.     printf("pc = %p, pc + 1 = %p\n", pc, pc + 1);
  20.     
  21.     float f;
  22.     float *pf = &f;
  23.     printf("pf = %p, pf + 1 = %p\n", pf, pf + 1);
  24.     
  25.     double d;
  26.     double *pd = &d;
  27.     printf("pd = %p, pd + 1 = %p\n", pd, pd + 1);
  28.     
  29.     return 0;
  30. }

上述代码中,以下代码：


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

首先，定义了一个整型变量a。

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

最后，使用函数printf输出指针pa的值和pa+1的值。从输出结果可以看出，整型指针变量加1时，相当于加了1*sizeof（int），即4个字节。

上述代码中,以下代码：


    
    
  1.     short s;
  2.     short *ps = &s;
  3.     printf("ps = %p, ps + 1 = %p\n", ps, ps + 1);

首先，定义了一个短整型变量s。

然后，定义了一个短整型指针变量ps，并初始化为短整型变量s的地址。

最后，使用函数printf输出指针ps的值和ps+1的值。从输出结果可以看出，短整型指针变量加1时，相当于加了1*sizeof（short），即2个字节。

上述代码中,以下代码：


    
    
  1.     long l;
  2.     long *pl = &l;
  3.     printf("pl = %p, pl + 1 = %p\n", pl, pl + 1);

首先，定义了一个长整型变量l。

然后，定义了一个长整型指针变量pl，并初始化为长整型变量l的地址。

最后，使用函数printf输出指针pl的值和pl+1的值。从输出结果可以看出，长整型指针变量加1时，相当于加了1*sizeof（long），即8个字节。

上述代码中,以下代码：


    
    
  1.     char c;
  2.     char *pc = &c;
  3.     printf("pc = %p, pc + 1 = %p\n", pc, pc + 1);

首先，定义了一个字符型变量c。

然后，定义了一个字符型指针变量pc，并初始化为字符型变量c的地址。

最后，使用函数printf输出指针pc的值和pc+1的值。从输出结果可以看出，字符型指针变量加1时，相当于加了1*sizeof（char），即1个字节。

上述代码中,以下代码：


    
    
  1.     float f;
  2.     float *pf = &f;
  3.     printf("pf = %p, pf + 1 = %p\n", pf, pf + 1);

首先，定义了一个浮点型变量f。

然后，定义了一个浮点型指针变量pf，并初始化为浮点型变量f的地址。

最后，使用函数printf输出指针pf的值和pf+1的值。从输出结果可以看出，浮点型指针变量加1时，相当于加了1*sizeof（float），即4个字节。

上述代码中,以下代码：


    
    
  1.     double d;
  2.     double *pd = &d;
  3.     printf("pd = %p, pd + 1 = %p\n", pd, pd + 1);

首先，定义了一个双精度浮点型变量d。

然后，定义了一个双精度浮点型指针变量pd，并初始化为双精度浮点型变量d的地址。

最后，使用函数printf输出指针pd的值和pd+1的值。从输出结果可以看出，双精度浮点型指针变量加1时，相当于加了1*sizeof（double），即8个字节。

5.3 完整代码

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


    
    
  1. #include <stdio.h>
  3. int main()
  4. {
  5.     int a;
  6.     int *pa = &a;
  7.     printf("pa = %p, pa + 1 = %p\n", pa, pa + 1);
  8.     
  9.     short s;
  10.     short *ps = &s;
  11.     printf("ps = %p, ps + 1 = %p\n", ps, ps + 1);
  12.     
  13.     long l;
  14.     long *pl = &l;
  15.     printf("pl = %p, pl + 1 = %p\n", pl, pl + 1);
  16.     
  17.     char c;
  18.     char *pc = &c;
  19.     printf("pc = %p, pc + 1 = %p\n", pc, pc + 1);
  20.     
  21.     float f;
  22.     float *pf = &f;
  23.     printf("pf = %p, pf + 1 = %p\n", pf, pf + 1);
  24.     
  25.     double d;
  26.     double *pd = &d;
  27.     printf("pd = %p, pd + 1 = %p\n", pd, pd + 1);
  28.     
  29.     return 0;
  30. }

6 const的使用

6.1 问题

定义const的普通变量和const指针的三种方式，验证一下效果。

6.2 步骤

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

步骤一：const的使用

代码如下所示：


    
    
  1. #include <stdio.h>
  3. int main()
  4. {
  5.     int i1=5;
  6.     
  7.     const int i2 = 10;
  8.     //i2 = 6;
  9.     //i2++;
  10.     i1 = i2;
  11.     i1 = 100;
  12.     printf("i2=%d\n",i2);
  13.     
  14.     const int *p1 = &i2;
  15.     //*p1 = 200;
  16.     p1 = &i1;
  17.     
  18.     int * const p2 = &i2;
  19.     *p2 = 200;
  20.     //p2 = &i1;
  21.     printf("i2=%d\n",i2);
  22.     
  23.     return 0;
  24. }

上述代码中，以下代码：


    
    
  1.     int i1=5;

定义了一个整型变量i1，并初始化为5。

上述代码中，以下代码：


    
    
  1.     const int i2 = 10;

定义了一个const整型变量i2，并初始化为10。const是一个C语言的关键字，它限定变量i2不允许被改变，如以下代码：


    
    
  1.     //i2 = 6;
  2.     //i2++;

是错误的，如果不注释，将报编译错误。但以下代码：


    
    
  1.     i1 = i2;
  2.     i1 = 100;

是正确的，因为变量i1未被const关键字修饰。

上述代码中，以下代码：


    
    
  1.     const int *p1 = &i2;

使用关键字const修饰了一个整型指针变量。由于关键字const在*号的左边，所以此时限定不能改变的是指针p1指向的地址的值，如以下语句：


    
    
  1.     //*p1 = 200;

是错误的，因为*p1代表指针p1指向的地址的值。但以下代码:


    
    
  1.     p1 = &i1;

是正确的。因为关键字const在*号的左边并未限定指针p1本身不能改变。

上述代码中，以下代码：


    
    
  1.     int * const p2 = &i2;

同样使用关键字const修饰了一个整型指针变量。但由于关键字const在*号的右边，所以此时限定不能改变的是指针p1本身的值，如以下语句：


    
    
  1.     *p2 = 200;

是正确的。因为关键字const在*号的右边并未限定指针p1指向的地址的值。但以下代码:


    
    
  1.     //p2 = &i1;

是错误的，由于关键字const在*号的右边，所以此时指针p1本身的值不能改变。

6.3 完整代码

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


    
    
  1. #include <stdio.h>
  3. int main()
  4. {
  5.     int i1=5;
  6.     
  7.     const int i2 = 10;
  8.     //i2 = 6;
  9.     //i2++;
  10.     i1 = i2;
  11.     i1 = 100;
  12.     printf("i2=%d\n",i2);
  13.     
  14.     const int *p1 = &i2;
  15.     //*p1 = 200;
  16.     p1 = &i1;
  17.     
  18.     int * const p2 = &i2;
  19.     *p2 = 200;
  20.     //p2 = &i1;
  21.     printf("i2=%d\n",i2);
  22.     
  23.     return 0;
  24. }

7 指针和数组

7.1 问题

定义一个数组，然后赋值给指针，然后互相用对方的方式进行操作。

7.2 步骤

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

步骤一：指针和数组

代码如下所示：


    
    
  1. #include <stdio.h>
  3. int main()
  4. {
  5.     int arr[5] = {10, 20, 30, 4, 5};
  6.     int *po = arr;
  7.     for(int i = 0; i < 5; i++)
  8.     {
  9.         printf("arr=%d\n",*(arr+i));
  10.         printf("po=%d\n",*(po+i));
  11.         printf("arr[i]=%d\n",i[arr]);//*(arr+i)
  12.     }
  14.     printf("*po=%d\n",*po++);
  15.     printf("*po=%d\n",(*po)++);
  16.     printf("%d\n",*po);
  17.     po++;
  18.     printf("*po=%d\n",*po);
  19.     //arr = arr+1;//arr++;
  20.     //printf("*arr=%d\n",*arr);
  22.     return 0;
  23. }

上述代码中，以下代码：


    
    
  1.     int arr[5] = {10, 20, 30, 4, 5};

定义了一个整型数组arr，数组中有5个元素，并对数组进行了初始化。

上述代码中，以下代码：


    
    
  1.     int *po = arr;

定义了一个整型指针变量po，并初始化为数组名arr，这种赋值是合法的，因为数组名就是数组第一个元素arr[0]的地址。

上述代码中，以下代码：


    
    
  1.         printf("arr=%d\n",*(arr+i));

数组名arr是数组第一个元素arr[0]的地址。当i为0时，*（arr+i）等效于*arr，即数组第一个元素arr[0]。当i为1时，arr+1是数组第二个元素arr[1]的地址，*（arr+i）即数组第二个元素arr[1]。依次类推。

上述代码中，以下代码：


    
    
  1.         printf("po=%d\n",*(po+i));

使用函数printf输出指针po+i指向的地址的值，当i为0时，指针po+0就是数组名arr的值，而arr又是数组第一个元素arr[0]的地址，所以*（po+0）就是arr[0]。当i为1时，指针po+1就是数组名arr+1的值，而arr+1又是数组第二个元素arr[1]的地址，所以*（po+1）就是arr[1]。依次类推。

上述代码中，以下代码：


    
    
  1.         printf("arr[i]=%d\n",i[arr]);

i[arr]是一种不推荐使用的方法。i[arr]与arr[i]是等价的，在编译时分别被编译成*（i+arr）和*（arr+i），而它们是一回事。

上述代码中，以下代码：


    
    
  1.     printf("*po=%d\n",*po++);

由于*po++左右有两个运算符*和++，它们是同优先级的，结合性是自右向左，所以先计算++，但又由于++是后置，所以该语句等效于以下语句：


    
    
  1.     printf("*po=%d\n",*po);
  2.        po = po + 1;

即输出为*po=10；

上述代码中，以下代码：


    
    
  1.     printf("*po=%d\n",(*po)++);

同样是因为++是后置的，所以该语句等效于以下语句：


    
    
  1.     printf("*po=%d\n",*po);
  2.        *po = *po + 1;

即输出为*po=20；不是10的原因是上次等效时，进行了po = po + 1运算。

上述代码中，以下代码：


    
    
  1.     printf("%d\n",*po);

输出为*po=21，是因为上次等效时，进行了*po = *po + 1运算。

上述代码中，以下代码：


    
    
  1.     po++;
  2.     printf("*po=%d\n",*po);

输出为*po=30，因为po++再次改变了po的值。

上述代码中，以下代码：


    
    
  1.     //arr = arr+1;//arr++;
  2.     //printf("*arr=%d\n",*arr);

为错误的。因为数组名是一个常量，虽然它是数组第一个元素arr[0]的地址，但它不能改变。

7.3 完整代码

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


    
    
  1. #include <stdio.h>
  3. int main()
  4. {
  5.     int arr[5] = {10, 20, 30, 4, 5};
  6.     int *po = arr;
  7.     for(int i = 0; i < 5; i++)
  8.     {
  9.         printf("arr=%d\n",*(arr+i));
  10.         printf("po=%d\n",*(po+i));
  11.         printf("arr[i]=%d\n",i[arr]);//*(arr+i)
  12.     }
  14.     printf("*po=%d\n",*po++);
  15.     printf("*po=%d\n",(*po)++);
  16.     printf("%d\n",*po);
  17.     po++;
  18.     printf("*po=%d\n",*po);
  19.     //arr = arr+1;//arr++;
  20.     //printf("*arr=%d\n",*arr);
  22.     return 0;
  23. }









opera92
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C语言指针基础
12-15
C语言中的指针其实并没有那么可怕，我上传了一份C语言指针基础课件。欢迎大家下载。
C语言——指针（1.2.指针变量的定义和初始化）
一个努力的程序猿
10-27 2605
上一小节，我们了解到了关于变量的储存地址，并且了解到了变量名，变量的值，变量的地址之间的关系。简单回顾一下就是，需要存储的值存储在变量里面，通过访问变量的地址可以找到变量对应存储的值。 这一小结我们开始学习指针变量的定义和初始化： 指针的定义：存放变量的地址需要一种特殊类型的变量，而这种特殊的数据类型被称作指针。 指针变量：具有指针类型的变量，被成为指针变量，其定义形式如下： 类型关键字 *指针变量名 类型关键字代表指针变量要指向的变量的类型，即指针变量的类型（举个例子） int *pa; .
指针的定义、初始化、解引用
WWX2LN的博客
04-01 1729
1.指针的定义和初始化 （1）&a: 取地址符（单目运算符） a&b: 按位与（双目运算符） *的三种用法： (1) 乘法：3*4=12 (2) int *p=&a; //定义指针变量 (3) *p=100; //解引用 （2）int *p=&a; //定义整型指...
C语言 指针——指针变量的定义、初始化及解引用
最新发布
hangweijie的博客
05-29 1724
目录指针内存如何编址？如何对变量进行寻址？用什么类型的变量来存放变量的地址?如何显示变量的地址?​编辑使用未初始化的指针会怎样？NULL是什么？如何访问指针变量指向的存储单元中的数据？指针变量的定义和初始化
指针变量定义和初始化
热门推荐
fangyan_1229的博客
04-17 1万+
1.指针定义和初始化 2.指向数组的指针 指针数组 指针定义 类型 * ptr = xxx; 指针运算 * 寻址过程，根据地址找到内存单元，然后把里面的值给取出来。 取地址运算 & 指针变量的初始化 语法形式 存储类型 数据类型*指针名＝初始地址； 例： int *pa = &a; 注意事项 用变量地...
指针--指针变量的定义和初始化
ww1425408527的博客
06-05 2328
指向某变量的指针变量，通常称为某变量的指针，虽然指针变量中存放的是变量的地址值，二者在数值上相等，但在概念上变量的指针并不等同于变量的地址。而变量的指针是一个变量，其值是改变的。：定义一个可以指向整型数据1的指针变量pa，并用整型变量a的地址值对指针变量pa进行初始化，从而使指针变量pa具体的指向了整型变量a。并且，指针变量的定义只是声明了指针变量的名字及其所能指向的数据类型，并没有说明变量究竟指向了哪里。其中，类型关键字代表指针变量要指向的变量的数据类型，即指针变量的基类型（Base Type），
C语言初阶指针.zip
01-14
以上只是C语言指针基础的简单介绍，实际应用中还有更多高级用法，如指针数组、指针作为函数返回值等。深入理解和熟练运用指针是掌握C语言的关键，也是许多系统编程和底层开发的基础。通过学习"《C语言初阶指针》"，...
C语言——指针
01-07
C语言是一门基础语言，将C语言比作地基再合适不过了，像Python和Java的底层都是由C语言编写的。我虽然很早就接触了C语言，但是一直没有将它学懂，这个寒假将C语言的一些知识又重新学了一遍，弄清楚了之前一直没有...
C语言指向指针的指针
07-15
本文主要讲了C语言指向指针的指针的相关问题，下面一起来学习一下
课程思政-C语言程序设计-指针基础
03-25
课程思政-C语言程序设计-指针基础
C++读书笔记—指针变量的定义与初始化
的博客
06-23 4220
在了解指针变量与初始化之前，首先要弄清楚一点：什么是指针？1、指针的内容实际上是一个地址，我们只要给指针赋值一个地址，它将会指向这个地址表示的内存空间，这也是指针的作用，我们要访问某个地址时，这个指针必须合法，否则容易出现系统崩溃，从而出现段错误。比如一个指针指向11楼的某个房间，但是该楼层只有10层，若贸然进去，则会出现严重后果2、指针变量：就是指向某个内存地址的变量    char *p_ch...
指针作用、指针与指针变量、指针的定义与初始化、指针赋值
csdn_lfy的博客
08-11 3047
指针
指针定义和初始化
diyudong4681的博客
04-05 441
指针变量的类型说明 对指针变量的类型说明包括三个内容：(1)指针类型说明，即定义变量为一个指针变量；(2)指针变量名；(3)变量值(指针)所指向的变量的数据类型。　　 其一般形式为： 类型说明符 *变量名；其中，*表示这是一个指针变量，变量名即为定义的指针变量名，类型说明符表示本指针变量所指向的变量的数据类型。 指针变量的初始化 指针变量同普通变量一样，使用之前不仅要定义说明， 而...
指针的定义和初始化
u012226625的专栏
01-02 8709
每个指针都有一个与之关联的数据类型，该数据类型决定了指针所有指向的对象的类型。例如，一个int 型指针只能指向 int 型对象。 1.指针变量的定义      C++语言使用 * 号把一个标识符声明为指针：              vector   *pvec;         int        *p1, *p2;         string    *pstri
C语言指针（3）
ddiioopp123的博客
02-05 788
对使用字符指针变量和字符数组的讨论：       虽然用字符数组和字符指针变量都能实现字符串的存储和运算，但他们二者之间是有区别的，不应混为一谈。       主要概括下来有以下几点：       1、字符数组由若干个元素组成，每个元素中放一个字符，而字符指针变量中存放的是地址（字符串第一个字符的地址）。       2、赋值方式的不同：对字符数组只能对各个元素赋值，不能用这种方法：
C语言--指针详解
jiekaile的博客
08-18 207
这段时间在看 Linux 内核，深觉 C 语言功底不扎实，很多代码都看不太懂，深入学习巩固 C 语言的知识很有必要。先从指针开始。 一、什么是指针 C语言里，变量存放在内存中，而内存其实就是一组有序字节组成的数组，每个字节有唯一的内存地址。CPU 通过内存寻址对存储在内存中的某个指定数据对象的地址进行定位。这里，数据对象是指存储在内存中的一个指定数据类型的数值或字符串，它们都有一个自己的地址，而指针便是保存这个地址的变量。也就是说：指针是一种保存变量地址的变量。 前面已经提到内存其实就是一组有序字节组成的数
C语言指针理解（一）
m0_62209669的博客
04-01 1260
我觉得C语言中指针是最难的，看了几遍书还是不好理解，但指针确是非常重要的 一：指针含义 通过地址能够找到所需的变量单元，也就是说指针指向变量单元。 将地址形象化称为指针，也就是通过它能够找到地址的内存单元： 复杂类型说明： 原则：从变量名处起，根据运算符优先级结合，一步一步向下分析 intp;//这是一个普通的整型变量 int*p;//首先从P 处开始,先与*结合,所以说明P 是一个指针,然后再与int 结合,说明指针所指向的内容的类型为int 型.所以P是一个返回整型数据的指针 ...
【c语言问题系列教程之一】变量声明和初始化
MyLinChi的博客
09-24 7095
一、基本类型 1.c语言整数类型的大小并没有精确的定义，而是随着编译器的类型而变化，ANSI C能保证的只是数据的最小尺寸。char>=8位，short>=16位,int>=16位，long>=32位。 2.因此，可以用typedef定义int16和int32,然后根据实际的机器环境把它们定义为int,short,long等类型。但是，标准头文件已经定义了标准名称int16_t,uint32_
掌握C语言指针基础：高效与挑战
C语言指针基础课程深入探讨了C语言中的核心概念，它强调了指针在编程中的重要性，尤其是在实现高效和高能计算方面。本章节共分为六个部分： 1. 指针的概念和变量地址：指针是C语言中的关键工具，它代表了内存中的一...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值