参考：五大板块（2）—— 指针
作者：丶PURSUING
发布时间： 2021-03-18 16:01:22
网址：https://blog.csdn.net/weixin_44742824/article/details/114981482

本文为学习笔记，整合课程内容及文章如下：

在 为什么要使用指针 板块：
参考：原文链接
作者：Cloudkip

一、地址的引入
- 概念
- 地址长啥样？
二、指针变量的引入
三、指针分类型与指针偏移量
- 整型指针，字符指针
- 函数指针（重点）
- - 无参无返的函数指针
  - 有参有返的函数指针
  - 结构体中的函数指针
  - 规律总结
- 数组指针（少用）
- 指针数组（少用）
- 结构体指针（重点）
- - 定义赋值调用与指针偏移
  - 实际应用例子
- 野指针
- - 是什么
  - 野指针是怎样生成的？
  - 有什么危害
  - 如何避免
  - malloc与内存泄漏
- 指针类型小测试
四、指针也可以作为数组传入的形式参数
五、为什么要使用指针？
- （1）节省内存
- （2）在子函数中修改被传递过来的对象
- （3）动态分配内存
- （4）在指定地址写入数据（目前少用）
- （5）函数多个返回值

指针，你说他难吧，其实都是在学校学的时候给劝退了，其实很简单，而且学会了之后老是想用，也很好用，以后看到指针就不会有心理障碍啦。

一、地址的引入

概念

地址是一个十六进制表示的整数，用来映射一块空间，是系统用来查找数据位置的依据。地址标识了存储单元空间，而字节就是最小的存储单位。

按字节的编址方式：每一个字节都有一个唯一的地址。例如：一个int型的变量是4个字节，就会对应4个地址，我们只需要取到这个变量的首地址就能得到完整的int型数据。

地址长啥样？

用一个例子感受变量存放的地址：

#include <stdio.h>int main()
{int a=10;int b=11;int* p=&a;int* p2=&b;printf("a的地址是：%p\n",p);printf("b的地址是：%p\n",p2);return 0;
}

结果：可以发现两者地址相差4个字节，说明int型变量用4个字节的空间存放

a的地址是：0x7ea5d1dc
b的地址是：0x7ea5d1d8

大概可以表示为：

二、指针变量的引入

什么是指针？从根本上看，指针是一个值为内存地址的变量。

正如char型变量存放字符，int型变量存放整型数一样，指针变量存放的是地址，没有什么难理解的。

给指针赋值就是让其指向一个地址。

三、指针分类型与指针偏移量

用sizeof发现linux下所有指针类型的大小均为8字节。

平台：树莓派

首先明白：指针所占用的空间与指针指向的内容和内容的大小无关。
其次明白：在不同的操作系统及编译环境下，指针类型所占用的字节数是不同的
例如：
编译生成16位的代码时，指针占2个字节
编译生成32位的代码时，指针占4个字节
编译生成64位的代码时，指针占8个字节

整型指针，字符指针

