单片机软件架构连载(2)-指针

我工作了10年，大大小小做过几十个项目，用指针解决过很多实际产品的痛点，比如写过小系统，数据结构(队列，链表)，模块化编程等等.....

今天贴近实际，给大家总结了c语言指针常用的知识点，吃透指针并灵活应用，你会发现了c语言的"新大陆"。

长文预警，全文13271，写了4天3夜，手指现在还瑟瑟发抖，看不懂你锤自己。

1.为什么说指针是 c 语言的灵魂？

因为它提供了对内存的直接控制能力，这是 C 语言和其它高级编程语言的关键特点之一。

基于这个特点，能衍生出非常多灵活的应用，比如内存管理、数组操作、函数参数传递、数据结构、硬件寄存器配置等等。

这样说，可能有点抽象，不要紧，我刚开始接触指针，也是这感觉。

我也是做了单片机开发 6,7 年以后，独立做了一些网关产品，有 Ble、WiFi、4G，研究过一些大厂写的 sdk，也学习过同事的编程思维，吃透他们写的代码，然后才对指针有了更深的理解。

为此，我摸索了很多年，因为网上大多数都是零散的基础内容，真正深入系统的很少。

面临开发瓶颈的我，就像拾荒者，协议栈捡一点，同事那里捡一点，然后消化用于项目上，才慢慢形成系统的知识体系，这个体系，我愿称为程序架构。

其实复杂项目做不稳定，问题的本质，就是缺失程序架构设计和模块化编程能力。

而要实现可扩展性，可移植性强的程序架构，指针绝对是绕不开的坎。

有时，我和无际单片机项目特训营的铁子开玩笑说，如果我当时能碰到这些项目就太爽了，少走好几年弯路。

因为项目 3 和项目 6 每个功能的模块化设计，以及整体程序架构，可以说是我们整个职业生涯的结晶。

下面废话不多说，直接开整。

2.指针变量

2.1指针变量定义

指针变量定义的格式如下：

变量类型 *变量名

举例：

unsigned char *p;

unsigned char 是数据类型，p 是变量名。

2.2指针变量赋值

指针变量在使用前，一定要先赋值(指向一个地址)。

给指针变量赋的值和普通变量不同，给指针变量赋值只能是地址。

那么怎么获取普通变量的地址呢，在 C 语言里可以使用”&”来获取普通变量的地址，一般用以下格式来表示:

&变量名

举例:

// 包含标准输入输出库，用于printf函数等
#include <stdlib.h>

// 定义一个无符号字符变量a，其取值范围是0到255
unsigned char a;
// 定义一个指向无符号字符的指针变量p
unsigned char *p;

// 主函数入口点
int main()
{
    // 将值10赋给变量a
    a = 10;
    // 让指针p指向变量a的地址
    p = &a;
    // 打印变量a的地址，%x代表以十六进制形式，\r\n代表回车和换行符
    printf("a=0x%x\r\n",&a);
    // 打印指针p所指向的地址，即变量a的地址，以十六进制形式，后面跟一个回车换行符
    printf("P=0x%x\r\n",p);
    // 打印变量a的值，%d代表以十进制形式,即10
    printf("a=%d\r\n",a);
    // 打印指针p所指向的值，即变量a的值，由于p指向a，所以打印的也是10
    printf("*p=%d\r\n",*p);
    // 函数返回0，表示程序正常结束
    return(0);
}

这段代码演示了如何在 C 语言中使用指针，首先定义了一个无符号字符变量 a 和一个指向无符号字符的指针 p。

然后在 main 函数中，将 a 的值设置为 10，并将 p 指向 a 的地址。接着打印出 a 和 p 的内存地址，以及 a 的值和通过指针 p 访问到的值。

代码输出结果如下：

我们来分析下输出结果：

a=0x404090 - 变量 a 在内存里的存储地址

p=0x404090 - 指针变量 p 指向的地址，因为程序把 a 的地址赋值给 p，所以 p 指向 a 的存储地址。

a=10 - 变量 a 的值

*p=10 - 指针变量 p 指向地址里的值，p 指向地址是 0x404040,而这个地址里存储的值为 10，所以*p=10。

普及两个符号的定义

“&” - 取变量地址，“*” - 取地址的值

所以：

&a 代表取 a 在内存里的存储地址

