从单片机基础到程序框架（连载）

单片机

杨光 · 2017-4-30 22:39:16

佩服和尊敬，支持吴工！！！

hong45691 · 2017-5-4 11:16:08

又看一下，学习学习

jiangyi · 2017-5-4 22:22:35

学习了。看看啊啊啊

bg6jlj · 2017-5-4 23:59:57

学习了，感谢楼主。

吴坚鸿 · 2017-5-7 10:35:54

第六十八节：为函数接口指针“定向”的const关键词。

【68.1 为函数接口指针“定向”的const关键词。】

在函数接口处的指针，是一个双向口，既可以作为“输入”也可以作为“输出”，换句话说，既能“读”也能“写”（被更改），这样一来，当你把一个数组（或者某变量）通过指针引入到函数内部的时候，当执行完此函数，这个数组的数值可能已经悄悄发生了更改（“是否被更改”取决于函数内部的具体代码），进来时是“摩托”出来后可能已变成“单车”，而实际项目上，很多时候我们只想传递数组（或者某变量）的数值，并不想数组（或者某变量）本身发生变化，这个时候，本节的主角const关键词就派上用场了。
只要在函数接口的指针前面加上const关键词，原来双向的指针就立刻变成了单向，只能输入不能输出。这个const有两个好处。第一个好处是方便阅读，通过const就知道此接口的“入口”和“出口”属性，如果你是用别人已经封装好的函数，一旦发现接口指针带了const标签，就足以说明这个指针只能作为输入接口，不用担心输入数据被意外修改。第二个好处是确保数据的安全，函数接口指针一旦加了const限定，万一你不小心在函数内部对指针所关联的数据进行了更改（“更改”就意味着“出口”），C编译器在编译的时候就会报错让你编译失败，及时让你发现程序的bug(程序的漏洞)，这是编译器层面的一道防火墙。例子如下：

unsigned char ShuRu(const unsigned char *pu8Data)
{
unsigned char a;
a=*pu8Data; //这行代码是合法的，是指针所关联数据的“读”操作。
*pu8Data=a; //这行代码是非法的，是指针所关联数据的“写”操作，违背const的约束。
return a;
}

复制代码

【68.2 例程练习和分析。】

在前面第65节讲函数入口的时候，用到一个求数组平均值的程序例子，这个数组是仅仅作为输入用的，不需要被更改，因此，现在借本节讲const的机会，为此函数的接口指针补上一个const关键词，让该函数更加科学规范，程序如下：

/*---C语言学习区域的开始。-----------------------------------------------*/
unsigned long PinJunZhi(const unsigned char *pu8Buffer); //指针前增加一个const关键词
unsigned char Gu8Buffer[4]={2,6,8,4};
unsigned long Gu32PinJunZhi;
unsigned long PinJunZhi(const unsigned char *pu8Buffer) //指针前增加一个const关键词
{
unsigned long u32PinJunZhi;
u32PinJunZhi=(pu8Buffer[0]+pu8Buffer[1]+pu8Buffer[2]+pu8Buffer[3])/4; //求平均值
return u32PinJunZhi;
}
void main() //主函数
{
Gu32PinJunZhi=PinJunZhi(&Gu8Buffer[0]);//不用担心Gu8Buffer数组的数据被意外更改。
View(Gu32PinJunZhi); //把第1个数Gu32PinJunZhi发送到电脑端的串口助手软件上观察。
while(1)
{
}
}
/*---C语言学习区域的结束。-----------------------------------------------*/

复制代码

      在电脑串口助手软件上观察到的程序执行现象如下：

开始...

第1个数
十进制:5
十六进制:5
二进制:101

分析：
      平均值变量Gu32PinJunZhi为5。

【68.3 如何在单片机上练习本章节C语言程序？】

      直接复制前面章节中第十一节的模板程序，练习代码时只需要更改“C语言学习区域”的代码就可以了，其它部分的代码不要动。编译后，把程序下载进带串口的51学习板，通过电脑端的串口助手软件就可以观察到不同的变量数值，详细方法请看第十一节内容。

郭亚龙 · 2017-5-8 19:16:27

jianhong_wu 发表于 2016-1-18 11:34
第一节：我的价值观。我2006年毕业，2009年就出来做自由职业者在深圳以接单片机项目谋生，到现在我有自己的机器人技术有限公司，做数控机器人系统，运动卡，三轴五轴联动之类的产品。目前公司的ARM单片机编程，DSP编程，FPGA编程，电路板设计，上位机软件都是由我带领的研发团队在做。我只专心做技术，而市场，生产， ...

刚好用到，谢谢分享

吴坚鸿 · 2017-5-14 10:26:40

第六十九节：宏函数sizeof()。

【69.1 宏函数sizeof()的基础知识。】