#include <stdio.h>int main()
{int a = 5;char b = 'A';int *pa = &a;//存放整型数的指针叫整型指针char *pb = &b;//而这叫字符型指针//printf("int型指针 pa 的地址是%p,指针偏移(++pa)的地址是:%p\n",pa,++pa);//printf("char型指针 pb 的地址是%p,指针偏移(++pb)的地址是:%p\n",pb,++pb);printf("int 型指针pa的地址是%p\n",pa);printf("int 型指针偏移(++pa)后的地址是:%p\n\n",++pa);printf("char 型指针pb的地址是%p\n",pb);printf("char 型指针偏移(++pb)后的地址是:%p\n",++pb);return 0;}

结果：可以看到指针类型不同，其每次偏移的地址量也不同。

pi@raspberrypi:~/Desktop $ ./a.out
int 型指针pa的地址是0x7ead81ec
int 型指针偏移(++pa)后的地址是:0x7ead81f0char 型指针pb的地址是0x7ead81eb
char 型指针偏移(++pb)后的地址是:0x7ead81ec

不知道你会不会思考，为什么我不使用代码中被注释的两条语句，简短明了，而要使用4条printf。
你尽管试试，打印出来的pa和++pa是一样的，好似是地址没有偏移，这其实关系到了printf的出栈入栈问题，放在六、其他小知识点：printf 里的 a++,++a，真的有鬼！！ 中详细展开。

函数指针（重点）

顾名思义，指向函数地址的指针。

无参无返的函数指针

这是函数指针最简单的一种形式

#include <stdio.h>void print()//要被指向的函数
{printf("hello world\n");
}int main()
{void (*pprint)() = NULL;//定义函数指针pprint = print;         //函数指针赋值：指向函数的首地址（就是函数名）//如同数组的首地址，是数组名pprint();        //调用方法1(*pprint)();     //调用方法2printf("函数指针pprint的地址是%p\n",pprint);printf("函数指针偏移(++pprint)后的地址是:%p\n",++pprint);return 0;
}

结果：

hello world
hello world
函数指针pprint的地址是0x1046c
函数指针偏移(++pprint)后的地址是:0x1046d

有参有返的函数指针

稍微上升点难度

#include <stdio.h>int sum(int a,int b)//要被指向的函数
{int c = 0;c = a+b;return c;
}int main()
{int total1;int total2;int (*psum)(int a,int b) = NULL;//定义函数指针psum = sum;           //函数指针赋值，指向函数的首地址（就是函数名）//如同数组的首地址，是数组名total1 = psum(5,6);   //调用方法1total2 = (*psum)(6,9);//调用方法2printf("total1:%d\ntotal2:%d\n",total1,total2);printf("%p\n",psum);printf("%p\n",++psum);return 0;
}

结果：

total1:11
total2:15
0x10440
0x10441

结构体中的函数指针

比较常见的还是和结构体的结合，这个容易看花眼。

#include <stdio.h>
#include <string.h>struct student
{int english;int japanese;int math;int chinese;char name[128];int (*pLanguage)(int english,int japanese);//顺便复习函数指针怎么使用};int Language(int eng,int jap)//函数指针所指向的函数
{int total;total = eng + jap;return total;
}int main()
{int lanSum;struct student stu1 = {.japanese = 90,.english = 100,.math = 90,.name = "华天朱",.pLanguage = Language,};lanSum = stu1.pLanguage(stu1.english,stu1.japanese);printf("stu1的名字是%s,他的语言综合分数是%d\n",stu1.name,lanSum);printf("%p\n",stu1.pLanguage);printf("%p\n",++stu1.pLanguage);return 0;
}

结果：

stu1的名字是华天朱,他的语言综合分数是190
0x10470
0x10471

规律总结

函数指针无非就三步走：

定义
类型 (*指针名)();

void (*pprint)() = NULL;

两个括号很好记

赋值
指针名 = 函数名

pprint = print;

调用
如有参数则调用时传

pprint();        //调用方法1
(*pprint)();     //调用方法2

数组指针（少用）

顾名思义，就是指向数组地址的指针。

目前还没碰到数组指针的使用，涉及即更新

#include <stdio.h>int main()
{int a[3] = {1,2,3};int (*p)[3] = NULL;p = a;printf("%p\n",p);printf("%p\n",++p);return 0;
}

结果：偏移了整个数组的大小12字节

0x7ede61e8
0x7ede61f4

指针数组（少用）

存放一系列指针的数组，本质是数组。

#include <stdio.h>int main()
{int a=1;int b=2;int c=3;int *parray[3] = {&a,&b,&c};int i;printf("指针数组的第一个元素是:%p,地址的内容是:%d\n",parray[0],*parray[0]);return 0;
}

结果：

指针数组的第一个元素是:0x7ed501f4,地址的内容是:1

结构体指针（重点）

定义赋值调用与指针偏移

#include <stdio.h>
#include <stdlib.h>
#include <string.h>struct STU
{int score;char name[128];
};int main()
{struct STU stu1 = {.score = 99,.name = "果粒臣",};//malloc为结构体指针开辟一块空间struct STU *pstu = (struct STU *)malloc(sizeof(struct STU));//结构体指针的赋值1：直接赋值,在此之前要开辟空间pstu->score = 100;strcpy(pstu->name,"华天朱");printf("%s:%d\n",pstu->name,pstu->score);free(pstu);//释放指针，重新指向一段地址//结构体指针的赋值2：指向结构体变量的地址pstu = &stu1;printf("%s:%d\n",pstu->name,pstu->score);//指针偏移printf("%p\n",pstu);printf("%p\n",++pstu);return 0;
}

结果：结构体偏移了4+128个字节

华天朱:100
果粒臣:99
0x7e905170
0x7e9051f4

实际应用例子

用一个结构体指针做一个最简单的学生成绩管理。

#include <stdio.h>
#include <stdlib.h>
#include <string.h>struct stud
{char* name;int score;
};int main()
{int num;int i;printf("需要录入几个学生的成绩？\n");scanf("%d",&num);//这里开辟了num个结构体所需要的空间，动态分配内存struct stud *pstu = (struct stud *)malloc(sizeof(struct stud)*num);for(i=0;i<num;i++){pstu->name = (char* )malloc(sizeof(char)*16);memset(pstu->name,0,sizeof(char)*16);printf("请输入第%d个学生的名字\n",i+1);scanf("%s",pstu->name);printf("请输入第%d个学生的成绩\n",i+1);scanf("%d",&pstu->score);pstu++;}pstu -= num;//指针回头for(i=0;i<num;i++){printf("%s:%d\n",pstu->name,pstu->score);pstu++;}return 0;
}

结果：

美羊羊:45
废羊羊:100
喜羊羊:60
灰太狼:76

野指针

是什么

野指针指向的地址是随机（又称为："垃圾"内存）的，无法得知他的地址，操作系统自动对其进行初始化。

野指针是怎样生成的？

（1）创建指针时没有对指针进行初始化
（2）使用free释放指针后没有将其指向NULL

有什么危害

当一个指针成为野指针，指向是随机的，当你使用它时，危害程度也是随机而不可预测的。一般会造成内存泄漏也很容易遭到黑客攻击，只要将病毒程序放入这块内存中，当使用到这个指针时就开始执行。

如何避免

定义指针时进行初始化

如果没有确定指向，就让它指向NULL

NULL在宏定义中是#define NULL (void **) 0，代表的是零地址，零地址不能进行任何读写操作

要给指针指向的空间赋值时，先给指针分配空间，并且初始化空间

简单示例：

//char型指针
char *p = (char *)malloc(sizeof(char));
memset(p,0,sizeof(char));//int型指针
//指针（指向地址）游标卡尺   开辟空间大小
int *p     =     (int *)malloc(sizeof(int));
memset(p,0,sizeof(int));//结构体指针
struct stu *p = (struct stu *)malloc(sizeof(struct stu));
memset(p,0,sizeof(struct stu));

malloc动态内存分配，用于申请一块连续的指定大小的内存块区域以void*类型返回分配的内存区域地址。void *malloc(unsigned int size)，因为返回值时void*，所以要进行强制转换。

memset将某一块内存中的内容全部设置为指定的值，这个函数通常为新申请的内存做初始化工作,是对较大的结构体或数组进行清零操作的一种最快方法。void *memset(void *s, int ch, size_t n);

释放指针同时记得指向NULL

free(p);
p = NULL;

malloc与内存泄漏

情景：
程序刚跑起来的时候没问题，时间久了程序崩溃，大多为内存泄漏。

最常见的情况是在无限的循环中一直申请空间。用malloc申请的空间，程序不会主动释放，只有当程序结束后，系统才回收空间。

避免在循环中一直申请空间，即使合理释放（free,指向NULL）

指针类型小测试

搞几个容易混淆的

int *p[4];
int (*p)[4];
int *p();
int(*p)();

指针数组，数组中存放的是一系列的地址
数组指针，指向一个数组
只是一个普通的函数，其返回值是int* 的指针
函数指针，指向一个函数

四、指针也可以作为数组传入的形式参数

在数组作为子函数的形式参数小节中，子函数的形式参数我们用 int array[ ]来定义。

学了指针之后，我们也可以用 int *array来定义.这是因为前者的本质上传入的是数组的首地址，而指针也一样，需要传入数组的首地址。

如下：

#include <stdio.h>int arraySum(int *array,int num)//数组形参，仅仅传递数组的首地址，代表不了个数。
{int sum;int i;for(i=0;i<num;i++){sum+=array[i];}return sum;}int main()
{int sum;int array[5]={0,1,2,3,4};//      sum=arraySum(array,sizeof(array)/sizeof(array[0]));    //传递数组名sum=arraySum(&array[0],sizeof(array)/sizeof(array[0]));//或者传递首元素的地址（&）//sizeof里面只能传入数组名                                                  printf("sum=%d\n",sum);return 0;
}

五、为什么要使用指针？

（1）节省内存

指针的使用使得不同区域的代码可以轻易的共享内存数据，当然也可以通过数据的复制达到相同的效果，但是这样往往效率不太好。

指针节省内存主要体现在参数传递上，比如传递一个结构体指针变量和传递一个结构体变量，结构体占用内存越大，传递指针变量越节省内存，也就是可以减少不必要的数据复制。

（2）在子函数中修改被传递过来的对象

C语言中的 一切函数调用中，值传递都是“按值传递” 的。如果要在函数中修改被传递过来的对象，就必须通过这个对象的指针来完成。

太抽象了不懂？举个栗子：

#include <stdio.h>void add(int a)
{a = a+1;printf("add:a的值为%d\n",a);
}int main()
{int a = 10;add(a);printf("main:a的值为%d\n",a);return 0;
}

结果：可以发现main函数中a的值并没有真正发生改变。

add:a的值为11
main:a的值为10

为什么没有改变呢？
函数add调用时，才申请了一个内存空间，才有了这个变量a，同时把实际参数（main中的a）的值拷贝一份给形式参数(add中的a)，函数执行结束后释放空间,这个子函数中的变量自然也被释放了。

其中这个a就是传递入子函数add的对象，如果想要在这个子函数中修改a的值，就要使用指针

#include <stdio.h>void add(int *a)
{*a = *a+1;printf("add:a的值为%d\n",*a);
}int main()
{int a = 10;add(&a);printf("main:a的值为%d\n",a);return 0;
}

结果：

add:a的值为11
main:a的值为11

传入了main中a的地址，再在子函数中修改这个地址中的内容，当然能够修改成功。

（3）动态分配内存

常常可以看到，程序使用的内存在一开始就进行分配（静态内存分配）。这对于节省计算机内存是有帮助的，因为计算机可以提前为需要的变量分配内存。

但是大多应用场合中，可能一开始程序运行时不清楚到底需要多少内存，这时候可以使用指针，让程序在运行时获得新的内存空间（动态内存分配），并让指针指向这一内存更为方便。

在结构体指针实际应用举例中有涉及：

int num;printf("需要录入几个学生的成绩？\n");
scanf("%d",&num);//这里开辟了num个结构体所需要的空间，动态分配内存
struct stud *pstu = (struct stud *)malloc(sizeof(struct stud)*num);

（4）在指定地址写入数据（目前少用）

了解就行 JAVA等其他编程语言实现不了这种操作

#include <stdio.h>int main()
{volatile int *p = (volatile int *)0x7ead81eb;//强制转化成整型地址*p = 10;                                     //ARM架构 裸机编程 ARM驱动会使用printf("在地址%p中存放的数据是%d\n",p,*p);return 0;
}

结果：

在地址0x7ead81eb中存放的数据是10

注意哈，这个操作运行很有可能

Segmentation fault

这也正常，毕竟可能这地址放有东西或者不允许这样操作。

volatile和编译器的优化有关：

编译器的优化

在本次线程内，当读取一个变量时，为了提高读取速度，编译器进行优化时有时会先把变量读取到一个寄存器中（寄存器比内存要快！）；以后，再读取变量值时，就直接从寄存器中读取；当变量值在本线程里改变时，会同时把变量的新值copy到该寄存器中，以保持一致。

当变量因别的线程值发生改变，上面寄存器的值不会相应改变，从而造成应用程序读取的值和实际的变量值不一致。
当寄存器因别的线程改变了值，原变量的值也不会改变，也会造成应用程序读取的值和实际的变量值不一致。

（5）函数多个返回值

有时候我们总是希望一个功能子函数的返回值可以有很多个，但奈何用return只能返回一个。

碰到实际用上的例子再补充，不硬找例子。

五大板块（2）—— 指针相关推荐

五大板块（5）——字符串
参考:五大板块(5)--字符串作者:丶PURSUING 发布时间: 2021-03-18 16:03:48 网址:https://blog.csdn.net/weixin_44742824/arti ...
五大板块（4）——链表
参考:五大板块(4)--链表作者:丶PURSUING 发布时间: 2021-02-15 09:33:29 网址:https://blog.csdn.net/weixin_44742824/artic ...
五大板块（3）—— 结构体
参考:五大板块(3)-- 结构体作者:丶PURSUING 发布时间: 2021-03-18 16:02:43 网址:https://blog.csdn.net/weixin_44742824/art ...
五大板块（1）—— 数组的定义，赋值与应用
参考:五大板块(1)-- 数组的定义,赋值与应用作者:丶PURSUING 发布时间: 2021-03-18 16:00:05 网址:https://blog.csdn.net/weixin_4474 ...
119只股连跌四周五大板块成重灾区
http://www.sina.com.cn 2007年09月25日 08:30 中国证券网-上海证券报 ⊙东吴证券邓文渊 7月份以来股指连续发力上攻,如今沪指已经跨越5400点.时近中秋国庆,虽然 ...
5G | 5G新基建最新进展及投资机会【包含五大板块】
/*********************************************************** 博主github:https://github.com/MichaelBeec ...
群硕入列FoodTalks优质供应商地图数字化板块
2022年6月28日,FoodTalks正式发布食品供应商地图,作为FBIF首席战略技术合作伙伴,群硕软件荣耀上榜! 这次发布的供应商地图覆盖配料.包装.营销等20+大类.100+细分类别.1000家 ...
60分钟入门PyTorch，官方教程手把手教你训练第一个深度学习模型（附链接）
来源:机器之心本文约800字,建议阅读5分钟. 本文介绍了官方教程入门PyTorch的技巧训练. 近期的一份调查报告显示:PyTorch 已经力压 TensorFlow 成为各大顶会的主流深度学习框 ...
5G人才报告 | 买5G手机不用卖肾，有这个就行（全文）
来源:猎聘网本文约4000字,建议阅读8分钟. 本文为你介绍了目前招聘市场5G相关职位的信息. 在今年2月于西班牙巴塞罗那举办的2019世界移动通信大会上,华为.小米.vivo等中国企业先后扎堆发布 ...

五大板块（2）—— 指针

目录