*p 代表取 p 指向那个地址里面存储的值

发散思考

你有没有想过，既然用符号"*“可以取地址的值，那我直接用*0x404090，是否能取到变量 a 的值？

有想法，就要去做实验，错了也没关系，这是成长必经过程。

我增加了第 14 行代码，编译后出现了一个错误：invaild type argument of 'unary *'。

这个错误大概意思就是，我试图对一个不是指针类型的东西，使用*操作符。

对于编译器来说，0x404090 可能识别为一个值，而不是一个地址，所以属于语法错误。

我继续改进代码，把 0x404090 这个十六进制值，强制转换成一个地址。

((unsigned char *)0x404090))代表把 0x404090 这个值，强制转换成一个无符号字符类型指针，相当于告诉编译器，这是一个地址。

强制转换的类型要和变量 a 的数据类型保持一致，因为我们想直接通过地址，把变量 a 的值读出来。

最后通过*，把这个地址的数据读出来，结果等于10。

*p 就像是*((unsigned char *)0x404090)的缩写版本。

那可不可以理解成，p 其实就是一个地址？

我个人觉得，这个条件是成立的，概念无所谓，最主要的是通过实践，能验证理论的正确性。

这个例子，*p 可以替代*((unsigned char *)0x404090)，其实就初步体现了指针的方便和灵活性了。

2.3指针变量也占内存

指针本身也是一个变量，也有自己的地址，需要内存存储。

那是不是意味着，指针变量本身也有一个存储的地址。

我们直接来做个实验：

我增加了一条语句，用来打印指针变量 p 存储地址，通过&p 即可获得 p 的在内存中的存储地址。

输出结果显示指针变量 p 的存储地址是 0x4040A0。

我再增加一条语句，看下 0x4040A0 这个地址下，存储的是什么值。

没有意外，输出结果 0x4040A0 地址存储的值是 0x404090，即 p 指向的地址(变量a的地址)。

这里需要注意的是，p 指向的值，是 4 个字节的地址，所以要正确输出，需要强制转化成 unsigned int 类型。

这样刨根问底，还挺有意思的，指针概念过于抽象，有时指来指去，都不知道指到哪去了，所以有疑问时，最好的方式，就是直接做实验，看地址的变化。

通过以上的学习，我觉得初学者必须亲自动手做做实验，通过一系列的实验，掌握指针的底层逻辑，为后续指针的高阶应用打下扎实的基础，而不是停留在看懂和记概念。

2.4通过指针改变某个内存地址里的值

前面我们可以通过指针，去获取某个内存地址的值，那可不可以通过指针，改变某个内存地址里的值呢？

答案是当然可以！

格式：

*指针变量 = 数值

如：*p = 20;

代码举例：

前面我们把 p 指向变量 a 的地址，然后通过*p 修改该地址下存储的值，最终其实就是修改的变量 a 的值。

最终代码：

#include <stdlib.h>

unsigned char a;
unsigned char *p;

int main()
{
    a = 10;
    p = &a;
    printf("a=0x%x\r\n",&a);
    printf("P=0x%x\r\n",p);
    printf("a=%d\r\n",a);
    printf("*p=%d\r\n",*p);
    printf("*0x404090=%d\r\n",*((unsigned char *)0x404090));
    
    printf("&p=0x%x\r\n",&p);
    printf("*0x4040A0=0x%x\r\n",*((unsigned int *)0x4040A0));
    
    *p = 20; 
    printf("a=%d\r\n",a);
    printf("*p=%d\r\n",*p);
    
    return(0);
}

3. 数组与指针

一般编译器会分配连续地址的内存，来存储数组里的元素。

3.1 数组当指针用

其实数组，本质上也是指针。

我们来做个实验：

#include <stdlib.h>

// 定义一个无符号字符数组buff，初始化为{1, 2, 3, 4, 5}，数组长度为5
unsigned char buff[5] = {1,2,3,4,5};


// 主函数入口点
int main()
{

    // 打印数组buff的首地址，以十六进制形式
    printf("buff=0x%x\r\n",buff);
    // 打印数组buff第一个元素的地址，以十六进制形式
    printf("&buff[0]=0x%x\r\n",&buff[0]);
    
    //打印buff[0]的值，通过指针的形式访问
    printf("buff[0]=%d\r\n",*buff);
    
    // 打印一个空行以便于区分下面的输出
    printf("\r\n");
    
    // 程序正常结束并返回0
    return(0);
}