宏函数sizeof()是用来获取某个对象所占用的字节数。既然是“宏”，就说明它不是单片机执行的函数，而是单片机之外的C编译器执行的函数（像#define这类宏语句一样），也就是说，在单片机上电之前，C编译器在电脑端翻译我们的C语言程序的时候，一旦发现了这个宏函数sizeof，它就会在电脑端根据C语言程序的一些关键字符（比如“unsigned char,[,]”这类字符）来自动计算这个对象所占用的字节数，然后再把我们C语言程序里所有的sizeof字符替换等效成一个“常量数字”，1代表1个字节，5代表5个字节，1000代表1000个字节。所谓在单片机之外执行的宏函数，就是说，在“计算”这些对象所占的字节数的时候，这个“计算”的工作只占用电脑的内存（C编译器是在电脑上运行的），并不占用单片机的ROM容量和内存。而其它在单片机端执行的“非宏”函数，是占用单片机的ROM容量和内存。比如：

unsgiend char a; //变量。占用1个字节
unsgiend int b; //变量。占用2个字节
unsgiend long c; //变量。占用4个字节
code unsgiend char d[9]; //常量。占用9个字节
unsigned int Gu16GetBytes; //这个变量用来获取字节数
Gu16GetBytes=sizeof(a); //单片机上电后，在单片机程序里等效于Gu16GetBytes=1;
Gu16GetBytes=sizeof(b); //单片机上电后，在单片机程序里等效于Gu16GetBytes=2;
Gu16GetBytes=sizeof(c); //单片机上电后，在单片机程序里等效于Gu16GetBytes=4;
Gu16GetBytes=sizeof(d); //单片机上电后，在单片机程序里等效于Gu16GetBytes=9;

复制代码

      上述的“sizeof字符”在进入到单片机的层面的时候，已经被编译器预先替换成对应的“常量数字”的，这个“常量数字”就代表所占用的字节数。

【69.2 宏函数sizeof()的作用。】

      在项目中，通常用在两个方面：一方面是用在求一个数组的大小尺寸，另一方面是用在计算内存分配时候的偏移量。当然，sizeof并不是“刚需”，如果没有sizeof宏函数，我们也可以人工计算出一个对象所占用的字节数，只是，人工计算，一方面容易出错，另一方面代码往往“动一发而牵全身”，改一个变量往往就会涉及很多地方需要配合调整更改，没法做到“自由裁剪”的境界。下面举一个程序例子：要把3个不同长度的数组“合并”成1个数组。

      第一种情况：在没有使用sizeof宏函数时，人工计算字节数和偏移量：

unsigned char a[2]={1,2}; //占用2个字节
unsigned char b[3]={3,4,5}; //占用3个字节
unsigned char c[4]={6,7,8,9}; //占用4个字节
unsigned char HeBing[9];//合并a,b,c在一起的数组。这里的9是人工计算a,b,c容量累加所得。
unsigned char i; //循环变量i
for(i=0;i<2;i++) //这里的2，是人工计算出a占用2个字节
{
HeBing[i+0]=a[i]; //从HeBing数组的偏移量第0个地址开始存放。
}
for(i=0;i<3;i++) //这里的3，是人工计算出b占用3个字节
{
HeBing[i+2]=b[i]; //这里的2是人工计算出的偏移量。a占用了数组2个字节。
}
for(i=0;i<4;i++) //这里的4，是人工计算出c占用4个字节
{
HeBing[i+2+3]=c[i]; //这里的2和3是人工计算出的偏移量，a和b占用了数组2+3个字节。
}

复制代码

第二种情况：在使用sizeof宏函数时，利用C编译器自动来计算字节数和偏移量：

