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

news2024/12/22 13:14:35

我工作了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+说明文档,让你迅速进阶成高手

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

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

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

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

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.coloradmin.cn/o/1885294.html

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈,一经查实,立即删除!

相关文章

C++封装

1. 封装 1.1. struct 当单一变量无法完成描述需求的时候&#xff0c;结构体类型解决了这一问题。可以将多个类型打包成一体&#xff0c;形成新的类型&#xff0c;这是c语言中的封装 但是&#xff0c;新类型并不包含&#xff0c;对数据类的操作。所有操作都是通过函数的方式进…

python-糖果俱乐部(赛氪OJ)

[题目描述] 为了庆祝“华为杯”的举办&#xff0c;校园中开展了许多有趣的热身小活动。小理听到这个消息非常激动&#xff0c;他赶忙去参加了糖果俱乐部的活动。 该活动的规则是这样的&#xff1a;摊位上有 n 堆糖果&#xff0c;第 i 堆糖果有 ai​ 个&#xff0c;参与的同学可…

从入门到深入,Docker新手学习教程

编译整理&#xff5c;TesterHome社区 作者&#xff5c;Ishaan Gupta 以下为作者观点&#xff1a; Docker 彻底改变了我们开发、交付和运行应用程序的方式。它使开发人员能够将应用程序打包到容器中 - 标准化的可执行组件&#xff0c;将应用程序源代码与在任何环境中运行该代码…

YOLOv10改进教程|C2f-CIB加入注意力机制

一、 导读 论文链接&#xff1a;https://arxiv.org/abs/2311.11587 代码链接&#xff1a;GitHub - CV-ZhangXin/AKConv YOLOv10训练、验证及推理教程 二、 C2f-CIB加入注意力机制 2.1 复制代码 打开ultralytics->nn->modules->block.py文件&#xff0c;复制SE注意力机…

快排的实现

引言 作为c语言库函数的一种&#xff0c;快排在排序中的地位毋庸置疑. 而更加具体的实现如图&#xff1a; 快排的实现&#xff08;递归实现&#xff09; 原理 单趟:先假定第一个数设为key,如果左边指针的值比key大&#xff0c;且右边指针的值比key小&#xff0c;则将其交换.…

无线领夹麦克风有什么用,揭秘唱歌不费力的无线麦克风

随着自媒体行业的快速扩张&#xff0c;人们对音频录制设备的要求日益增长&#xff0c;麦克风作为核心设备之一&#xff0c;其重要性不言而喻。技术的演进使得麦克风从简单的无线小蜜蜂发展到多功能的数字领夹麦克风&#xff0c;满足了多样化的录制需求。然而&#xff0c;一个视…

昇思MindSpore学习总结八——模型保存与加载

在训练网络模型的过程中&#xff0c;实际上我们希望保存中间和最后的结果&#xff0c;用于微调&#xff08;fine-tune&#xff09;和后续的模型推理与部署&#xff0c;接下来将介绍如何保存与加载模型。 1.构建模型 import numpy as np import mindspore from mindspore impo…

别再被大模型骗了,一个小技巧,让LLaMa3诚信度提升65%

人工智能正以惊人的速度发展&#xff0c;大语言模型(LLM)作为其中的"明星"&#xff0c;展现了令人赞叹的语言理解和生成能力。然而&#xff0c;在享受大语言模型带来便利的同时&#xff0c;我们也必须正视其在诚实性和安全性方面所面临的挑战。 近期&#xff0c;华中…

CSF视频文件格式转换WMV格式(2024年可用)

如果大家看过一些高校教学讲解视频的话&#xff0c;很可能见过这样一个难得的格式&#xff0c;".csf "&#xff0c;非常漂亮 。 用暴风影音都可以打开观看&#xff0c;会自动下载解码。 但是一旦我们想要利用或者上传视频的时候就麻烦了&#xff0c;一般网站不认这…

3个企业级最佳实践,教你ByteHouse云数仓这么用

随着各业务场景各行业数字化转型加快&#xff0c;数据量呈爆炸式增长。在拥有庞大数据的同时&#xff0c;业务也在分析、查询与响应层面&#xff0c;对数据库系统性能提出了更高要求。云原生技术推动了分布式数据库系统的迭代升级&#xff0c;对云数仓技术而言&#xff0c;“写…