代码输出结果：

我们分别打印了 buff 和&buff[0]的地址，发现地址是一样的。

既然是个地址，那应该可以是用指针的形式，去访问地址里存储的值的。

然后我打印*buff 的值，得到的结果是 1，正好和 buff[0]数组的值对应。

得出结论，数组也可以用指针的形式去用。

3.2 通过指针变量引用数组

也可以通过定义指针变量来引用数组，读写数组里的元素。

我们来做个实验：

#include <stdlib.h>

// 定义一个无符号字符数组buff，初始化为{1, 2, 3, 4, 5}，数组长度为5
unsigned char buff[5] = {1,2,3,4,5};

// 定义两个指向无符号字符的指针变量p1和p2
unsigned char *p1;
unsigned char *p2;

// 主函数入口点
int main()
{
    // 将指针p1指向数组buff的首地址
    p1 = buff;
    // 将指针p2指向数组buff的第一个元素的地址，这和p1指向的是同一个地址
    p2 = &buff[0];
    
    // 打印数组buff的首地址，以十六进制形式
    printf("buff=0x%x\r\n",buff);
    // 打印数组buff第一个元素的地址，以十六进制形式
    printf("&buff[0]=0x%x\r\n",&buff[0]);
    // 打印指针p1的地址，由于它指向buff，所以打印的是buff的地址
    printf("p1_addr=0x%x\r\n",p1);
    // 打印指针p2的地址，由于它也指向buff的第一个元素，所以打印的也是buff的地址
    printf("p2_addr=0x%x\r\n",p2);
    
    // 打印一个空行以便于区分下面的输出
    printf("\r\n");
    
    // 打印数组buff的第一个元素的值，即1
    printf("buff[0]=%d\r\n",buff[0]);
    // 通过指针p1解引用，打印它指向的值，即数组buff的第一个元素的值，也是1
    printf("*p1=%d\r\n",*p1);
    // 通过指针p2解引用，打印它指向的值，即数组buff的第一个元素的值，同样是1
    printf("*p2=%d\r\n",*p2);
    
    // 程序正常结束并返回0
    return(0);
}

代码输出结果如下：

注意：buff 和&buff[0]都是代表数组首地址(即 buff[0]的存储地址)。

从输出结果来看，数组和指针变量的地址都是一样的，所以大家用这几种写法，都是可以读写数组里的值的。

也可以修改指针指向地址的值，达到修改数组值的效果：

#include <stdlib.h>

unsigned char buff[5] = {1,2,3,4,5};

unsigned char *p1;
unsigned char *p2;

int main()
{
    p1 = buff;
    p2 = &buff[0];
    printf("buff=0x%x\r\n",buff);
    printf("&buff[0]=0x%x\r\n",&buff[0]);
    printf("p1_addr=0x%x\r\n",p1);
    printf("p2_addr=0x%x\r\n",p2);
    
    printf("\r\n");
    printf("buff[0]=%d\r\n",buff[0]);
    printf("*p1=%d\r\n",*p1);
    printf("*p2=%d\r\n",*p2);
    
    printf("\r\n");
    
    *p1 = 7;
    printf("buff[0]=%d\r\n",buff[0]);
    printf("*p1=%d\r\n",*p1);
    printf("*p2=%d\r\n",*p2);
     
    return(0);
}

代码输出结果：

4.指针自加自减运算

指针加减运算，常用有以下几种：

p++;    //等同于p = p+1;
p--;    //等同于p = p-1;
p += 1; //等同于p = p+1;
p -= 1; //等同于p = p-1;

当然，加减法运算的值不限于 1，也可以是其它数，前提是加减完后，仍是有效地址。

p += 9; //等同于p = p+9;
p -= 9; //等同于p = p-9;

注意：加或减运算，是指加减整个指针类型的长度。

我们做个实验：

#include <stdlib.h>

// 定义一个无符号字符数组buff，初始化为{1, 2, 3, 4, 5}
unsigned char buff[5] = {1,2,3,4,5};
// 定义一个无符号整型数组buff2，初始化为{10, 11, 12, 13, 14}
unsigned int buff2[5] = {10,11,12,13,14};

