C语言之漫谈指针(上）

guguguhuha 2021-03-16 原文

 

在C语言学习的途中，我们永远有一个绕不了的坑，那就是——指针。

在这篇文章中我们就谈一谈指针的一些基础知识。

 

纲要：

  • 零.谈指针之前的小知识
  • 一.指针与指针变量
  • 二.指针变量的类型
  • 三.指针的解引用
  • 四.野指针
  • 五.指针运算
  • 六.指针与数组
  • 七.二级指针
  • 八.指针数组
  • 九.相关例题
  •  
  •  
  •  

 


在谈指针之前我们先来说一说  计算机的储存器.

 

我们在码代码时, 每当声明一个变量，计算机都会在存储器中某个地方为它创建空间。

如果在函数（例如main()函数）中声明变量，计算机会把它保存在一个叫栈（Stack）的存储器区段中；

如果你在函数以外的地方声明变量，计算机则会把它保存在存储器的全局量段（Globals）。

 

程序内存分配的几个区域：

　　1. 栈区（stack）：在执行函数时，函数内局部变量的存储单元都可以在栈上创建，函数执行结束时这些

　　　存储单元自动被释放。栈内存分配运算内置于处理器的指令集中，效率很高，但是分配的内存容量有

　　　限。 栈区主要存放运行函数而分配的局部变量、函数参数、返回数据、返回地址等。
　　2. 堆区（heap）：一般由程序员分配释放， 若程序员不释放，程序结束时可能由OS回收 。分配方式类似

　　    于链表。
　　3. 数据段（静态区）（static）存放全局变量、静态数据。程序结束后由系统释放。

　　4. 代码段：存放函数体（类成员函数和全局函数）的二进制代码。

 

 

如下图：

 

 

 当然了，这张图对于一些初学者并不是很友好。但是接下来一张图就友好了很多。

 

 那么，我们如何知道我们的变量储存在哪？

这时我们就需要用到 & 操作符了。

 

这时可能有人问了，我这两次 x 的地址为什么不相同，这是因为：

我们每一次程序开始运行的时候，系统都会给我们的变量重新分配地址，

程序结束的时候销毁地址，再次从头开始运行时再次重新分配，结束时再次销毁。

 

有了一定的知识之后，我们便开始正文。

 

　　在计算机科学中，指针（Pointer）是编程语言中的一个对象，利用地址，它的值直接指向
（points to）存在电脑存储器中另一个地方的值。由于通过地址能找到所需的变量单元，可以
说，地址指向该变量单元。因此，将地址形象化的称为“指针”。意思是通过它能找到以它为地址
的内存单元。

　　对于上面的概念我们再简练一些便可以概括为：

　　指针 ：内存单元的地址（编号）。如上例中 x 的地址 (指针) 为 0x00D3FD34，

　　 指针变量：存储地址 (指针) 的变量。

　　1、指针就是地址，地址就是指针。

　　2、地址就是内存单元的编号。

　　3、指针变量就是存放内存地址的变量。

　　　 指针变量的值就是变量的地址。指针与指针变量的区别，就是变量值与变量的区别。

　　4、为表示指针变量和它指向的变量之间的关系，用指针运算符”*”表示。如：

  1. //分别定义了 int、float、char 类型的指针变量
  2. int *x = 1;
  3. float *f = 1.3;
  4. char *ch = 'z';

　   　要注意的一点就是 此时 x、y、z 就是指针变量的名字，而不是 *x、*y、*z。

如下：

  1. #include <stdio.h>
  2. int main()
  3. {
  5.     int a = 10;  //在内存中开辟一块空间来放制a
  6.  
  7.     int* p = &a;//这里我们对变量a，取出它的地址，可以使用 & 操作符。
  9.     　　　　　　  //将a的地址存放在p变量中，p就是一个之指针变量。
  10.  
  11.     return 0;
  12. }

指针变量所占空间的大小和该指针变量指向的数据类型没有任何直接关系,而是跟其所在地址的所占空间的大小有关。

同一编译器下,同一编译选项下所有类型的指针变量大小都是一样的,

指针变量的大小是编译器所对应的系统环境所决定的。

如：

　　指针变量的大小在16位平台是2个字节，在32位平台是4个字节，在64位平台是8个字节。

 

提前声明一下：为了方便讲述后面的知识，下文将以指针代替指针变量！

我们先来看以下代码：

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

现在我们都知道了 p 是一个存储着a的地址的指针变量。

可是它的类型是什么呢？

 这时，我们就需要看它所存储的地址中的变量是什么类型了。

  1. 存储类型      指针类型
    int        --->  int*
  2. short  --->  short*
  3. float  --->  float*
  4. char   --->  char*
  5. double --->  double*
  6. long   --->  long*

我们可以看到：

指针的定义方式是： type + * 。

其实： char* 类型的指针是为了存放 char 类型变量的地址。

　　　 short* 类型的指针是为了存放 short 类型变量的地址。

　　     int* 类型的指针是为了存放int 类型变量的地址。

 


那么指针类型又意味着什么呢？

我们来看看下述代码：

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

 

 

 我们可以发现：

　　int* + 1 向后跳过了4个字节—恰好为一个int 型的大小

　　char* + 1 向后跳过了1个字节—恰好为一个char 型的大小


而这，是不是巧合呢——答案当然是否定的。

所以，我们可以得到一个结论：

　　针的类型决定了指针向前或者向后走一步有多大（距离）。

 

现在我们有了变量存储的地址，可是我们要怎么样用到它呢？

这时就需要指针的解引用操作符了—” * “

  1. int main()
  2. {
  3.     int a = 1;
  4.     int* b = &a;
  5.     printf("%d", a);
  6.     printf("%d", *b); //*p 就相当于把p所指向的空间的内容拿出来
  7.     return 0;
  8. }

我们会发现其结果都相同。

我们也可以利用解引用的方式来改变一个变量的值：

  1. int main()
  2. {
  3.     int a = 1;
  4.     int* b = &a;
  5.     printf("改变之前: %d\n", a);
  6.     *b = 2;
  7.     printf("改变之后: %d\n", a);
  8.     return 0;
  9. }

 

 

 如果上面图中的语言有点抽象，那我们可以举一个形象的例子：

　　有一个人叫张三，有一天他在XX宾馆中定了一间房，且房子的门号为100，到这天晚上的时候，他觉得有点寂寞，

于是打电话喊了他好朋友小刘来找他玩，张三在描述地址时是这样说的：我在XX宾馆100号房间……但小刘那时有事，所以等到小刘来宾馆的时候

已经是第二天中午了，可时张三在第二天早上就退了房，且李四又住了进来，所以当小刘打开宾馆的100室见到的还会是张三吗？肯定不会了

 

住在100室的人——–a

100室——&a、b

张三——-1

李四——–2

不知大家这回理解了没有

 

我们来看看这一个例子：

  1. #include <stdio.h>
  2. //在此程序运行时，我们要重点在调试的过程中观察内存的变化
  3. int main()
  4. {
  6.     int n = 0x11223344;
  8.     char* pc = (char*)&n;
  10.     int* pi = &n;
  12.     *pc = 0; 
  14.     *pi = 0;
  16.     return 0;
  17. }

 

 

 所以，我们又可以推出：

　　指针的类型决定了，对指针解引用的时候有多大的权限（能操作几个字节）。

　　比如： char* 的指针解引用就只能访问一个字节，而 int* 的指针的解引用就能访问四个字节。

野指针：野指针就是指针指向的位置是不可知的（随机的、不正确的、没有明确限制的）

　　1、指向不可访问的地址
　　2、指向一个可用的，但是没有明确意义的空间
　　3、指向一个可用的，而且正在被使用的空间，造成瘫痪

  1. #include <stdio.h>
  2. int main()
  3. {
  5.     int* p;//局部变量指针未初始化，默认为随机值
  6.  
  7.     *p = 20;
  9.     return 0;
  10. }
  1. #include <stdio.h>
  2. int main()
  3. {
  5.     int arr[10] = { 0 };
  7.     int* p = arr;
  9.     int i = 0;
  11.     for (i = 0; i <= 11; i++)
  12.     {
  14.         //当指针指向的范围超出数组arr的范围时，p就是野指针
  15.  
  16.         *(p++) = i;
  17.     }
  19.     return 0;
  20. }
  1. int func()
  2. {
  3.     int *p = malloc(sizeof(int));
  4.     free(p);//没有将p值为NULL的操作 
  5. }

　　1. 指针初始化
　　2. 小心指针越界
　　3. 指针指向空间释放及时置NULL
　　4. 指针使用之前检查有效性

 

 在我们指针变量大小那块我们便展示了一个例子，接下来我们继续看一个：

  1. #define N_VALUES 5
  2.  
  3. int main()
  4. {
  5.     float values[N_VALUES];
  6.     float* vp;
  7.     //指针+-整数；指针的关系运算
  8.     for (vp = &values[0]; vp < &values[N_VALUES];)
  9.     {
  10.         *vp++ = 0;
  11.     }
  12.     for (int i = 0; i < N_VALUES; i++)
  13.     {
  14.         printf("%f ", values[i]);
  15.     }
  16.     return 0;
  17. }

此例是运用指针来放置数组变量

到这，我们便又掌握了一种操作数组的方法。（详见六.指针与数组）

 

 在之前我们模拟strcpy()的实现中，便用到此方法,下面我们继续再来写一下

  1. //1. 计数器的方法
  2. int my_strlen(char* str)
  3. {
  4.     int count = 0;
  5.     while (*str != '\0')
  6.     {
  7.         count++;
  8.         str++;
  9.     }
  10.     return count;
  11. }
  1. //2.递归实现
  2. int my_strlen(const char* str)
  3. {
  4.     if (*str == '\0')
  5.         return 0;
  6.     else
  7.         return 1 + my_strlen(str + 1);
  8. }
  1. //3.指针-指针
  2. int my_strlen(char* s)
  3. {
  4.     char* p = s;
  5.     while (*p != '\0')
  6.         p++;
  7.     return p - s;
  8. }

详情参见：C语言之库函数的模拟与使用

在指针-指针中我们需要注意的一点就是：两个指针一定要指向的是同一块连续的空间

 

下面以一个实例来说明：

  1. int main()
  2. {
  3.     int arr[10] = { 0 };
  4.     printf("%d\n", &arr[0] - &arr[9]);//-9
  5.     char ch[5] = {0};
  6.     //指针-指针   绝对值的是指针和指针之间的元素个数
  7.     printf("%d\n", &arr[9] - &ch[3]);//err
  8.     //指针-指针 计算的前提条件是：两个指针指向的是同一块连续的空间的
  9.     return 0;
  10. }

我们会看到编译器报一个警告

 

  1. #define N_VALUES 5
  2.  
  3. int main()
  4. {
  5.     float values[N_VALUES];
  6.     float* vp;
  7.     //指针的关系运算
  8.  
  9.     for (vp = &values[N_VALUES - 1]; vp >= &values[0]; vp--)
  10.     {
  12.         *vp = 0;
  13.     }
  15.     for (int i = 0; i < N_VALUES; i++)
  16.     {
  17.         printf("%f ", values[i]);
  18.     }
  19.     return 0;
  20. }

我们来看看上面这个例子有没有什么问题

 

 

 

 

我们先在这看一个实例：

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

在运行结果中，我们居然发现，这两个地址居然一样！

由此我们可以得到：数组名表示的是数组首元素的地址。

那么我们用指针来接收数组时便可写成这个样子

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

    int *p = arr;//p存放的是数组首元素的地址
  1. int main()
  2. {
  3.     int arr[5] = { 1, 2, 3, 4, 5 };
  4.     int* p = arr;
  5.     int i = 0;
  6.     for (i = 0; i < 5; i++)
  7.     {
  8.         printf("%d ", *(p + i));//通过指针来访问数组元素
  9.     }
  10.     printf("\n");
  11.     for (i = 0; i < 5; i++)
  12.     {
  13.         printf("&arr[%d] = %p < === > %p\n", i, &arr[i], p+i);//打印两地址看是否相同
  14.     }
  15.     return 0;
  16. }

所以 p+i 其实计算的是数组 arr 下标为i的地址。

那我们就可以直接通过指针来访问数组。

如下：

  1. int main()
  2. {
  3.     int arr[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 };
  4.     int* p = arr; //指针存放数组首元素的地址
  5.     int sz = sizeof(arr) / sizeof(arr[0]);
  6.     int i = 0;
  7.     for (i = 0; i < sz; i++)
  8.     {
  9.         printf("%d ",*(p + i));
  10.     }
  11.     return 0;
  12. }

 

我们知道，存放地址变量的叫做指针变量，那存放指针变量的呢，自然就叫做二级指针变量了啊！

由此我们可以继续推下去：

  1. int main()
  2. {
  3.     int a = 10;
  4.     int * p = &a;//p是一级指针
  5.     int * * pp = &p;//pp是二级指针
  6.  
  7.     **pp = 20;
  8.     printf("%d\n", a);//
  9.     //int*** ppp = &pp;//三级指针
  10.     //int**** pppp = &ppp;//四级指针
    　　//……………………
    　　//……………………
  11.  
  12.     return 0;
  13. }

 

 

 

在谈这个主题之前，我们先来想一想 指针数组到底是指针还是数组？

数组

整形数组 – 存放整形的数组

字符数组 – 存放字符的数组

所以：

指针数组 – 存放的指针

如：

  1. int main()
  2. {
  3.     //int arr[10] = {0};//整形数组
  4.     //char ch[5] = { 'a', 'b' };//字符数组
  5.     //指针数组
  6.     int a = 10;
  7.     int b = 20;
  8.     int c = 30;
  10.     //arr就是指针数组
  11.     //存放整形指针的数组
  12.     int* arr[3] = { &a, &b, &c };//int* 
  13.     char* ch[5];//存放字符指针的数组
  14.  
  15.     return 0;
  16. }

 

 在我们解决问题时，第一个遇到用指针的问题应该是这个：

写一个函数可以交换两个整形变量的内容。

  1. #include <stdio.h>
  2. void Swap1(int x, int y)
  3. {
  4.     int tmp = 0;
  5.     tmp = x;
  6.     x = y;
  7.     y = tmp;
  8. }
  10. int main()
  11. {
  12.     int num1 = 1;
  13.     int num2 = 2;
  14.     Swap1(num1, num2);
  15.     printf("Swap1::num1 = %d num2 = %d\n", num1, num2);
  16.     return 0;
  17. }

当时，我们说，函数里的 x，y 只是对于数据的一份临时拷贝，而与真实数据并没有本质的联系。

所以，我们把函数改写成了：

  1. void Swap2(int* px, int* py)
  2. {
  3.     int tmp = 0;
  4.     tmp = *px;
  5.     *px = *py;
  6.     *py = tmp;
  7. }

这时，我们或许知道了这样是怎么把值给交换过来的

我们将地址先传过去，然后再进行解引用赋值操作，整个函数过程都与我们传过去的变量息息相关

 

例题1：

  1. #include <stdio.h>
  2. int main()
  3. {
  4.     int a = 0x11223344;
  5.     char* pc = (char*)&a;
  6.     *pc = 0;
  7.     printf("%x\n", a);
  8.     return 0;
  9. }

这一题要用到我们之前谈到过的大小端储存模式—–详见： C语言之数据在内存中的存储

首先 a在内存中按小端存储的是 44 33 22 11

char* 只能解引用一个字节，所以获取的是 44 这个字节

而现在 *pc=0 就是把这个字节的值由 44 变为了 0；

所以该程序在Vs的编译器结果是 0x 11 22 33 00

 

例题2：

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

首先我们要知道 short* 解引用只能解引用 2 个字节

而 int 类型为 4 个字节

所以第一个for循环只改变了数组 arr 的前两个变量(改为了0）

所以最后的结果为： 0 0 3 4 5 

 

 

 

到此，我们便掌握了指针的一些基础知识

下节，我们将谈到一些指针的高级应用

详见：C语言之漫谈指针(下）

 

 

|——————————————————————|

|因笔者水平有限，若有错误之处，还望多多指正。|

|——————————————————————|

 

发表于
2021-03-16 08:48 
guguguhuha 
阅读(0) 
评论(0) 
编辑 
收藏

 

版权声明：本文为guguguhuha原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://www.cnblogs.com/guguguhuha/p/14538956.html

C语言之漫谈指针(上）的更多相关文章

  1. 第9章 用户自己建立数据类型

    9.1 定义和使用结构体变量 9.1.1 自己建立结构体类型 C语言允许用户自己建立由不同类型数据组成的组合型 […]...

  2. 你可能不知道的printf

    你可能不知道的printf 前言 printf可能是我们在学习C语言的过程中最早接触的库函数了。其基本使用想必 […]...

  3. 空间换时间，查表法的经典例子

    前言 上一篇分享了：C语言精华知识：表驱动法编程实践 这一篇再分享一个查表法经典的例子。 我们怎么衡量一个函数 […]...

  4. C语言（面积计算器）

    简单面积计算器（自定义函数利用）  调试了好久也没有从default再次进入switch；   程序不能输入负 […]...

  5. Nginx(五)、http反向代理的实现

    　　上一篇nginx的文章中，我们理解了整个http正向代理的运行流程原理，主要就是事件机制接入，header […]...

  6. C语言|博客作业02

    这个作业属于哪个课程 https://edu.cnblogs.com/campus/zswxy/CST2020 […]...

  7. 力扣1052. 爱生气的书店老板-C语言实现-中等难度

    题目 传送门 文本 今天，书店老板有一家店打算试营业 customers.length 分钟。每分钟都有一些顾 […]...

  8. [源创] STM32F103ZET6 基于XMODEM 通讯的 BOOTLOADER案列IAP

    网上好多初学者 都想知道如何更好的用IAP，BOOTLOADER 功能 我给大家一个我自己的基于Xmodem的 […]...

随机推荐

  1. mysql group by 取第一条

    select * from table where id in (select max(id) from ta […]...

  2. 局域网共享打印机

    同一个课题组一般只有一台打印机，因此只能通过共享方式实现共用。之前配置过一次，但是用了一段时间之后突然连接不上 […]...

  3. 查看电脑本机的ip地址 – 叶是风的眼泪

    查看电脑本机的ip地址 第一步：打开cmd 第二步：输入：ipconfig，回车 第三步：找到无线局域网适配器 […]...

  4. java Swing可视化开发工具

    java Swing可视化开发工具 2013-06-15 19:08  youxin  阅读(7200)  评 […]...

  5. 深度学习 for java http://deeplearning4j.org/

    http://deeplearning4j.org/ http://deeplearning4j.org/zh […]...

  6. java 线程实现、线程暂停和终止 、线程联合join、线程基本信息获取和设置、线程优先级

    转载地址：速学堂 https://www.sxt.cn/Java_jQuery_in_action/eleve […]...

  7. Lambda@edge 实现负载均衡器功能

    一般的业务实现流程为CDN->ELB->EC2，但OTT业务往往会产生很高的流量费用，如果使用常规 […]...

  8. 阿里云OSS的使用总结

    阿里云OSS的使用总结 背景说明：项目接手过来发现oss是使用的别人的oss，这里我们配置成自己的。 1.首先 […]...

热门专题

poj1417
topcoder
Redis简介及五种数据类型
4.电影搜索之如何把视频播放器嵌入网页
矩池云安装/修改
基于HTTPS的接口测试——nginx配置SSL
【机器学习】梯度下降中矩阵的迹的求导证明
左侧菜单，右侧内容的布局（带左侧菜单点击隐藏显示效果）
只需两步快速获取微信小程序源码
Arduino入门小程序大合集
连接打印机出现0x0000007e错误的解决方法(转)
opengl基础学习专题
增强型51单片机定时器2与串行通讯应用
Android开发所有视频教程汇总
显卡故障轻松处理
Kit联合开发丨行人社交距离风险提示Demo
乐鑫esp8266的
coolnet
函数VLOOKUP之多列数据同时导入的两种特殊用法
图文详解模块使用教程
计算广告
展开目录

目录导航