参考：五大板块（2）—— 指针
作者：丶PURSUING
发布时间： 2021-03-18 16:01:22
网址：https://blog.csdn.net/weixin_44742824/article/details/114981482
本文为学习笔记，整合课程内容及文章如下：
指针，你说他难吧，其实都是在学校学的时候给劝退了，其实很简单，而且学会了之后老是想用，也很好用，以后看到指针就不会有心理障碍啦。
地址是一个十六进制表示的整数，用来映射一块空间，是系统用来查找数据位置的依据。地址标识了存储单元空间，而字节就是最小的存储单位。
按字节的编址方式：每一个字节都有一个唯一的地址。例如：一个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)后的地址是:0x7ead81f0
char 型指针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)(); //调用方法2
printf("函数指针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); //调用方法1
total2 = (*psum)(6,9);//调用方法2
printf("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); // 指针占用地址空间大小恒定，指向的内容需要提前分配好堆空间大小
// char[5]是自动分配的栈空间
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);
free(p);
p = NULL;
情景：
程序刚跑起来的时候没问题，时间久了程序崩溃，大多为内存泄漏。
最常见的情况是在无限的循环中一直申请空间。用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;
}
指针的使用使得不同区域的代码可以轻易的共享内存数据，当然也可以通过数据的复制达到相同的效果，但是这样往往效率不太好。
指针节省内存主要体现在参数传递上，比如传递一个结构体指针变量和传递一个结构体变量，结构体占用内存越大，传递指针变量越节省内存，也就是可以减少不必要的数据复制。
在实际做项目的过程中，遇到了结构体多级嵌套导致mcu崩溃的情况(mcu ram吃紧)。
#include <stdio.h>
#include <string.h>
struct Student {
int age;
char sex;
char name[100];
};
void InputStudent(struct Student * pstu) { //pstu只占四个字节
(*pstu).age = 10;
strcpy(pstu->name, "张三");
pstu->sex = 'F';
}
void OutStudent(struct Student ss) {
printf("%d %c %s\n", ss.age, ss.sex, ss.name);
}
int main(void) {
struct Student st;
InputStudent(&st);
printf("%d %c %s\n",st.age,st.sex,st.name);
OutStudent(st);
return 0;
}
代码分析;
void OutStudent(struct Student ss) {
printf("%d %c %s", ss.age, ss.sex, ss.name);
}
此处传递的是一个变量，此变量占的字节空间大，我们可以利用指针，指针只占四个字节空间，而且只存变量st的第一个字节地址，然而指针指向的是整个变量。因为指针前面的类型是struct Student代表的是整个变量。
修改为指针后速度变快，占的内存空间也减小
#include <stdio.h>
#include <string.h>
struct Student {
int age;
char sex;
char name[100];
};
void InputStudent(struct Student * pstu) { //pstu只占四个字节
(*pstu).age = 10;
strcpy(pstu->name, "张三");
pstu->sex = 'F';
}
void OutStudent(struct Student * stu) {
printf("%d %c %s\n", stu->age, stu->sex, stu->name);
}
int main(void) {
struct Student st;
InputStudent(&st);
printf("%d %c %s\n",st.age,st.sex,st.name);
OutStudent(&st);
return 0;
}
当然眼睛是看不出来的，但是理论和事实就是这样的。
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，但对应不同的存储空间)，才有了这个形参变量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的地址，再在子函数中修改这个地址中的内容，当然能够修改成功。
常常可以看到，程序使用的内存在一开始就进行分配（静态内存分配）。这对于节省计算机内存是有帮助的，因为计算机可以提前为需要的变量分配内存。
但是大多应用场合中，可能一开始程序运行时不清楚到底需要多少内存，这时候可以使用指针，让程序在运行时获得新的内存空间（动态内存分配），并让指针指向这一内存更为方便。
在结构体指针实际应用举例中有涉及：
int num;
printf("需要录入几个学生的成绩？\n");
scanf("%d",&num);
//这里开辟了num个结构体所需要的空间，动态分配内存
struct stud *pstu = (struct stud *)malloc(sizeof(struct stud)*num);
了解就行，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到该寄存器中，以保持一致。
当变量因别的线程值发生改变，上面寄存器的值不会相应改变，从而造成应用程序读取的值和实际的变量值不一致。
当寄存器因别的线程改变了值，原变量的值也不会改变，也会造成应用程序读取的值和实际的变量值不一致。
volatile防止优化，每次都要从内存取数据，这样效率会慢于寄存器，但是提高准确度。
有时候我们总是希望一个功能子函数的返回值可以有很多个，但奈何用return只能返回一个。
碰到实际用上的例子再补充，不硬找例子。