// 定义一个指向无符号字符的指针p1
unsigned char *p1;
// 定义一个指向无符号整型的指针p2
unsigned int *p2;

// 主函数入口点
int main()
{
    // 将指针p1指向数组buff的首地址
    p1 = buff;
    // 将指针p2指向数组buff2的首地址
    p2 = buff2;
    
    // 打印数组buff和buff2的地址，以十六进制形式
    printf("buff=0x%x, buff2=0x%x\r\n",buff,buff2);
    // 打印指针p1的地址和它指向的值（即buff的第一个元素1）
    printf("p1_addr=0x%x, *p1=%d\r\n",p1,*p1);
    // 打印指针p2的地址和它指向的值（即buff2的第一个元素10）
    printf("p2_addr=0x%x, *p2=%d\r\n",p2,*p2);
    
    //将指针p1向前移动一个单位，现在它指向buff的第二个元素
    p1++;
    // 将指针p2向前移动一个单位，现在它指向buff2的第二个元素
    p2++;
    
    // 打印一个空行以便于区分下面的输出
    printf("\r\n");

    // 打印移动后的指针p1的地址和它现在指向的值（即buff的第二个元素2）
    printf("p1_addr=0x%x, *p1=%d\r\n",p1,*p1);
    // 打印移动后的指针p2的地址和它现在指向的值（即buff2的第二个元素11）
    printf("p2_addr=0x%x, *p2=%d\r\n",p2,*p2);
    
    //将指针p1向前移动三个单位，现在它指向buff的第五个元素
    p1 = p1+3; 
    //将指针p2向前移动三个单位，现在它指向buff的第五个元素
    p2 = p2+3;
    printf("\r\n");

    printf("p1_addr=0x%x, *p1=%d\r\n",p1,*p1);
    printf("p2_addr=0x%x, *p2=%d\r\n",p2,*p2);
    
    // 程序正常结束并返回0
    return(0);
}

代码输出结果如下：

p1++等同于p1=p1+1，这里加1，是指把p1这个地址加上1个字节，因为p1是unsigned char类型，这个类型占用内存1个字节的存储空间。

p2++等同于p2=p2+1，这里加1，是指把p1这个地址加上4个字节，因为p2是unsigned int类型，这个类型占用内存4个字节的存储空间。

5.双重指针

指针变量可以指向字符型、整型、数组等，当然也可以指向指针变量，指向指针类型变量时，也叫双重/二级指针。

定义方法：

数据类型 **指针变量名；

例如：unsigned char **p;

直接上实验：

#include <stdlib.h>

// 定义一个无符号字符变量
unsigned char a;
// 定义一个指向无符号字符的指针p1
unsigned char *p1;
// 定义一个指向无符号字符的指针的指针p2，即p2是一个双重/二级指针
unsigned char **p2;

// 主函数入口点
int main()
{
    // 将变量a的值设置为10
    a = 10;
    // 将指针p1指向变量a的地址 
    p1 = &a;
    // 把p1指针变量在内存中的存储地址，赋值给p2双重指针变量。
    p2 = &p1;
    
    // 打印变量a的地址和a的值，地址以十六进制形式打印，a的值以十进制形式打印
    printf("&a=0x%x, a=%d\r\n",&a,a);
    // 打印指针p1的地址和p1指向的值（即变量a的值），地址和值都以十六进制和十进制形式打印
    printf("p1=0x%x, *p1=%d\r\n",p1,*p1);
    
    //p2 - p2变量的存储地址
    //*p2 - p2指向的值（即p1变量的存储地址）
    //**p2 - p1指向的值（即变量a的值）
    printf("p2=0x%x, *p2=0x%x, **p2=%d\r\n",p2,*p2,**p2);
     // 程序正常结束并返回0
    return(0);
}

代码输出结果：

我们重点来讲下双重指针变量 p2：

p2 - p2 变量的存储地址 *p2 - p2 指向的值（即 p1 变量的存储地址） **p2 - p1 指向的值（即变量 a 的值）

”*”这个运算符是从右到左进行运算的，**p2 就是*(*p2)，先取指向地址，再取指向地址里面存储的值。

指针容易把人搞晕的就是，指针变量本身的存储地址和指向的地址分不清楚，这个是两个概念。