MacBook关闭谷歌浏览器双指左右移动(扫动)前进后退功能

这个功能真的很反人类&#xff0c;正常上下滑动页面的时候很容易误操作&#xff0c;尤其是当你在一个页面上做了很多的编辑工作后误触发了此手势&#xff0c;那真叫一个崩溃&#xff01; 其实这应该是 Macbook 触控板提供的一个快捷操作&#xff0c;跟浏览器本身估计没关系&am…

mysql-sql-第十三周

学习目标&#xff1a; sql 学习内容&#xff1a; 37.查询各科成绩最高分、最低分和平均分&#xff1a; 以如下形式显示&#xff1a;课程 ID,课程 name,最高分,最低分,平均分,及格率,中等率,优良率,优秀率 及格为>60,中等为&#xff1a;70-80,优良为&#xff1a;80-90,优秀…

使用Comsol进行边坡稳定性分析的例子——详细步骤(第二部分)

使用Comsol进行边坡稳定性分析的例子——详细步骤 研究1方法结果书接上回 在FOS参数的帮助下,对材料强度进行参数化。在第二个研究步骤中添加 FOS 的辅助扫描。对于某些 FOS 值,解不会收敛,并且设置为最后一个 FOS 值的默认图将给出错误。禁用此研究的默认绘图以避免出现错误…

65、基于卷积神经网络的调制分类(matlab)

1、基于卷积神经网络的调制分类的原理及流程 基于卷积神经网络&#xff08;CNN&#xff09;的调制分类是一种常见的信号处理任务&#xff0c;用于识别或分类不同调制方式的信号。下面是基于CNN的调制分类的原理和流程&#xff1a; 原理&#xff1a; CNN是一种深度学习模型&a…

root密码忘了怎么办(从系统引导过程解决)

目录 1.Linux系统密码忘记 2.系统引导过程 2.1 systemd 2.2 GRUB和GRUB2 2.3 运行级别 3.修复MBR扇区故障和GRUB引导故障 3.1 MBR扇区故障 3.2 GRUB引导故障 1.Linux系统密码忘记 我们在生活中经常遇到这类困扰&#xff0c;就是某个账号还是账户密码忘了&#xff0c;这…

Llama也能做图像生成?文生图模型已开源

导读 基于next-token prediction的图像生成方法首次在ImageNet benchmark超越了LDM, DiT等扩散模型&#xff0c;证明了最原始的自回归模型架构同样可以实现极具竞争力的图像生成性能。 Llama也能做图像生成&#xff1f;文生图模型已开源 香港大学、字节跳动提出了基于自回归模…

【AI大模型】大型模型飞跃升级—文档图像识别领域迎来技术巨变_图像识别大模型

写在前面 2023年12月31日&#xff0c;第十九届中国图象图形学学会青年科学家会议在广州举行&#xff0c;由中国图象图形学学会主办。 该会议的目标是促进青年科学家之间的交流与合作&#xff0c;以提升我国在图像图形领域的科研水平和创新能力。 由中国图象图形学学会和上海合合…

如何将音频文件发送至摄像头

目前再很多互联互通的场景下&#xff0c;如AI盒子再从摄像头上取视频分析&#xff0c;分析出发生某个事件&#xff0c;需要反向通过摄像头的喇叭播放语音&#xff0c;发出告警提示&#xff0c;使用场景如下 盒子上对于此类场景的需求往往不能满足&#xff0c;或者为这个需求需要…

Day8: 232.用栈实现队列 225. 用队列实现栈 20. 有效的括号 1047. 删除字符串中的所有相邻重复项

题目232. 用栈实现队列 - 力扣&#xff08;LeetCode&#xff09; class MyQueue { public:MyQueue() {}void push(int x) { // 出栈input.push(x);}int pop() {// 如果出栈为空&#xff0c;把入栈元素全都转移到出栈if (output.empty()) {while (!input.empty()) {int itop i…

【WEB前端2024】3D智体编程:乔布斯3D纪念馆-第52课-语音控制机器人

【WEB前端2024】3D智体编程&#xff1a;乔布斯3D纪念馆-第52课-语音控制机器人 使用dtns.network德塔世界&#xff08;开源的智体世界引擎&#xff09;&#xff0c;策划和设计《乔布斯超大型的开源3D纪念馆》的系列教程。dtns.network是一款主要由JavaScript编写的智体世界引擎…