unsigned char a[2]={1,2}; //占用2个字节
unsigned char b[3]={3,4,5}; //占用3个字节
unsigned char c[4]={6,7,8,9}; //占用4个字节
unsigned char HeBing[sizeof(a)+sizeof(b)+sizeof(c)];//C编译器自动计算字节数
unsigned char i;
for(i=0;i
{
HeBing[i+0]=a[i];
}
for(i=0;i
{
HeBing[i+sizeof(a)]=b[i]; //C编译器自动计算偏移量
}
for(i=0;i
{
HeBing[i+sizeof(a)+sizeof(b)]=c[i]; //C编译器自动计算偏移量
}

复制代码

【69.3 例程练习和分析。】

现在编写一个练习的程序：

/*---C语言学习区域的开始。-----------------------------------------------*/
unsigned char a[2]={1,2}; //占用2个字节
unsigned char b[3]={3,4,5}; //占用3个字节
unsigned char c[4]={6,7,8,9}; //占用4个字节
unsigned char HeBing[sizeof(a)+sizeof(b)+sizeof(c)];//C编译器自动计算字节数
unsigned char i;
void main() //主函数
{
for(i=0;i
{
HeBing[i+0]=a[i];
}
for(i=0;i
{
HeBing[i+sizeof(a)]=b[i]; //C编译器自动计算偏移量
}
for(i=0;i
{
HeBing[i+sizeof(a)+sizeof(b)]=c[i]; //C编译器自动计算偏移量
}
for(i=0;i
{
View(HeBing[i]); //把HeBing所有数据挨个依次全部发送到电脑端观察
}
while(1)
{
}
}
/*---C语言学习区域的结束。-----------------------------------------------*/

复制代码

在电脑串口助手软件上观察到的程序执行现象如下：

开始...
第1个数
十进制:1
十六进制:1
二进制:1
第2个数
十进制:2
十六进制:2
二进制:10
第3个数
十进制:3
十六进制:3
二进制:11
第4个数
十进制:4
十六进制:4
二进制:100
第5个数
十进制:5
十六进制:5
二进制:101
第6个数
十进制:6
十六进制:6
二进制:110
第7个数
十进制:7
十六进制:7
二进制:111
第8个数
十进制:8
十六进制:8
二进制:1000
第9个数
十进制:9
十六进制:9
二进制:1001

复制代码

分析：
      HeBing[0]为1。
      HeBing[1]为2。
      HeBing[2]为3。
      HeBing[3]为4。
      HeBing[4]为5。
      HeBing[5]为6。
      HeBing[6]为7。
      HeBing[7]为8。
      HeBing[8]为9。

【69.4 如何在单片机上练习本章节C语言程序？】

      直接复制前面章节中第十一节的模板程序，练习代码时只需要更改“C语言学习区域”的代码就可以了，其它部分的代码不要动。编译后，把程序下载进带串口的51学习板，通过电脑端的串口助手软件就可以观察到不同的变量数值，详细方法请看第十一节内容。

吴坚鸿 · 2017-5-21 10:24:28

第七十节： “万能数组”的结构体。

【70.1 结构体与数组。】

结构体是数组，但不是普通的数组，而是一种“万能数组”。普通数组，是依靠严格的数组下标（类似编号）来识别某个具体单元的（或者称“寻址”），期间，如果要往数组插入或者删除某些单元，后面所有单元的下标编号都会发生改变，牵一发而动全身，后面其它单元的下标序号自动重新排列，原来某个特定的单元的下标发生了改变，也就意味着“名字”发生了改变，这种情况在编写程序的时候，就意味着很多代码需要随着更改调整，给程序员带来很多不便。怎么办？结构体此时横空出世，扭转了这种“不便”的局面。之所以称结构体为“万能数组”，是因为结构体内部没有“下标编号”，只有名字。结构体与普通数组的本质区别是，结构体是靠“名字”来寻址的，不管你往结构体里插入或者删除某些单元，其它单元的“名字”不会发生改变，隔离效果好，左邻右舍不会受影响。除此之外，结构体内部的成员变量是允许出现不同的数据类型的，比如unsigned char,unsigned int,unsigned long这三种数据类型的变量都可以往同一个结构体里面“填充”，不受类型的局限，真正做到“万能”级。而普通数组就没有这个优越性，普通数组要么清一色都是unsigned char，要么清一色都是unsigned int，要么清一色都是unsigned long，不能像结构体这么“混合型”的。结构体的这种优越性，在大型程序的升级和维护时体现得非常明显。

【70.2 “造模”和“生成”和“调用”。】

结构体的使用，有三道标准工序“造模”和“生成”和“调用”。塑胶外壳，必须先开模具（造模），然后再用模具印出外壳（生成），再把外壳应用于日常生活中（调用）。结构体也一样，先“造”结构体的“模”（造模），再根据这个“模”来“生成”一个结构体变量（生成），然后在某函数里使用此变量（调用）。例子如下：

struct StructMould //“造模”
{
unsigned char u8Data_A;
unsigned int u16Data_B;
unsigned long u32Data_C;
};
struct StructMould GtMould; //“生成”一个变量GtMould。
void main()
{
GtMould.u8Data_A=1; //依靠成员的“名字”来“调用”
GtMould.u16Data_B=2; //依靠成员的“名字”来“调用”
GtMould.u32Data_C=3; //依靠成员的“名字”来“调用”
while(1)
{
}
}

复制代码

把上述程序转换成“普通数组”和“指针”的形式，给大家一个直观的对比，代码如下：

unsigned char Gu8MouldBuffer[7]; //相当于结构体变量GtMould
unsigned char *pu8Data_A;
unsigned int *pu16Data_B;
unsigned long *pu32Data_C;
void main()
{
pu8Data_A=(unsigned char *)&Gu8MouldBuffer[0]; //依靠数组的下标[0]来“调用”
*pu8Data_A=1;
pu16Data_B=(unsigned int *)&Gu8MouldBuffer[1]; //依靠数组的下标[1]来“调用”
*pu16Data_B=2;
pu32Data_C=(unsigned long *)&Gu8MouldBuffer[3]; //依靠数组的下标[3]来“调用”
*pu32Data_C=3;
while(1)
{
}
}

复制代码

分析：上述两种代码，目标都是把1,2,3这三个数字存放在一个数组里。第一种用结构体的方式，第二种用普通数组的方式。

【70.3 例程练习和分析。】

现在编写一个练习的程序：

/*---C语言学习区域的开始。-----------------------------------------------*/
struct StructMould //“造模”
{
unsigned char u8Data_A;
unsigned int u16Data_B;
unsigned long u32Data_C;
};
struct StructMould GtMould; //“生成”一个变量GtMould。
void main() //主函数
{
GtMould.u8Data_A=1; //依靠成员的“名字”来“调用”
GtMould.u16Data_B=2; //依靠成员的“名字”来“调用”
GtMould.u32Data_C=3; //依靠成员的“名字”来“调用”
View(GtMould.u8Data_A); //把结构体成员GtMould.u8Data_A发送到电脑端观察
View(GtMould.u16Data_B); //把结构体成员GtMould.u16Data_B发送到电脑端观察
View(GtMould.u32Data_C); //把结构体成员GtMould.u32Data_C发送到电脑端观察
while(1)
{
}
}
/*---C语言学习区域的结束。-----------------------------------------------*/

复制代码

在电脑串口助手软件上观察到的程序执行现象如下：

开始...
第1个数
十进制:1
十六进制:1
二进制:1
第2个数
十进制:2
十六进制:2
二进制:10
第3个数
十进制:3
十六进制:3
二进制:11

复制代码

分析：
      GtMould.u8Data_A为1。
      GtMould.u16Data_B为2。
      GtMould.u32Data_C为3。

【70.4 如何在单片机上练习本章节C语言程序？】

      直接复制前面章节中第十一节的模板程序，练习代码时只需要更改“C语言学习区域”的代码就可以了，其它部分的代码不要动。编译后，把程序下载进带串口的51学习板，通过电脑端的串口助手软件就可以观察到不同的变量数值，详细方法请看第十一节内容。

lee_st · 2017-5-21 15:47:06

这也是吴老师的啊，

lee_st · 2017-5-21 15:47:19

好像是还没结束啊，

lee_st · 2017-5-21 15:47:35

程序框架还没有涉及啊

lee_st · 2017-5-21 15:47:54

有请吴老师继续出山

lee_st · 2017-5-21 15:48:05

补充一下下了哦，，

db1001001 · 2017-5-22 21:43:06

每周来看看

芦苇将 · 2017-5-25 08:55:26

好样的，支持

吴坚鸿 · 2017-5-29 11:24:56

第七十一节：结构体的内存和赋值。
【71.1 结构体的内存生效。】

上一节讲到结构体有三道标准工序“造模”和“生成”和“调用”，那么，结构体在哪道工序的时候才会开始占用内存(或者说内存生效)？答案是在第二道工序“生成”（或者说定义）的时候才产生内存开销。第一道工序仅“造模”不“生成”是不会产生内存的。什么意思呢？请看下面的例子。

第一种情况：仅“造模”不“生成”。

struct StructMould //“造模”
{
unsigned char u8Data_A;
unsigned char u8Data_B;
};

复制代码

分析：这种情况是没有内存开销的，尽管你已经写下了数行代码，但是C编译器在翻译此代码的时候，它会识别到你偷工减料仅仅“造模”而不“生成”新变量，此时C编译器会把你这段代码忽略而过。

第二种情况：先“造模”再“生成”。

struct StructMould //“造模”
{
unsigned char u8Data_A;
unsigned char u8Data_B;
};
struct StructMould GtMould_1; //“生成”一个变量GtMould_1。占用2个字节内存
struct StructMould GtMould_2; //“生成”一个变量GtMould_2。占用2个字节内存

复制代码

   分析：这种情况才会占用内存。你“生成”变量越多，占用的内存就越大。像本例子，“生成”了两个变量GtMould_1和GtMould_2，一个变量占用2个字节，两个就一共占用了4个字节。结论：内存的占用是跟变量的“生成”有关。

【71.2 结构体的内存对齐。】

   什么是对齐？为了确保内存的地址能整除某个“对齐倍数”（比如4）。比如以4为“对齐倍数”，在地址0存放一个变量a,因为地址0能整除“对齐倍数”4，所以符合“地址对齐”，接着往下再存放第二个变量b，紧接着的地址1不能整除“对齐倍数”4，此时，为了内存对齐，本来打算把变量b放到地址1的，现在就要更改挪到地址4才符合“地址对齐”，这就是内存对齐的含义。“对齐倍数”是什么？“对齐倍数”就是单片机的位数除以8。比如8位单片机的“对齐倍数”是1（8除以8）,16位单片机是2（16除以8），32位单片机是4（32除以8）。本教材所用的单片机是8位的51内核单片机，因此“对齐倍数”是1。1是可以被任何整数整除的，因此，8位单片机在结构体的使用上被内存对齐的“干扰”是最小的。

   为什么要对齐？单片机内部硬件层面一条指令处理的数据宽度是固定的，比如，因为一个字节是8位，所以，8位的单片机一次处理的数据宽度是1个字节（8除以8等于1），16位的单片机一次处理的数据宽度是2个字节（16位除以8位等于2），32位的单片机一次处理的数据宽度是4个字节（32位除以8位等于4），如果字节不对齐，本来单片机一个指令能处理的数据可能就要分解成2个指令甚至更多的指令，所以C编译器为了让单片机处于最佳状态，在某些情况就会涉及内存对齐，结构体就涉及到内存对齐。
结构体的内存对齐表现在哪里呢？请看下面两个例子：

   第一个例子：8位单片机。

struct StructMould_1 //“造模”
{
unsigned char u8Data; //一个unsigned char占用1个字节。
unsigned long u32Data; //一个unsigned long占用4个字节。
};
struct StructMould_1 GtMould_1; //占用多少个字节内存呢？

复制代码

分析：GtMould_1这个变量占用多少个内存字节呢？假设GtMould_1的首地址是0，那么地址0就存放成员u8Data，u8Data占用1个字节，所以接下来的地址是1（0+1），问题来了，地址1能直接存放占用4个字节的成员u32Data吗？因为8位单片机的“对齐倍数”是1（8除以8），那么地址1显然是可以整除“对齐倍数”1的，因此，地址1是可以果断存储u32Data成员的。因此，GtMould_1占用的总字节数是5（1+4），也就是u8Data和u32Data两者所占字节数之和。

第二个例子：32位单片机。

struct StructMould_1 //“造模”
{
unsigned char u8Data; //一个unsigned char占用1个字节。
unsigned long u32Data; //一个unsigned long占用4个字节。
};
struct StructMould_1 GtMould_1; //占用多少个字节内存呢？

复制代码

分析：GtMould_1这个变量占用多少个内存字节呢？假设GtMould_1的首地址是0，那么地址0就存放成员u8Data，u8Data占用1个字节，所以接下来的地址是1（0+1），那么问题来了，地址1能直接存放占用4个字节的成员u32Data吗？不能。因为32位单片机的“对齐倍数”是4（32除以8），那么地址1显然是不可以整除“对齐倍数”4的，因此，就要把地址1更改挪到地址4这里才符合“地址对齐”，这样，就意味着多插入了3个“填充的字节”，因此，GtMould_1占用的总字节数是8（1+3+4），也就是“1个字节u8Data，3个填充字节，4个u32Data”三者所占字节数之和。那么问题又来了，如果把结构体内部成员u8Data和u32Data的位置顺序更改一下，内存容量会有所改变吗？位置顺序更改后如下。

struct StructMould_1 //“造模”
{
unsigned long u32Data; //一个unsigned long占用4个字节。
unsigned char u8Data; //一个unsigned char占用1个字节。
};
struct StructMould_1 GtMould_1; //占用多少个字节内存呢？

复制代码

分析：更改u8Data和u32Data的位置顺序后，u32Data在前u8Data在后，GtMould_1这个变量占用多少个内存字节呢？假设GtMould_1的首地址是0，那么地址0就存放成员u32Data，u32Data占用4个字节，所以接下来的地址是4（0+4），那么问题来了，地址4能直接存放占用1个字节的成员u8Data吗？能。因为32位单片机的“对齐倍数”是4（32除以8），那么地址4显然是可以整除“对齐倍数”4的，因此，地址4是可以果断存储u8Data的。那么，是不是GtMould_1就占用5个字节呢？不是。因为结构体的内存对齐，还包括另外一条规定，那就是“一个结构体变量所占的内存总容量必须能整除该单片机的“对齐倍数”（单片机的位数除以8），如果不能，C编译器就会擅自在最后一个成员的后面插入若干个“填充字节”来满足这个规则”，根据这条规定，计算所得的总容量5是不能整除“对齐倍数”4的，必须再额外填充3个字节补足到8，才能整除“对齐倍数”4，因此，更改顺序后，GtMould_1还是占用8个字节（4+1+3），前4个字节是u32Data，中间1个字节是u8Data，后3个字节是“填充字节”。

因为本教程采用的是8位的51内核单片机，因此，在上述这个例子中，GtMould_1所占的字节数是符合“第一个例子”的情况，也就是占用5个字节。内存对齐是遵守几条严格的规则的，我只列出其中最关键的两条给大家大致阅读一下，有一个印象即可，不强求死记硬背，只需知道“结构体因为存在内存对齐，所以实际内存容量是有可能大于内部各成员类型字节数相加之和，尤其是16位或者32位这类单片机”就可以了。

第（1）条：结构体内部某个成员相对结构体首地址的偏移地址必须能整除该单片机的“对齐倍数”（单片机的位数除以8），如果不能，C编译器就会擅自在各成员之间插入若干个“填充字节”来满足这个规则。
第（2）条：一个结构体变量所占的内存总容量必须能整除该单片机的“对齐倍数”（单片机的位数除以8），如果不能，C编译器就会擅自在最后一个成员的后面插入若干个“填充字节”来满足这个规则。

复制代码

【71.3 如何获取某个结构体变量的内存容量？】

结构体存在内存对齐的问题，就说明它的内存占用情况不会像普通数组那样一目了然，那么，我们编写程序的时候怎么知道某个结构体变量占用了多少个字节数？答案是：用sizeof宏函数。比如：

struct StructMould_1
{
unsigned long u32Data;
unsigned char u8Data;
};
struct StructMould_1 GtMould_1;
unsigned long a; //此变量用来获取结构体变量GtMould_1所占用的字节总数
void main() //主函数
{
a=sizeof(GtMould_1); //利用宏函数sizeof获取结构体变量所占用的字节总数
}

复制代码

【71.4 结构体之间的赋值。】

结构体之间的赋值有两种，第一种是成员之间“一对一”的赋值，第二种是整个结构体之间“面对面”的整体赋值。第一种成员赋值像普通变量赋值那样，没有那么多套路和忌讳，数据传递安全可靠。第二种整个结构体之间赋值在编程体验上带有“一键操作”的快感，但是要注意避开一些“雷区”，首先，整体赋值的前提是必须保证两个结构体变量都是同一个“结构体模板”造出来的变量，不同“模板”的结构体变量之间禁止“整体赋值”，其次，哪怕是“同一个模板”的结构体变量，也并不是所有的“同模板结构体”变量都能实现整个结构体之间的直接赋值，只有在结构体内部成员比较简单的情况下才适合“整体赋值”，如果结构体内部包含有“指针”或者“字符串”或者“其它结构体中的结构体”，这类情况就比较复杂，这时建议大家绕开有“雷区”的“整体赋值”而直接选用安全可靠的“成员赋值”。什么是“成员赋值”什么是“整体赋值”？请看下面两个例子。

第一种：成员赋值。把结构体变量GtMould_2_A赋值给GtMould_2_B。

struct StructMould_2 //“造模”
{
unsigned long u32Data;
unsigned char u8Data;
};
struct StructMould_2 GtMould_2_A; //生成第1个结构体变量
struct StructMould_2 GtMould_2_B //生成第2个结构体变量
void main() //主函数
{
//先给GtMould_2_A赋初值。
GtMould_2_A.u32Data=1;
GtMould_2_A.u8Data=2;
//通过“成员赋值”，把结构体变量GtMould_2_A赋值给GtMould_2_B。
GtMould_2_B.u32Data=GtMould_2_A.u32Data; //成员之间“一对一”的赋值
GtMould_2_B.u8Data=GtMould_2_A.u8Data; //成员之间“一对一”的赋值
}

复制代码

第二种：整体赋值。把结构体变量GtMould_2_A赋值给GtMould_2_B。

struct StructMould_2 //“造模”
{
unsigned long u32Data;
unsigned char u8Data;
};
struct StructMould_2 GtMould_2_A; //生成第1个结构体变量
struct StructMould_2 GtMould_2_B //生成第2个结构体变量
void main() //主函数
{
//先给GtMould_2_A赋初值。
GtMould_2_A.u32Data=1;
GtMould_2_A.u8Data=2;
//通过“整体赋值”，把结构体变量GtMould_2_A赋值给GtMould_2_B。
GtMould_2_B=GtMould_2_A; //整体之间“一次性”的赋值
}

复制代码

上述例子中的整体赋值，是因为结构体内部的数据比较“简单”，没有包含“指针”或者“字符串”或者“其它结构体中的结构体”这类数据成员，如果包含这类成员，建议大家不要用整体赋值。比如遇到以下这类结构体就建议大家直接用安全可靠的“成员赋值”：

struct StructMould //“造模”
{
unsigned char u8String[]=”String”; //字符串
unsigned char *pu8Data; //指针
struct StructOtherMould GtOtherMould; //结构体中的结构体
};

复制代码

【71.5 例程练习和分析。】

现在编写一个练习的程序：

/*---C语言学习区域的开始。-----------------------------------------------*/
struct StructMould_1 //“造模”
{
unsigned long u32Data; //一个unsigned long占用4个字节。
unsigned char u8Data; //一个unsigned char占用1个字节。
};
struct StructMould_2 //“造模”
{
unsigned char u8Data;
unsigned long u32Data;
};
struct StructMould_1 GtMould_1; //占用多少个字节内存呢？
struct StructMould_2 GtMould_2_A;
struct StructMould_2 GtMould_2_B;
unsigned long a; //此变量用来获取结构体变量GtMould_1所占用的字节总数
void main() //主函数
{
a=sizeof(GtMould_1); //利用宏函数sizeof获取结构体变量GtMould_1所占用的字节总数
//先给GtMould_2_A赋初值。
GtMould_2_A.u32Data=1;
GtMould_2_A.u8Data=2;
//通过“整体赋值”，把结构体变量GtMould_2_A赋值给GtMould_2_B。
GtMould_2_B=GtMould_2_A; //整体之间“一次性”的赋值
View(a); //把a发送到电脑端观察
View(GtMould_2_B.u32Data); //把结构体成员GtMould_2_B.u32Data发送到电脑端观察
View(GtMould_2_B.u8Data); //把结构体成员GtMould_2_B.u8Data发送到电脑端观察
while(1)
{
}
}
/*---C语言学习区域的结束。-----------------------------------------------*/

复制代码

在电脑串口助手软件上观察到的程序执行现象如下：

开始...
第1个数
十进制:5
十六进制:5
二进制:101
第2个数
十进制:1
十六进制:1
二进制:1
第3个数
十进制:2
十六进制:2
二进制:10

复制代码

分析：
      GtMould_1所占的字节数a为5。
      GtMould_2_B的结构体成员GtMould_2_B.u32Data为1。
      GtMould_2_B的结构体成员GtMould_2_B.u8Data为2。

【71.6 如何在单片机上练习本章节C语言程序？】

      直接复制前面章节中第十一节的模板程序，练习代码时只需要更改“C语言学习区域”的代码就可以了，其它部分的代码不要动。编译后，把程序下载进带串口的51学习板，通过电脑端的串口助手软件就可以观察到不同的变量数值，详细方法请看第十一节内容。

吴坚鸿 · 2017-6-4 12:10:31

第七十二节：结构体的指针。

【72.1 结构体指针的重要用途。】

   结构体指针有两个重要用途，一个是结构体数据的拆分和打包，另一个是作为结构体数据在涉及函数时的参数入口。
   什么是“结构体数据的拆分和打包”？结构体本质是一个数组，数组内可能包含了许多不同数据长度类型的成员，当我们直接操作某个具体的成员时，只改变某个成员的数值，不影响其它成员，这个就是“拆分”的角度。那么，什么是“打包”？当涉及整个结构体数据的存储或者传输（通信）给另外一个单片机时，这时候有两种选择，一种是一个成员一个成员的挨个处理，这种“拆分”的处理方式比较繁琐麻烦，另外一种就是把整个结构体当作一个以字节为单位的整体数组来处理，这种处理方式就是高速便捷的“打包”处理，但是关键的问题来了，我们把整个结构体数据以字节的方式“打包”传递给另外一个单片机，但是这个单片机接收到我们一组数据后，如何把这“一包”以字节为单位的数组转换成相同的结构体变量，以便在它的程序处理中也能以“拆分”的角度直接处理某个具体的成员变量，这时就涉及到结构体指针的作用。
   什么是“作为结构体数据在涉及函数时的参数入口”？结构体数据一般内部包含了很多成员，当要把这一包数据传递给某个函数内部时，这个函数要给结构体数据预留参数入口，这时，如果函数以结构体成员的角度来预留入口，那么有多少个成员就要预留多少个函数的参数入口，可阅读性非常差，操作起来也麻烦。但是，如果以指针的角度来预留入口，那么不管这个结构体内部包含多少个成员，只需要预留一个指针参数入口就够用了，这就是绝大多32单片机在写库函数时都采样结构体指针作为函数的参数入口的原因。
结构体指针这两个重要用途后续章节会深入讲解，本节的重点是先让大家学会结构体指针的基础知识，为后续章节做准备。

【72.2 结构体指针的基础。】

   操作结构体内部某个具体变量时，有两种方式，一种是成员调用的方式，另一种是指针调用的方式。C语言语法为了区分这两种方式，专门设计了两种不同的操作符号。成员调用方式采样小数点“.”的符号，指针调用方式采用箭头“->”的符号。例子如下：

struct StructMould_1
{
unsigned char u8Data_A;
unsigned long u32Data_B;
};
struct StructMould_1 GtMould_1; //“生成”一个变量。 //占用5个字节。
struct StructMould_1 *ptMould_1; //定义一个结构体指针。 //占用3个字节。
void main() //主函数
{
GtMould_1.u8Data_A=5; //“成员调用”的方式，用小数点符号“.”
ptMould_1=&GtMould_1; //ptMould_1指针与变量GtMould_1建立关联。
ptMould_1->u8Data_A=ptMould_1->u8Data_A+5; //“指针调用”的方式，用箭头符号“->”
while(1)
{
}
}

复制代码

   分析：上述例子中，信息量很大，知识点有两个。
   第一个知识点：为什么结构体变量GtMould_1占用5个字节，而结构体指针*ptMould_1只占用3个字节？结构体变量GtMould_1所占的内存是由结构体成员内部的数量决定的，而结构体指针*ptMould_1是由C编译器根据芯片硬件寻址范围而决定的，在一个相同的C编译器系统中，所有类型的指针所占用的字节数都是一样的，比如在本教程中所用8位单片机的C51编译器系统中，unsigned char *,unsigned int *,unsigned long *,以及本节的struct StructMould_1 *，都是占用3个字节（题外话，我前面第60节中所说的“凡是32位以下的单片机的指针都是占用4个字节”是有误的，抱歉）。32位单片机的指针往往都是4个字节，而某些64位的PC机，指针可能是8个字节，这些内容大家只要有个大概的了解即可。
   第二个知识点：结构体成员GtMould_1.u8Data_A经过第一步的“成员调用”直接赋值5，紧接着经过“指针调用”的累加5操作，最后GtMould_1.u8Data_A的数值是10（5+5）。

【72.3 例程练习和分析。】

   现在编写一个练习的程序：

/*---C语言学习区域的开始。-----------------------------------------------*/
struct StructMould_1
{
unsigned char u8Data_A;
unsigned long u32Data_B;
};
struct StructMould_1 GtMould_1; //“生成”一个变量。 //占用5个字节。
struct StructMould_1 *ptMould_1; //定义一个结构体指针。 //占用3个字节。
void main() //主函数
{
GtMould_1.u8Data_A=5; //“成员调用”的方式，用小数点符号“.”
ptMould_1=&GtMould_1; //ptMould_1指针与变量GtMould_1建立关联。
ptMould_1->u8Data_A=ptMould_1->u8Data_A+5; //“指针调用”的方式，用箭头符号“->”
View(sizeof(GtMould_1)); //在电脑端观察变量GtMould_1占用多少个字节。
View(sizeof(ptMould_1)); //在电脑端观察指针ptMould_1占用多少个字节。
View(GtMould_1.u8Data_A); //在电脑端观察结构体成员GtMould_1.u8Data_A的最后数值。
while(1)
{
}
}
/*---C语言学习区域的结束。-----------------------------------------------*/

复制代码

在电脑串口助手软件上观察到的程序执行现象如下：

开始...
第1个数
十进制:5
十六进制:5
二进制:101
第2个数
十进制:3
十六进制:3
二进制:11
第3个数
十进制:10
十六进制:A
二进制:1010

复制代码

   分析：
   变量GtMould_1占用5个字节。
   指针ptMould_1占用3个字节。
   结构体成员GtMould_1.u8Data_A的最后数值是10。

【72.4 如何在单片机上练习本章节C语言程序？】

   直接复制前面章节中第十一节的模板程序，练习代码时只需要更改“C语言学习区域”的代码就可以了，其它部分的代码不要动。编译后，把程序下载进带串口的51学习板，通过电脑端的串口助手软件就可以观察到不同的变量数值，详细方法请看第十一节内容。

文艺的淡定哥 · 2017-6-4 16:01:20

现在看这些自己早已都掌握；但14年时候在学校里初学单片机，在老哥的帖子里还是学习了很多东西

，支持老哥

kkfy888 · 2017-6-4 17:20:01

看了这么多章节对学习有了很大的进步，谢谢鸿哥

吴坚鸿 · 2017-6-11 09:32:46

第七十三节：结构体数据的传输存储和还原。

【73.1 结构体数据的传输存储和还原。】

结构体本质是一个数组，数组内可能包含了许多不同数据长度类型的成员，当整个结构体数据需要存储或者传输（通信）给另外一个单片机时，这时候有两种选择，一种是一个成员一个成员的挨个处理，这种“以成员为单位”的处理方式比较繁琐麻烦，另外一种是把整个结构体变量当作一个“以字节为单位”的普通数组来处理，但是有两个关键的问题来了，第一个问题是如何把结构体“拆分”成“以字节为单位”来进行搬动数据，第二个问题是假如我们把整个结构体数据以“字节为单位”的方式“整体打包”传递给另外一个单片机，当这个接收方的单片机接收到我们这一组数据后，如何把这“一包”以字节为单位的数组再“还原”成相同的结构体变量，以便在程序处理中也能直接按“结构体的方式”来处理某个具体的成员。其实，这两个问题都涉及到“指针的强制转换”。具体讲解的例子，请直接阅读下面73.2段落的源代码例子和注释。

【73.2 例程练习和分析。】

现在编写一个练习程序，把一个结构体变量“以字节的方式”存储到另外一个普通数组里，然后再把这个“以字节为单位”的普通数组“还原”成“结构体的方式”，以便直接操作内部某个具体的成员。

/*---C语言学习区域的开始。-----------------------------------------------*/
struct StructMould_1
{
unsigned char u8Data_A;
unsigned long u32Data_B;
unsigned int u16Data_C;
};
struct StructMould_1 GtMould_1; //“生成”一个变量。
unsigned char Gu8Buffer[sizeof(GtMould_1)]; //定义一个内存跟结构体变量大小一样的普通数组
unsigned char *pu8; //定义一个把结构体变量“拆分”成“以字节为单位”的指针
struct StructMould_1 *ptStruct; //定义一个结构体指针，用于“还原”普通数组为“结构体”
unsigned int i; //定义一个用于for循环的变量
void main() //主函数
{
//先把该结构体变量内部具体成员分别以“成员的方式”初始化为5，6，7
GtMould_1.u8Data_A=5;
GtMould_1.u32Data_B=6;
GtMould_1.u16Data_C=7;
pu8=(unsigned char *)&GtMould_1; //把结构体变量强制转换成“以字节为单位”的指针
for(i=0;i
{
Gu8Buffer[i]=pu8[i]; //把结构体变量以字节的方式搬运并且存储到普通数组里。
}
ptStruct=(struct StructMould_1 *)&Gu8Buffer[0]; //再把普通数组强制“还原”成结构体指针
ptStruct->u8Data_A=ptStruct->u8Data_A+1; //该变量从5自加1后变成6。
ptStruct->u32Data_B=ptStruct->u32Data_B+1; //该变量从6自加1后变成7。
ptStruct->u16Data_C=ptStruct->u16Data_C+1; //该变量从7自加1后变成8。
View(ptStruct->u8Data_A); //在电脑端观察结构体成员u8Data_A的数值。
View(ptStruct->u32Data_B); //在电脑端观察结构体成员u32Data_B的数值。
View(ptStruct->u16Data_C); //在电脑端观察结构体成员u16Data_C的数值。
while(1)
{
}
}
/*---C语言学习区域的结束。-----------------------------------------------*/

复制代码

   在电脑串口助手软件上观察到的程序执行现象如下：

开始...

第1个数
十进制:6
十六进制:6
二进制:110

第2个数
十进制:7
十六进制:7
二进制:111

第3个数
十进制:8
十六进制:8
二进制:1000

分析：
   结构体成员u8Data_A的数值是6。
   结构体成员u32Data_B的数值是7。
   结构体成员u16Data_C的数值是8。

【73.3 如何在单片机上练习本章节C语言程序？】

      直接复制前面章节中第十一节的模板程序，练习代码时只需要更改“C语言学习区域”的代码就可以了，其它部分的代码不要动。编译后，把程序下载进带串口的51学习板，通过电脑端的串口助手软件就可以观察到不同的变量数值，详细方法请看第十一节内容。

搜索历史

从单片机基础到程序框架（连载）

相关推荐

678 条评论

评论

精选推荐

热门帖

站长推荐 /6