一般在单片机程序中，尽量少使用这种指向指针的指针，防止出现 Bug 的时候非常难排查，目前我就在队列中使用过。

6.二维数组与指针

二维数组和双重指针有点类似。

前面我们讲了数组也能当指针用，通过指针可以访问数组任意下标的值。

我们直接上实验：

// 定义一个无符号字符数组buff，初始化为{1, 2, 3, 4, 5}，数组长度为5
unsigned char buff[5] = {1,2,3,4,5};

// 主函数入口点
int main()
{
    // 打印数组buff的首地址，以十六进制形式
    printf("buff=0x%x\r\n",buff);
    // 打印数组buff第一个元素的地址，以十六进制形式
    printf("&buff[0]=0x%x\r\n",&buff[0]);
    
        // 打印buff[0]的值  
    printf("buff[0]=%d\r\n",*buff);
        // 打印buff[1]的值  
    printf("buff[1]=%d\r\n",*(buff+1));
    // 打印buff[0]的值  
    printf("buff[2]=%d\r\n",*(buff+2));
    // 程序正常结束并返回0
    return(0);
}

代码输出结果如下：

通过结果，我们可以看到，一维数组，数组名即指针，可以通过指针加/减运算，灵活访问数组每个元素的值。

那二维数组，又怎样通过二维指针的方式用呢？

请注意，请注意，建议你找个没人打扰的角落，因为马上就要进入烧脑实验啦！！！！

下面实验代码来喽：

#include <stdlib.h>

// 定义一个3行2列的二维数组buff
unsigned char buff[3][2] = {{1,2},{3,4},{5,6}};

int main()
{
   // 打印buff数组第一行第一列元素的地址和值
    printf("&buff[0][0]=0x%x, buff[0][0]=%d\r\n",buff,**buff);
    // 打印buff数组第一行第二列元素的地址和值
        printf("&buff[0][1]=0x%x, buff[0][1]=%d\r\n",(*buff)+1,*((*buff)+1));
        
        // 打印一个空行，用于分隔输出
        printf("\r\n");

        // 打印buff数组第二行第一列元素的地址和值
        printf("&buff[1][0]=0x%x, buff[1][0]=%d\r\n",buff+1,*(*(buff+1)));
        // 打印buff数组第二行第二列元素的地址和值
        printf("&buff[1][1]=0x%x, buff[1][1]=%d\r\n",(*(buff+1))+1,*((*(buff+1))+1));
        
        printf("\r\n");
        
        // 打印buff数组第三行第一列元素的地址和值
        printf("&buff[2][0]=0x%x, buff[2][0]=%d\r\n",buff+2,*(*(buff+2)));
        // 打印buff数组第三行第二列元素的地址和值
        printf("&buff[2][1]=0x%x, buff[2][1]=%d\r\n",(*(buff+2))+1,*((*(buff+2))+1));
        
    return(0);
}

代码输出结果：

这个代码演示了，通过二级指针，打印了二维数组每个元素的地址和值。

总结：

*(*(buff+ i) + j)换成二维数组的形式，等同于 buff[i][j] 。

7.指针数组

指针数组是一种数组，数组的每个元素都是指针。

定义方法：

数据类型 *指针数组名[数组元素个数]；

例如：unsigned char *pBuff[3];

直接上实验代码：

#include <stdlib.h>

//定义三个无符号字符数组buff1, buff2, buff3 
unsigned char buff1[3] = {1,2,3};
unsigned char buff2[3] = {4,5,6};
unsigned char buff3[3] = {7,8,9};

// 定义一个指针数组pBuff，它可以存储3个指向无符号字符的指针
unsigned char *pBuff[3];

int main()
{
        pBuff[0] = buff1;//pBuff[0]现在指向buff1数组
        pBuff[1] = buff2;//pBuff[1]现在指向buff2数组
        pBuff[2] = buff3;//pBuff[2]现在指向buff3数组
        
 //打印buff1数组的地址，pBuff[0]的地址，以及通过pBuff[0]访问的buff1数组的第一个元素的值
    printf("&buff1=0x%x, &pBuff[0]=0x%x, *pBuff[0]=%d\r\n",buff1,pBuff[0],*pBuff[0]);
    printf("&buff2=0x%x, &pBuff[1]=0x%x, *pBuff[1]=%d\r\n",buff2,pBuff[1],*pBuff[1]);
    printf("&buff3=0x%x, &pBuff[2]=0x%x, *pBuff[2]=%d\r\n",buff3,pBuff[2],*pBuff[2]);
        printf("\r\n");
 
    return(0);
}

