单片机软件架构连载(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;  
}

代码输出结果:

我们可以看到直接写 func[0](),func[1]()...,就可以执行函数指针数值指向的函数了。

10.总结

学到这里,我估计很多童鞋想说卧槽了!指针花样真特么多。

我无意吓你,其实以上这些,都只是基础,真正复杂的是它的应用。

指针太灵活了,这个特性让它能构建更多,更复杂的应用场景,比如我们无际单片机特训营项目里,用指针去实现了回调函数、队列、链表、任务管理等各种高阶的应用。

你或许有点绝望, 太难了。

好消息是,每个人都是这样过来的,先理解,不用去背语法,比如说函数指针这种,我有时也记不住怎么定义,直接百度搜就好了,然后在我们项目实战的过程中,再深入学习指针的应用,怼它几个项目,就很熟悉了。


最近很多粉丝问我单片机怎么学,我根据自己从业十年经验,累积耗时一个月,精心整理一份「单

片机最佳学习路径+单片机入门到高级教程+工具包」全部无偿分享给铁粉!!!

除此以外,再含泪分享我压箱底的22个热门开源项目,包含源码+原理图+PCB+说明文档,让你迅速进阶成高手

教程资料包和详细的学习路径可以看我下面这篇文章的开头

单片机入门到高级开挂学习路径(附教程+工具)

单片机入门到高级开挂学习路径(附教程+工具)

单片机入门到高级开挂学习路径(附教程+工具)

上一篇:AV