代码输出结果：

这个代码，演示了如何使用指针数组，来管理多个数组。

其实还有一个叫概念，叫数值指针，理解起来也很恶心，我做产品开发时，也用的比较少，这里就不讲了。

8.函数指针

如果在程序中定义了一个函数，那么在编译时系统就会为这个函数代码分配一段存储空间，这段存储空间的首地址称为这个函数的地址。

而且函数名表示的就是这个地址。

既然是地址，我们就可以定义一个指针变量来引用，这个指针变量就叫作函数指针变量，简称函数指针。

函数指针的产品应用非常多，特别是做一些可扩展性，可移植性强的程序，我愿称之为刚需。

定义方法：

函数返回值类型 (* 指针变量名) (函数参数列表);

例如： unsigned char (*func)(unsigned char,unsigned char);

这样就定义了一个函数指针变量 func, 该函数指针返回值为 unsigned char 类型，然后有 2 个形参，分别是 unsigned char 类型。

那么我们定义了这个函数指针变量以后,要怎么使用呢？

我们直接上实验代码：

#include <stdlib.h> 

// 定义一个函数指针func，它可以指向接受两个无符号字符参数，并返回一个无符号字符类型的值
unsigned char (*func)(unsigned char, unsigned char);

// 定义一个函数add，它接受两个无符号字符参数v1和v2，并返回它们的和
unsigned char add(unsigned char v1, unsigned char v2) 
{
    return (v1 + v2); // 返回两个参数的和
} 

int main() 
{
    unsigned char a; // 定义一个无符号字符变量a，用于存储函数的返回值

    // 将函数指针func指向add函数，这样func就可以像调用add函数一样使用
    func = add;
    
    // 通过函数指针func调用add函数，传入1和2作为参数，并将返回值赋给变量a
    a = (*func)(1, 2);
    
    // 使用printf函数打印变量a的值
    printf("a=%d\r\n", a);

    return 0; // 程序正常结束，返回0
}

代码输出结果：

定义一个函数指针 func，定义一个函数 add，将函数指针 func 指向 add 函数，这样调用 func 等同于调用 add 函数，输出结果 a=3.

注意：函数指针指向的函数，返回值类型要一致，形参类型和数量也要一致。

9.函数指针数组

函数指针数组，我在实际产品开发时，也用的比较多，特别适合一些函数功能类似的场合，比如控制很多个 LED 灯，检测很多个按键输入。

定义方法：

函数返回值类型 (* 指针变量名[数组大小]) (函数参数列表);

Void (*func[3])();

这样就定义了一个可以指向 3 个函数的函数指针数组，没有返回值，没有形参。

定义了以后，我们函数指针需要赋值，赋值的意思就是让它们指向函数首地址。

9.1 函数指针数组两种初始化方式

9.1.1 定义函数指针数组的时候直接初始化。

void func1();
void func2();
void func3();
void (*func[3])() = {func1,func2,func3};

9.1.2 先定义然后再初始化


void func1();
void func2();
void func3();

void (*func[3])();

func[0] = func1;
func[1] = func2;
func[2] = func3;

9.2 函数指针数组使用方式

#include <stdlib.h> // 包含标准库头文件，这里用于使用printf函数

// 声明一个函数指针数组func，存储3个函数指针，无返回值，无形参
void (*func[3])();

// 声明三个无返回值，无形参的函数
void func1();
void func2();
void func3();

// 初始化func数组，将func1, func2, func3的地址分别赋给func数组的三个元素
void (*func[3])() = {func1, func2, func3};

void func1() 
{
    printf("无际单片机任务1\r\n");
}

void func2() 
{
    printf("无际单片机任务2\r\n");
}

void func3() 
{
    printf("无际单片机任务3\r\n");
}

// main函数，程序的入口点
int main() {
    // 通过函数指针数组func调用func1, func2, func3函数
    func[0](); // 调用func1函数
    func[1](); // 调用func2函数
    func[2](); // 调用func3函数
    
    return 0;  
}

代码输出结果：