第二十节：减法运算的5种常见格式。
请先看以下的减法语法格式：
“保存变量”=“减数1”-“减数2”-...-“减数N”;
含义是：右边的“减数”与“减数”相减，并且把最终的运算结果赋值给左边的“保存变量”。注意，这里的符号“=”不是等于号的意思，而是赋值的意思。左边的“保存变量”必须是变量，不能是常量，否则编译时会报错。右边的“减数”既可以是变量，也可以是常量，也可以是“保存变量”本身自己。多说一句，何谓变量和常量？变量是可以在程序中被更改的，是被分配的一个RAM空间。常量往往是数字，或者是被分配在ROM空间的一个具体数值。下面根据右边“被减数”与“减数”的不同组合，列出了减法运算的5种常见格式。
第1种：“减数1”是常量，“减数2”是常量。比如：
unsigned char a;
a=15-3;
数字“15”和“3”都是常量。执行上述语句后，保存变量a变成了12。
第2种：“减数1”是变量，“减数2”是常量。比如：
unsigned char b;
unsigned char x=15;
b=x-10;
x是变量，“10”是常量。由于原来x变量里面的数值是15，执行上述语句后，保存变量b变成了5。而变量x则保持不变，x还是15。
第3种：“减数1”是变量，“减数2”是变量。比如：
unsigned char c;
unsigned char x=15;
unsigned char y=6;
c=x-y;
x是变量，y也是变量。由于原来x变量里面的数值是15，y变量里面的数值是6，执行上述语句后，保存变量c变成了9。而变量x和y则保持不变，x还是15，y还是6。
第4种：“减数1”是保存变量本身，“减数2”是常量。比如：
unsigned char d=18;
d=d-2;
d=d-7;
d是保存变量，“2”和“7”都是常量。这类语句有一个特点，具备了自减功能，可以更改自己本身自己的数值。比如原来保存变量d的数值是18，执行“d=d-2;”语句后，d变成了16，接着再执行完“d=d-7;”语句后，d最后变成了9。
第5种：“减数1”是保存变量本身，“减数2”是变量。比如：
unsigned char e=28;
unsigned char x=15;
unsigned char y=6;
e=e-x;
e=e-y;
e是保存变量，x与y都是变量。这类语句有一个特点，具备了自减功能，可以更改自己本身自己的数值。比如原来保存变量e的数值是28，执行“e=e-x;”语句后，e变成了13，接着再执行完“e=e-y;”语句后，e最后变成了7。
现在编写一个程序来练习上述5种格式的减法语句，最后把程序编译后下载到坚鸿51学习板观察结果。请直接复制第十节模板程序，修改的main程序代码如下：
void main() //主程序
{
/*---C语言学习区域的开始---------------------------------------------------------------------------*/
unsigned char a; //定义一个变量a，并且分配了1个字节的RAM空间。
unsigned char b; //定义一个变量b，并且分配了1个字节的RAM空间。
unsigned char c; //定义一个变量c，并且分配了1个字节的RAM空间。
unsigned char d=18; //定义一个变量d，并且分配了1个字节的RAM空间。初始化默认为18.
unsigned char e=28; //定义一个变量e，并且分配了1个字节的RAM空间。初始化默认为28.
unsigned char x=15; //定义一个变量x，并且分配了1个字节的RAM空间。初始化默认为15.
unsigned char y=6; //定义一个变量y，并且分配了1个字节的RAM空间。初始化默认为6.
//第1种：“减数1”是常量，“减数2”是常量。
a=15-3;
//第2种：“减数1”是变量，“减数2”是常量。
b=x-10;
//第3种：“减数1”是变量，“减数2”是变量。
c=x-y;
//第4种：“减数1”是保存变量本身，“减数2”是常量。
d=d-2;
d=d-7;
//第5种：“减数1”是保存变量本身，“减数2”是变量。
e=e-x;
e=e-y;
GuiWdData0=a; //把变量a这个数值放到窗口变量0里面显示
GuiWdData1=b; //把变量b这个数值放到窗口变量1里面显示
GuiWdData2=c; //把变量c这个数值放到窗口变量2里面显示
GuiWdData3=d; //把变量d这个数值放到窗口变量3里面显示
GuiWdData4=e; //把变量e这个数值放到窗口变量4里面显示
/*---C语言学习区域的结束---------------------------------------------------------------------------*/
while(1)
{
initial();
key_service();
display_service();
}
}
如何在坚鸿51学习板上观察a,b,c,d,e这5个变量？按下S1或者S5按键即可切换显示不同的窗口，从而显示不同的变量。上坚鸿51学习板观察程序执行的结果如下：
变量a为12。
变量b为5。
变量c为9。
变量d为9。
变量e为7。
下节预告：减法的连写和自减运算的简写。
（未完待续）
楼主很用心，对初学者很有帮助！
想问一下：uchar a；uchar b=5；uchar c=9；
a=b-c；a=？ 不知道负数如何处理，希望吴老师讲解讲解
新帖子又有新思路 跟来继续学 等着新书出版
sos9616 发表于 2015-6-1 07:12
想问一下：uchar a；uchar b=5；uchar c=9；
a=b-c；a=？ 不知道负数如何处理，希望吴老师讲解讲解 ...
我后面会有专门的章节讲到这方面的内容，大概还要过两三节左右就讲到。
第二十一节：减法的连写和自减运算的简写。
连减。上一节我列举的减法例子中，右边的减数只有一个。实际上，C语言规则没有限制减数的个数，它的通用格式如下：
“保存变量”=“被减数”-“减数1”-“减数2”-...-“减数N”;
被减数与减数的属性。当右边的减数个数总共超过1个的时候，就是我所说的“连减”。被减数和减数的属性没有限定，可以是常量，也可以是变量。比如：
a=68-3-15; //被减数和减数全部是常量。
b=q-x-y-k; //被减数和减数全部是变量。
c=63-x-5-k; //被减数和减数，有的是常量，有的是变量。
连减的运行顺序。赋值符号“=”右边的被减数挨个与减数相减，每一次的运算结果都放在一个临时的隐蔽变量里，这个隐蔽的变量我们看不到，是单片机系统内部参与运算时的专用寄存器，当与所有减数相减的计算结果出来后，再把隐蔽变量所保存的计算结果赋值给左边的“保存变量”。
自减。当被减数是“保存变量”本身时，这种情况就是我所说的“自减”。比如：
“保存变量”=“保存变量”-“减数1”；
“保存变量”=“保存变量”-“减数1”-“减数2”-...-“减数N”;
自减的简写。当被减数是“保存变量”本身，并且只有一个减数时，那么上述自减计算式可以简写成如下格式：
“保存变量”-=“减数1”；
“保存变量”-=“减数1”-“减数2”-...-“减数N”;
这种格式就是我所说的自减简写。现在举几个例子如下：
d-=6; //相当于d=d-6;
e-=x; //相当于e=e-x;
f-=18-y-k; //相当于f=f-(18-y-k);
自减的特殊简写。在自减运算中，只有一个减数，并且这个减数是常数1时，格式如下：
“保存变量”=“保存变量”-1；
这时候，可以把上述格式简写成如下两种格式：
“保存变量”--;
--“保存变量”;
这两种格式也是俗称的“自减1”操作。比如：
g--; //相当于g=g-1或者g-=1;
--h; //相当于h=h-1或者h-=1;
自减1符号“--”可以在变量的左边，也可以在变量的右边，它们在这里本质是一样的，没有差别。当然，如果是在循环条件语句中，这时自减1符号“--”在左边还是在右边是有一点点微弱的差别，这方面的内容以后再讲。
上机练习。现在编写一个程序来练习刚才讲到的内容，最后把程序编译后下载到坚鸿51学习板观察结果。请直接复制第十节模板程序，修改的main程序代码如下：
void main() //主程序
{
/*---C语言学习区域的开始---------------------------------------------------------------------------*/
unsigned char a; //定义一个变量a，并且分配了1个字节的RAM空间。
unsigned char b; //定义一个变量b，并且分配了1个字节的RAM空间。
unsigned char c; //定义一个变量c，并且分配了1个字节的RAM空间。
unsigned char d=65; //定义一个变量d，并且分配了1个字节的RAM空间。初始化默认为65.
unsigned char e=38; //定义一个变量e，并且分配了1个字节的RAM空间。初始化默认为38.
unsigned char f=29; //定义一个变量f，并且分配了1个字节的RAM空间。初始化默认为29.
unsigned char g=5; //定义一个变量g，并且分配了1个字节的RAM空间。初始化默认为5.
unsigned char h=5; //定义一个变量h，并且分配了1个字节的RAM空间。初始化默认为5.
unsigned char q=50; //定义一个变量q，并且分配了1个字节的RAM空间。初始化默认为50.
unsigned char x=3; //定义一个变量x，并且分配了1个字节的RAM空间。初始化默认为3.
unsigned char y=6; //定义一个变量y，并且分配了1个字节的RAM空间。初始化默认为6.
unsigned char k=2; //定义一个变量k，并且分配了1个字节的RAM空间。初始化默认为2.
//第1个知识点：连减。
a=68-3-15;//被减数和减数全部是常量。a的结果为：50。
b=q-x-y-k;//被减数和减数全部是变量。b的结果为：39。
c=63-x-5-k;//被减数和减数，有的是常量，有的是变量。c的结果为：53。
//第2个知识点：自减的常规格式。
d-=6;//相当于d=d-6;d的结果为：59。
e-=x;//相当于e=e-x;e的结果为：35。
f-=18-y-k;//相当于f=f-(18-y-k);f的结果为：19。
//第3个知识点：自减的特殊格式。
g--;//相当于g=g-1或者g-=1;g的结果为：4。
--h;//相当于h=h-1或者h-=1;d的结果为：4。
GuiWdData0=a; //把变量a这个数值放到窗口变量0里面显示
GuiWdData1=b; //把变量b这个数值放到窗口变量1里面显示
GuiWdData2=c; //把变量c这个数值放到窗口变量2里面显示
GuiWdData3=d; //把变量d这个数值放到窗口变量3里面显示
GuiWdData4=e; //把变量e这个数值放到窗口变量4里面显示
GuiWdData5=f; //把变量f这个数值放到窗口变量5里面显示
GuiWdData6=g; //把变量g这个数值放到窗口变量6里面显示
GuiWdData7=h; //把变量h这个数值放到窗口变量7里面显示
/*---C语言学习区域的结束---------------------------------------------------------------------------*/
while(1)
{
initial();
key_service();
display_service();
}
}
查看运算结果的方法。如何在坚鸿51学习板上观察a,b,c,d,e,f,g,h这8个变量？按下S1或者S5按键即可切换显示不同的窗口，从而显示不同的变量。上坚鸿51学习板观察程序执行的结果如下：
变量a为50。
变量b为39。
变量c为53。
变量d为59。
变量e为35。
变量f为19。
变量g为4。
变量h为4。
下节预告：减法运算的溢出。
（未完待续）
条理清晰，精神可嘉，值得敬佩
顶楼主，加油！辛苦了！
鸿哥，，多谢分享。
第二十二节：减法运算的溢出。
在开始本章节之前，先纠正一下前面第17节内容的一个小bug。我原文中写道：
“保存变量”+=“加数1”+“加数2”+...+“加数N”;
相当于:
“保存变量”=“保存变量”+“加数1”+“加数2”+...+“加数N”;
当时我没有考虑到优先级，漏了一个括号，修改后，相当于：
保存变量”=“保存变量”+（“加数1”+“加数2”+...+“加数）;这样才算比较准确。同理，我后面所举的例子：
f+=18+y+k; //相当于f=f+18+y+k;
在注释中也漏了一个括号，应该是：
f+=18+y+k; //相当于f=f+(18+y+k);
上述多一个括号或者少一个括号虽然看似不影响运算结果，但是运算顺序是有点不一样的。
现在正式开始讲本节减法溢出的问题。英文“unsigned”的中文意思就是”无符号的”，延伸含义是“无负号无负数”的意思，所以unsigned char ,unsigned int ,unsigned long这三种类型数据都是无负号无负数的，取值只能是0和正数，那么问题来了，当被减数小于减数的时候，运算结果会是什么样子，有什么规律？
（1）第一个例子:
unsigned char a;
a=0-1;
分析：
左边的“保存变量”a的数据长度是1个字节8位，a=0-1可以看成是十六进制的a=0x00-0x01。由于0x00比0x01小，所以假想一下需要向高位借位，借位后成了a=0x100-0x01。所以a的最终结果是0xff(十进制是255)。根据”假想借位”这个规律，如果是b也是unsigned char 类型，那么b=2-5自然就相当于b=0x102-0x05，运算结果b等于0xfd(十进制是253)。
（2）第二个例子:
unsigned int c;
c=0-1;
分析：
左边的“保存变量”c的数据长度是2个字节16位，c=0-1可以看成是十六进制的c=0x0000-0x0001。由于0x0000比0x0001小，所以假想一下需要向高位借位，借位后成了c=0x10000-0x0001。所以c的最终结果是0xffff(十进制是65535)。根据”假想借位”这个规律，如果是d也是unsignedint 类型，那么d=2-5自然就相当于b=0x10002-0x0005，运算结果b等于0xfffd(十进制是65533)。
为了验证上述抛出的”假想借位”，现在编写一个程序来练习刚才讲到的内容，最后把程序编译后下载到坚鸿51学习板观察结果。请直接复制第十节模板程序，修改的main程序代码如下：
void main() //主程序
{
/*---C语言学习区域的开始---------------------------------------------------------------------------*/
unsigned char a; //定义一个变量a，并且分配了1个字节的RAM空间。
unsigned char b; //定义一个变量b，并且分配了1个字节的RAM空间。
unsigned int c; //定义一个变量c，并且分配了2个字节的RAM空间。
unsigned int d; //定义一个变量d，并且分配了2个字节的RAM空间。
//第一个例子,针对a与b都是unsigned char类型数据。
a=0-1;
b=2-5;
//第二个例子,针对c与d都是unsigned int类型的数据。
c=0-1;
d=2-5;
GuiWdData0=a; //把变量a这个数值放到窗口变量0里面显示
GuiWdData1=b; //把变量b这个数值放到窗口变量1里面显示
GuiWdData2=c; //把变量c这个数值放到窗口变量2里面显示
GuiWdData3=d; //把变量d这个数值放到窗口变量3里面显示
/*---C语言学习区域的结束---------------------------------------------------------------------------*/
while(1)
{
initial();
key_service();
display_service();
}
}
查看运算结果的方法。如何在坚鸿51学习板上观察a,b,c,d这4个变量？按下S1或者S5按键即可切换显示不同的窗口，从而显示不同的变量。按下S9按键不松手就可以切换到十六进制的显示界面，松开手后会自动切换到十进制的界面。上坚鸿51学习板观察程序执行的结果如下：
变量a为0xff(十进制是255)。
变量b为0xfd(十进制是253)。
变量c为0xffff(十进制是65535)。
变量d为0xfffd(十进制是65533)。
下节预告：建议减法运算前先把所有变量转换成同一数据类型再参与运算。
（未完待续）
坐等后续！
第二十三节：建议把所有参与减法运算的变量都转换成unsigned long数据类型。
不管是以前讲的加法，现在讲的减法，还是未来讲的乘法和除法，我都会强烈建议“请把所有参与运算的变量都转成unsigned long类型”。unsigned long变量是三种数据类型中取值范围最大的数，取值范围可达0到4294967295之间，用了此类型变量的运算，不会轻易导致运算溢出的问题。有细心读者会问，万一数据超过了4294967295怎么办？答：可用BCD码的数组方式进行运算。这种数组运算的方法我在《从业将近十年，手把手教你单片机程序框架》里用了好几个章节跟大家介绍过，初学者暂时不用深入学习它。
变量转换的方法是引入中间变量，有多少个需要转换的变量就引入多少个中间变量，请看下面这个例子。
转换之前：
unsigned inta;
unsigned char x=195;
unsigned long y=101;
a=x-y;
分析：上述公式用到3个变量，其中a和x都不是unsigned long变量，因此需要为它们分别引入中间变量t和s。
转换之后：
unsigned inta;
unsigned char x=195;
unsigned long y=101;
unsigned long t; //引入的中间变量，用来替代a
unsigned long s; //引入的中间变量，用来替代x。
s=0;//s在接收x原数据之前先把高位和低位全部清零。因为s和x的数据宽度不一。
s=x;//接收x原数据，相当于把x转换成unsigned long中间变量。
t=s-y;//此处的t就默认代表了变量a。
本章虽短，但是此方法在实际项目中很重要，大家不可大意。
下节预告：乘法运算的5种常见格式。
（未完待续）
第二十四节：乘法运算的5种常见格式。
请先看以下的乘法语法格式：
“保存变量”=“被乘数1”*“乘数2”*... *“乘数N”;
含义是：右边的“被乘数”与各“乘数”相乘，并且把最终的运算结果赋值给左边的“保存变量”。注意，这里的符号“=”不是等于号的意思，而是赋值的意思。左边的“保存变量”必须是变量，不能是常量，否则编译时会报错。右边的“被乘数”和“乘数”既可以是变量，也可以是常量，也可以是“保存变量”本身自己。多说一句，何谓变量和常量？变量是可以在程序中被更改的，是被分配的一个RAM空间。常量往往是数字，或者是被分配在ROM空间的一个具体数值。下面根据右边“被乘数”与“乘数”的不同组合，列出了乘法运算的5种常见格式。
第1种：“被乘数1”是常量，“乘数2”是常量。比如：
unsigned char a;
a=15*3;
数字“15”和“3”都是常量。执行上述语句后，保存变量a变成了45。
第2种：“被乘数1”是变量，“乘数2”是常量。比如：
unsigned char b;
unsigned char x=15;
b=x*10;
x是变量，“10”是常量。由于原来x变量里面的数值是15，执行上述语句后，保存变量b变成了150。而变量x则保持不变，x还是15。
第3种：“被乘数1”是变量，“乘数2”是变量。比如：
unsigned char c;
unsigned char x=15;
unsigned char y=6;
c=x*y;
x是变量，y也是变量。由于原来x变量里面的数值是15，y变量里面的数值是6，执行上述语句后，保存变量c变成了90。而变量x和y则保持不变，x还是15，y还是6。
第4种：“被乘数1”是保存变量本身，“乘数2”是常量。比如：
unsigned char d=18;
d=d*2;
d=d*7;
d是保存变量，“2”和“7”都是常量。这类语句有一个特点，具备了自乘功能，可以更改自己本身自己的数值。比如原来保存变量d的数值是18，执行“d=d*2;”语句后，d变成了36，接着再执行完“d=d*7;”语句后，d最后变成了252。
第5种：“被乘数1”是保存变量本身，“乘数2”是变量。比如：
unsigned char e=2;
unsigned char x=15;
unsigned char y=6;
e=e*x;
e=e*y;
e是保存变量，x与y都是变量。这类语句有一个特点，具备了自乘功能，可以更改自己本身自己的数值。比如原来保存变量e的数值是2，执行“e=e*x;”语句后，e变成了30，接着再执行完“e=e*y;”语句后，e最后变成了180。
现在编写一个程序来练习上述5种格式的乘法语句，最后把程序编译后下载到坚鸿51学习板观察结果。请直接复制第十节模板程序，修改的main程序代码如下：
void main() //主程序
{
/*---C语言学习区域的开始---------------------------------------------------------------------------*/
unsigned char a; //定义一个变量a，并且分配了1个字节的RAM空间。
unsigned char b; //定义一个变量b，并且分配了1个字节的RAM空间。
unsigned char c; //定义一个变量c，并且分配了1个字节的RAM空间。
unsigned char d=18; //定义一个变量d，并且分配了1个字节的RAM空间。初始化默认为18.
unsigned char e=2; //定义一个变量e，并且分配了1个字节的RAM空间。初始化默认为2.
unsigned char x=15; //定义一个变量x，并且分配了1个字节的RAM空间。初始化默认为15.
unsigned char y=6; //定义一个变量y，并且分配了1个字节的RAM空间。初始化默认为6.
//第1种：“被乘数1”是常量，“乘数2”是常量。
a=15*3;
//第2种：“被乘数1”是变量，“乘数2”是常量。
b=x*10;
//第3种：“被乘数1”是变量，“乘数2”是变量。
c=x*y;
//第4种：“被乘数1”是保存变量本身，“乘数2”是常量。
d=d*2;
d=d*7;
//第5种：“被乘数1”是保存变量本身，“乘数2”是变量。
e=e*x;
e=e*y;
GuiWdData0=a; //把变量a这个数值放到窗口变量0里面显示
GuiWdData1=b; //把变量b这个数值放到窗口变量1里面显示
GuiWdData2=c; //把变量c这个数值放到窗口变量2里面显示
GuiWdData3=d; //把变量d这个数值放到窗口变量3里面显示
GuiWdData4=e; //把变量e这个数值放到窗口变量4里面显示
/*---C语言学习区域的结束---------------------------------------------------------------------------*/
while(1)
{
initial();
key_service();
display_service();
}
}
如何在坚鸿51学习板上观察a,b,c,d,e这5个变量？按下S1或者S5按键即可切换显示不同的窗口，从而显示不同的变量。上坚鸿51学习板观察程序执行的结果如下：
变量a为45。
变量b为150。
变量c为90。
变量d为252。
变量e为180。
下节预告：乘法连写的简写。
（未完待续）
顶楼主。算你狠。{:tongue:}
楼主能不能推荐一个适用于STC89C52 单片机的规格书，因为STC89C52的规格书太简单，比如，定时器与中断的介绍及寄存器的配置太简单。
第二十五节：连乘以及自乘运算的简写。
上一节我列举的乘法例子中，右边的参与运算的数据都是两个。实际上，C语言规则没有限制数据个数，它的通用格式如下：
“保存变量”=“被乘数1”*“乘数2”...*“乘数N”;
当右边的乘数个数超过两个的时候，就是我所说的“连乘”，每个乘数的属性没有限定，可以是常量，也可以是变量。比如：
a=2*5*3;//被乘数和乘数全部是常量。a的结果为30。
b=k*x*y;//被乘数和乘数全部是变量。b的结果为36。
c=x*5*y;//被乘数和乘数，有的是常量，有的是变量。c的结果为90。
连乘的运行顺序是，赋值符号“=”右边的乘数挨个相乘，把每一次的运算结果放在一个临时的隐蔽变量里，这个隐蔽的变量我们看不到，是单片机系统内部参与运算时的专用寄存器，等右边所有的乘数连乘的计算结果出来后，再把这个隐蔽变量所保存的计算结果赋值给左边的“保存变量”。
讲完了连乘的格式，接着讲自乘的简写。何谓自乘？当右边的被乘数是“保存变量”本身时，这种情况就是我所说的“自乘”。比如：
“保存变量”=“保存变量”*“乘数1”；
“保存变量”=“保存变量”*“乘数1”*“乘数2”...*“乘数N”;
上述自加计算式可以简写成如下格式：
“保存变量”*=“乘数1”；
“保存变量”*=“乘数1”*“乘数2”...*“乘数N”;
这种格式就是我所说的自乘简写。现在举几个例子如下：
d*=6; //相当于d=d*6;最后d的结果为30。
e*=x; //相当于e=e*x;最后e的结果为15。
f*=2*y*k; //相当于f=f*(2*y*k);最后f的结果为120。
我之前在讲加法的自加和减法的自减运算时，还给大家介绍了它们另外一种特殊的简写方式。比如减法运算，当右边只有2减数，当一个减数是“保存变量”，另一个是常数1时，格式如下：
“保存变量”=“保存变量”-1；
这时候，可以把上述格式简写成如下两种格式：
“保存变量”--;
--“保存变量”;
这两种格式也是俗称的“自减1”操作。比如：
g--; //相当于g=g-1或者g-=1;
--h; //相当于h=h-1或者h-=1;
那么，本节所讲的自乘运算，有没有这种特殊写法“g**”或者“**h”？答案很明显，没有。因为任何一个数“自乘1”还是等于它本身，所以研究这种特殊写法就没有任何意义。
现在编写一个程序来练习刚才讲到的内容，最后把程序编译后下载到坚鸿51学习板观察结果。请直接复制第十节模板程序，修改的main程序代码如下：
void main() //主程序
{
/*---C语言学习区域的开始---------------------------------------------------------------------------*/
unsigned char a; //定义一个变量a，并且分配了1个字节的RAM空间。
unsigned char b; //定义一个变量b，并且分配了1个字节的RAM空间。
unsigned char c; //定义一个变量c，并且分配了1个字节的RAM空间。
unsigned char d=5; //定义一个变量d，并且分配了1个字节的RAM空间。初始化默认为5.
unsigned char e=5; //定义一个变量e，并且分配了1个字节的RAM空间。初始化默认为5.
unsigned char f=5; //定义一个变量f，并且分配了1个字节的RAM空间。初始化默认为5.
unsigned char x=3; //定义一个变量x，并且分配了1个字节的RAM空间。初始化默认为3.
unsigned char y=6; //定义一个变量y，并且分配了1个字节的RAM空间。初始化默认为6.
unsigned char k=2; //定义一个变量k，并且分配了1个字节的RAM空间。初始化默认为2.
//第1个知识点：连乘。
a=2*5*3;//被乘数和乘数全部是常量。a的结果为30。
b=k*x*y;//被乘数和乘数全部是变量。b的结果为36。
c=x*5*y;//被乘数和乘数，有的是常量，有的是变量。c的结果为90。
//第2个知识点：自乘的简写。
d*=6; //相当于d=d*6;最后d的结果为30。
e*=x; //相当于e=e*x;最后e的结果为15。
f*=2*y*k; //相当于f=f*(2*y*k);最后f的结果为120。
GuiWdData0=a; //把变量a这个数值放到窗口变量0里面显示
GuiWdData1=b; //把变量b这个数值放到窗口变量1里面显示
GuiWdData2=c; //把变量c这个数值放到窗口变量2里面显示
GuiWdData3=d; //把变量d这个数值放到窗口变量3里面显示
GuiWdData4=e; //把变量e这个数值放到窗口变量4里面显示
GuiWdData5=f; //把变量f这个数值放到窗口变量5里面显示
/*---C语言学习区域的结束---------------------------------------------------------------------------*/
while(1)
{
initial();
key_service();
display_service();
}
}
如何在坚鸿51学习板上观察a,b,c,d,e,f这6个变量？按下S1或者S5按键即可切换显示不同的窗口，从而显示不同的变量。上坚鸿51学习板观察程序执行的结果如下：
变量a为30。
变量b为36。
变量c为90。
变量d为30。
变量e为15。
变量f为120。
下节预告：乘法运算的溢出。
（未完待续）
谢谢分享,学习了!顶一个,
第二十六节：乘法运算的溢出。
乘法的溢出规律跟加法的溢出规律是一样的。举一个例子如下：
unsigned char k=30;
unsigned char n=10;
unsigned char a;
a=k*n;
分析：
k和n相乘，相当于30乘以10，运算结果是300（十六进制是0x012c）保存在一个隐藏中间变量，根据前面加法运算的规律，我猜测这个隐藏中间变量可能是unsigned int类型，然后再把这个中间变量赋值给单字节变量a，a只能接收十六进制的低8位字节0x2c，所以运算后a的数值由于溢出变成了十六进制的0x2c（十进制是44）。
由于乘法的溢出规律跟加法的溢出规律是一样的，所以不再多举例子。在实际项目中，为了避免一不小心就溢出的问题，我强烈建议，不管加减乘除，凡是参与运算的变量全部都要转化成unsigned long变量，转化的方法也跟加减运算的转换方法一致，不再详细解决这方面的内容。
现在编写一个程序来练习刚才讲到的内容，最后把程序编译后下载到坚鸿51学习板观察结果。请直接复制第十节模板程序，修改的main程序代码如下：
void main() //主程序
{
/*---C语言学习区域的开始-----------------------------------------------------------------
----------*/
unsigned char k=30;
unsigned char n=10;
unsigned char a;
a=k*n;
GuiWdData0=a; //把变量a这个数值放到窗口变量0里面显示
/*---C语言学习区域的结束-----------------------------------------------------------------
----------*/
while(1)
{
initial();
key_service();
display_service();
}
}
查看运算结果的方法。如何在坚鸿51学习板上观察变量？按下S1或者S5按键即可切换显示不同的窗口，从而显示不同的变量。按下S9按键不松手就可以切换到十六进制的显示界面，松开手后会自动切换到十进制的界面。上坚鸿51学习板观察程序执行的结果如下：
变量a为0x2c(十进制是44)。
下节预告：除法运算的常见格式。
（未完待续）
楼主：这个http://www.amobbs.com/forum.php?mod=viewthread&tid=5572213&extra=page%3D1&page=1内容不更新了吗？有几个例程编译通不过。我有回贴子的
楼主，出书吧，值得学习！！！
crazylata 发表于 2015-7-12 13:38
楼主：这个http://www.amobbs.com/forum.php?mod=viewthread&tid=5572213&extra=page%3D1&page=1内容不更新 ...
问：
error C249: 'DATA': SEGMENT TOO LARGE
坚鸿解答：
右键单击Target选择“Options for Target'Target1'”就会出来一个框，在memory model中选择compact:variables in pdata 就可以了。
吴坚鸿 发表于 2015-7-12 21:54
问：
error C249: 'DATA': SEGMENT TOO LARGE
非常感谢，这两种有什么区别呢？
还有，从业将近十年，手把手教你单片机程序框架 这个帖子干嘛不更新了啊？
应该顶起，谢谢分享！
写的很细致，确实不错，值得学习！
从第一次听说单片机到现在不好意思说自己会单片机已经有六年了，也许还只停留在会玩之上，大概看了一些，讲的确实很基础详细，善于分享的人都是可敬的，加油！对于感兴趣的朋友多动手比什么都强。
吴坚鸿 发表于 2015-4-2 13:38
第十节：一个用来学习C语言的模板程序。
目前，几乎所有的初学者在学习和上机练习C语言的时候，都是在电脑 ...
能不能提供一个将串口作为调试工具的模版{:lol:}
第二十七节：整除求商的运算。
C语言中，乘法符号不是“×”而是“*”，除法求商的符号不是“÷”而是“/”。乘除法符号跟我们日常用的数学符号有点不一样，我个人猜测C语言这样规定的原因是因为“×”容易跟大写字母“X”搞混，而“÷”这个符号在电脑键盘上不方便直接输入，故分别用“*”和“/”替代。
何谓“整除”？请看以下两个对比例子：
10除以4，商等于2.5。------（带小数点）
10除以4，商等于2，余数是2。------（这就叫做整除）
什么时候带小数点，什么时候是整除？取决于参与运算的变量类型。标准的C语言中，其实远远不止我前面所说的unsigned char ,unsigned int ,unsigned long这三种类型，还有一种叫浮点数的float类型，当参与运算的变量涉及float类型时，就可能存在小数点。这是题外话，大家大概知道有这么一回事即可，暂时不用深入研究float等其它类型的数据，因为在单片机项目中，只要用我所述的三种常用类型就绝对够用了，单片机不用涉及float类型，如果项目涉及小数点的显示和处理，我们完全可以用那三种类型去处理它，这些处理方法我后续会讲到，暂时不用管。而unsigned char ,unsigned int ,unsigned long这三种类型的除法都是整除，我后续所讲的所有章节内容也都是整除。
整除的通用格式：
“保存变量”=“被除数” /“除数1” /“除数2”... /“除数N”;
跟之前讲的加减运算一样，左边的“保存变量”必须是变量，右边的可以是变量和常量的任意组合。如果右边只有两个参与运算的数据，就是整除的常见格式。
整除的常见格式：
“保存变量”=“被除数” /“除数” ;
现在从整除常见格式的6个方面来分析它的规律。
（1）当“除数”等于0时。我们都知道，数学运算除数是不允许等于0的，如果在单片机中非要让除数为0，商会出现什么结果？我试过，发现有一个规律：如果“除数”是变量的0，那么商等于十进制的255（十六进制是0xff）。如果“除数”是常量的0，那么商等于十进制的1。比如：
a=23 /y;//假设除数变量y里面是0，那么a的结果是255(十六进制的0xff)。
b=23 /0;//除数是常量0，那么b的结果是1。
（2）当被除数小于“除数”时。商等于0。比如：
c=7 / 10;//c的结果是0。
（3）当被除数等于“除数”时。商等于1。比如：
d=10/ 10;//d的结果是1。
（4）当被除数大于“除数”时。商大于0。
比如：
e=10/ 4;//e的结果是2。
f=10/ 3;//f的结果是3。
（5）自除运算的简写。跟前面加减法一样，当“被除数”是“保存变量”时，存在自除运算的简写。
“保存变量”=“保存变量” /“除数” ;
上述自除运算的简写如下：
“保存变量” / =“除数” ;
比如：
g/=5;//相当于g=g/5;
加减法有自加1“++g”和自减1“g--”的特殊写法，但是除法不存在这种自除1的特殊写法，因为一个数除以1还是等于它本身，所以自除1没有任何意义，因此C语言语法中没有这种写法。
（6）除法的溢出规律跟加法的溢出规律是一样的，所以不再多举例子。在实际项目中，为了避免一不小心就溢出的问题，我强烈建议，不管加减乘除，凡是参与运算的变量全部都要转化成unsigned long变量，转化的方法也跟加减运算的转换方法一致，不再详细讲解这方面的内容。
现在编写一个程序来练习刚才讲到的内容，最后把程序编译后下载到坚鸿51学习板观察结果。请直接复制第十节模板程序，修改的main程序代码如下：
void main() //主程序
{
/*---C语言学习区域的开始---------------------------------------------------------------------------*/
unsigned char a;
unsigned char b;
unsigned char c;
unsigned char d;
unsigned char e;
unsigned char f;
unsigned char g=10;//初始化为10
unsigned char y=0; //除数变量初始化为0。
a=23/y;
b=23/0;
c=7/10;
d=10/10;
e=10/4;
f=10/3;
g/=5;//相当于g=g/5;
GuiWdData0=a; //把a这个变量放到窗口变量0里面显示
GuiWdData1=b; //把b这个变量放到窗口变量1里面显示
GuiWdData2=c; //把c这个变量放到窗口变量2里面显示
GuiWdData3=d; //把d这个变量放到窗口变量3里面显示
GuiWdData4=e; //把e这个变量放到窗口变量4里面显示
GuiWdData5=f; //把f这个变量放到窗口变量5里面显示
GuiWdData6=g; //把g这个变量放到窗口变量5里面显示
/*---C语言学习区域的结束---------------------------------------------------------------------------*/
while(1)
{
initial();
key_service();
display_service();
}
}
查看运算结果的方法。如何在坚鸿51学习板上观察变量？按下S1或者S5按键即可切换显示不同的窗口，从而显示不同的变量。按下S9按键不松手就可以切换到十六进制的显示界面，松开手后会自动切换到十进制的界面。上坚鸿51学习板观察程序执行的结果如下：
变量a为255(十六进制是0xff)。
变量b为1。
变量c为0。
变量d为1。
变量e为2。
变量f为3。
变量g为2。
下节预告：整除求余的运算。
（未完待续）
楼主是我偶像啊
第二十八节：整除求余的运算。
求余跟上一节讲的求商都是属于整除运算，区别是：求余返回余数，求商返回商。整除求余的余数有一个很明显的规律：余数永远小于除数（除数不为0的情况下）。比如，除数是10，那么不管被除数有多大，余数必然是从0到9的数，不可能是10以上的数。上一节提到除法求商的运算符号是“/”，而除法求余的运算符号是“%”，外形跟百分号一致，只是在C语言中用来做除法求余的运算符而已。
整除求余的通用格式：
“保存变量”=“被除数”% “除数1” % “除数2”...%“除数N”;
跟之前讲的加减运算一样，左边的“保存变量”必须是变量，右边的可以是变量和常量的任意组合。如果右边只有两个参与运算的数据，就是整除求余的常见格式。
整除求余的常见格式：
“保存变量”=“被除数” % “除数” ;
现在从整除求余常见格式的6个方面来分析它的规律。
（1）当“除数”等于0时。我们都知道，数学运算除数是不允许等于0的，如果在单片机中非要让除数为0，余数会出现什么结果？我在keil的C51编译环境试过，发现有一个规律：如果“除数”是变量的0，那么余数等于被除数。如果“除数”是常量的0，那么余数等于1。还有一种特殊的情况是编译不通过的，就是“被除数”是变量，而“除数”是常量的0。其实大家都知道“除数”不能为0，为什么我非要做“除数”为0时的实验呢？意义何在？我虽然知道除数为0时会出错，但是我不知道这个错到底严不严重，会不会程序崩溃，当我做了这个实验后，我心中的石头才放下了，万一除数为0，只是运算出错，至少程序不会崩溃，这样我心里就有了一个底，当哪天我某个程序崩溃时，我至少可以排除了这种情况，方便我找bug。这就是本实验的意义所在。
比如：
a=23%y;//假设除数变量y里面是0，那么a的结果是23。
b=23%0;//除数是常量0，那么b的结果是1。
b=g%0;//这种特殊情况编译不通过：“被除数”是变量，而“除数”是常量的0。
（2）当被除数小于“除数”时。余数等于被除数本身。比如：
c=7%10;//c的结果是7。
（3）当被除数等于“除数”时。余数等于0。比如：
d=10%10;//d的结果是0。
（4）当被除数大于“除数”时。余数也必然小于“除数”。
比如：
e=10%4;//e的结果是2。
f=10% 3;//f的结果是1。
（5）自除求余运算的简写。跟前面加减法一样，当“被除数”是“保存变量”时，存在自除求余运算的简写。
“保存变量”=“保存变量” % “除数” ;
上述自除运算的简写如下：
“保存变量” % =“除数” ;
比如：
g%=5;//相当于g=g%5;
加减法有自加1“++g”和自减1“g--”的特殊写法，但是除法不存在这种自除1的特殊写法，因为一个数除以1还是等于它本身，所以自除1没有任何意义，因此C语言语法中没有这种写法。
（6）除法的溢出规律跟加法的溢出规律是一样的，所以不再多举例子。在实际项目中，为了避免一不小心就溢出的问题，我强烈建议，不管加减乘除，凡是参与运算的变量全部都要转化成unsigned long变量，转化的方法也跟加减运算的转换方法一致，不再详细讲解这方面的内容。
现在编写一个程序来练习刚才讲到的内容，最后把程序编译后下载到坚鸿51学习板观察结果。请直接复制第十节模板程序，修改的main程序代码如下：
void main() //主程序
{
/*---C语言学习区域的开始---------------------------------------------------------------------------*/
unsigned char a;
unsigned char b;
unsigned char c;
unsigned char d;
unsigned char e;
unsigned char f;
unsigned char g=10;//初始化为10
unsigned char y=0; //除数变量初始化为0。
a=23%y;
b=23%0;
//b=g%0;//这种特殊情况编译不通过：“被除数”是变量，而“除数”是常量的0。
c=7%10;
d=10%10;
e=10%4;
f=10%3;
g%=5;//相当于g=g%5;
GuiWdData0=a; //把a这个变量放到窗口变量0里面显示
GuiWdData1=b; //把b这个变量放到窗口变量1里面显示
GuiWdData2=c; //把c这个变量放到窗口变量2里面显示
GuiWdData3=d; //把d这个变量放到窗口变量3里面显示
GuiWdData4=e; //把e这个变量放到窗口变量4里面显示
GuiWdData5=f; //把f这个变量放到窗口变量5里面显示
GuiWdData6=g; //把g这个变量放到窗口变量5里面显示
/*---C语言学习区域的结束---------------------------------------------------------------------------*/
while(1)
{
initial();
key_service();
display_service();
}
}
查看运算结果的方法。如何在坚鸿51学习板上观察变量？按下S1或者S5按键即可切换显示不同的窗口，从而显示不同的变量。按下S9按键不松手就可以切换到十六进制的显示界面，松开手后会自动切换到十进制的界面。上坚鸿51学习板观察程序执行的结果如下：
变量a为23。
变量b为1。
变量c为7。
变量d为0。
变量e为2。
变量f为1。
变量g为0。
下节预告：利用“整除求商求余”来提取一个数的个十百千位。
（未完待续）
又见鸿哥新作，继续顶。
感谢一直以来的持续分享！
第二十九节：利用“整除求商求余”来拆分提取一个数的个十百千位。
上两节讲了整除的求商求余运算符，这两个运算不仅能用在数学运算中，还可以用来拆分提取一个数的个十百千位。提取这些位有什么用呢？因为在以后的单片机显示程序中，不管是液晶屏还是数码管，必须用到这种提取算法，先把一个数的个十百千位一个个拆分提取出来，然后再送到显示屏上显示，所以这种算法很常见和实用。上述提到的“个，十，百，千”位只是一个虚数，具体是多少应该根据实际项目而定，也有可能是“个，十，百，千，万，十万，百万...”等位，但是处理的思路和方法都是一致的。
拆分提取的思路。比如8562这个数，千位是8，百位是5，十位是6，个位是2。可以依次看成是：
8=8562/1000;
5=562/100;
6=62/10;
2=2/1;
上述用到了整除求商，但是562,62,2又是如何通过8562分解得到的呢？需要用到整除求余：
562=8562%1000;
62=8562%100;
2=8562%10;
最后综合在一起,连在一起写：
8=8562/1000;
5=8562%1000/100;
6=8562%100/10;
2=8562%10/1;
因为我们预先知道了这个数最大位是千位，所以千位直接整除1000求商就可以了。实际项目中，我们只是用某个变量，而这个变量的大小我们并不知道具体是什么，它的最大位可能并不止千位，也有可能是万位，所以需要把上述最高位的千位也做一下整除10000求余数，然后在整除1000求商，最后整理如下：
8=8562%10000/1000;
5=8562%1000/100;
6=8562%100/10;
2=8562%10/1;
大家仔细观察和品味一下，很容易发现规律和原因，如果求万，十万，百万，也是用一样的方法。多提醒一句，根据我的经验，有一些单片机的C编译器可能不支持long类型数据的求余求商连写在一起，那么就要用一个中间变量分两步走，先求余，再求商，分开来操作。比如：
8=8562%10000/1000;
分成两步走：
a=8562%10000;
a=a/1000;
上述的变量a就是引入的中间变量。
现在编写一个程序来练习刚才讲到的内容，最后把程序编译后下载到坚鸿51学习板观察结果。请直接复制第十节模板程序，修改的main程序代码如下：
void main() //主程序
{
/*---C语言学习区域的开始---------------------------------------------------------------------------*/
unsigned char a;
unsigned char b;
unsigned char c;
unsigned char d;
unsigned intx=8562;//初始化为8562，注意必须是int类型以上，不能是char类型，char最大范围是255。
a=x%10000/1000;//拆分提取千位
b=x%1000/100; //拆分提取百位
c=x%100/10; //拆分提取十位
d=x%10/1; //拆分提取个位
GuiWdData0=a; //把a这个变量放到窗口变量0里面显示
GuiWdData1=b; //把b这个变量放到窗口变量1里面显示
GuiWdData2=c; //把c这个变量放到窗口变量2里面显示
GuiWdData3=d; //把d这个变量放到窗口变量3里面显示
/*---C语言学习区域的结束---------------------------------------------------------------------------*/
while(1)
{
initial();
key_service();
display_service();
}
}
查看运算结果的方法。如何在坚鸿51学习板上观察变量？按下S1或者S5按键即可切换显示不同的窗口，从而显示不同的变量。按下S9按键不松手就可以切换到十六进制的显示界面，松开手后会自动切换到十进制的界面。上坚鸿51学习板观察程序执行的结果如下：
变量a为8。
变量b为5。
变量c为6。
变量d为2。
下节预告：逻辑运算符的“与”运算。
（未完待续）
本帖最后由 吴坚鸿 于 2015-8-8 11:52 编辑
第三十节：逻辑运算符的“与”运算。
单片机任何数字的底层运算都是以二进制的形式进行，前面讲的加减乘除也不例外。只不过加减乘除是生活常用的运算，任意给两个十进制的数据让单片机运算，我们都可以凭借既有的生活经验通过口算或者笔算来计算出结果，不需要刻意模拟单片机底层的二进制运算。但是本节讲的“与”运算却不行，它是为二进制而生的，若想使用它，必先把参与运算的数据双双转换成二进制格式的数据，你才能分析“与”运算的含义和规律。“与”运算是以位来进行运算的，位就是代表二进制中的每一位，每一个位只能是0或者1。两个数的“与”运算就是两个数被展开成二进制后的“与”运算。
“与”运算的运算符号是“&”。运算规律是：两个位进行“与”运算，只有两个位都同时是1运算结果才能等于1,，否则，只要其中有一位是0，运算结果都是0.比如：
0&0等于0。
0&1等于0。
1&0等于0。
1&1等于1。
注意，上述的0和1都是指二进制的0和1。
现在举一个完整的例子来分析“与”运算的规律。有两个unsigned char类型的十进制数分别是12和9，求12&9的结果是多少？分析步骤如下：
第一步：先把参与运算的两个数以二进制的格式展开。十进制转二进制的方法请参考前面第13,14,15节的内容。
十进制12的二进制格式是：00001100。
十进制9的二进制格式是：00001001。
第二步：二进制数右对齐，按每一位进行“与”运算。
00001100
&00001001
结果是 00001000。
第三步：把二进制的00001000转换成十六进制是：0x08。转换成十进制是8。所以12&9的结果是8。
上述举的例子只能分析“与”运算的规律，并没有看出“与”运算的意义所在。“与”运算有啥用途呢？其实用途很多，最常见的用途是可以指定一个变量的某位清零，其它位保持不变。比如一个unsigned char类型的变量b，数据长度一共是8位，从右往左：
想让第0位清零，其它位保持不变，只需跟十六进制的0xfe相“与”:b=b&0xfe。
想让第1位清零，其它位保持不变，只需跟十六进制的0xfd相“与”:b=b&0xfd。
想让第2位清零，其它位保持不变，只需跟十六进制的0xfb相“与”:b=b&0xfb。
想让第3位清零，其它位保持不变，只需跟十六进制的0xf7相“与”:b=b&0xf7。
想让第4位清零，其它位保持不变，只需跟十六进制的0xef相“与”:b=b&0xef。
想让第5位清零，其它位保持不变，只需跟十六进制的0xdf相“与”:b=b&0xdf。
想让第6位清零，其它位保持不变，只需跟十六进制的0xbf相“与”:b=b&0xbf。
想让第7位清零，其它位保持不变，只需跟十六进制的0x7f相“与”:b=b&0x7f。
根据上述规律，假设b原来等于十进制的85（十六进制是0x55，二进制是01010101），要想把此数据的第0位清零，只需b=b&0xfe。最终b的运算结果是十进制是84（十六进制是0x54，二进制是01010100）。
现在编写一个程序来练习刚才讲到的内容，最后把程序编译后下载到坚鸿51学习板观察结果。请直接复制第十节模板程序，修改的main程序代码如下：
void main() //主程序
{
/*---C语言学习区域的开始---------------------------------------------------------------------------*/
unsigned char a;
unsigned char b=85;//十六进制是0x55，二进制是01010101。
a=12&9;
b=b&0xfe;
GuiWdData0=a; //把a这个变量放到窗口变量0里面显示
GuiWdData1=b; //把b这个变量放到窗口变量1里面显示
/*---C语言学习区域的结束---------------------------------------------------------------------------*/
while(1)
{
initial();
key_service();
display_service();
}
}
查看运算结果的方法。如何在坚鸿51学习板上观察变量？按下S1或者S5按键即可切换显示不同的窗口，从而显示不同的变量。按下S9按键不松手就可以切换到十六进制的显示界面，松开手后会自动切换到十进制的界面。16个LED灯显示的就是当前变量的二进制数，亮代表1，灭代表0。上坚鸿51学习板观察程序执行的结果如下：
变量a为8（十六进制是0x08，二进制是00001000）。
变量b为84（十六进制是0x54，二进制是01010100）。
下节预告：逻辑运算符的“或”运算。
（未完待续）
夜了，先mark
第三十一节：逻辑运算符的“或”运算。
“或”运算是以位为单位进行运算的。位是指二进制中的某一位，位只能是0或者1。两个数的“或”运算就是转换成二进制后每一位的“或”运算。
“或”运算的符号是“|”。运算规律是：两个位的“或”运算，如果两个位都是0，那么运算结果才是0，否则只要其中有一位是1，那么运算结果必定是1。比如：
0|0等于0。
0|1等于1。
1|0等于1。
1|1等于1。
现在举一个完整的例子来分析“|”运算的规律。有两个unsigned char类型的十进制数分别是12和9，求12|9的结果是多少？分析步骤如下：
第一步：先把参与运算的两个数都转换成二进制的格式。十进制转二进制的方法请参考前面第13,14,15节的内容。
十进制12的二进制格式是：00001100。
十进制9的二进制格式是：00001001。
第二步：二进制数右对齐，按每一位进行“或”运算。
00001100
|00001001
结果是 00001101。
第三步：把二进制的00001101转换成十六进制是：0x0D。转换成十进制是13。所以12&9的结果是13。
“或”运算最常见的用途是可以指定一个变量的某位置1，其它位保持不变。比如一个unsigned char类型的变量b，数据长度一共是8位，从右往左：
想让第0位置1，其它位保持不变，只需跟十六进制的0x01相“或”:b=b|0x01。
想让第1位置1，其它位保持不变，只需跟十六进制的0x02相“或”:b=b|0x02。
想让第2位置1，其它位保持不变，只需跟十六进制的0x04相“或”:b=b|0x04。
想让第3位置1，其它位保持不变，只需跟十六进制的0x08相“或”:b=b|0x08。
想让第4位置1，其它位保持不变，只需跟十六进制的0x10相“或”:b=b|0x10。
想让第5位置1，其它位保持不变，只需跟十六进制的0x20相“或”:b=b|0x20。
想让第6位置1，其它位保持不变，只需跟十六进制的0x40相“或”:b=b|0x40。
想让第7位置1，其它位保持不变，只需跟十六进制的0x80相“或”:b=b|0x80。
根据上述规律，假设b原来等于十进制的84（十六进制是0x54，二进制是01010100），要想把此数据的第0位置1，只需b=b|0x01。最终b的运算结果是十进制是85（十六进制是0x55，二进制是01010101）。
现在编写一个程序来练习刚才讲到的内容，最后把程序编译后下载到坚鸿51学习板观察结果。请直接复制第十节模板程序，修改的main程序代码如下：
void main() //主程序
{
/*---C语言学习区域的开始---------------------------------------------------------------------------*/
unsigned char a;
unsigned char b=84;//十六进制是0x54，二进制是01010100。
a=12|9;
b=b|0x01;
GuiWdData0=a; //把a这个变量放到窗口变量0里面显示
GuiWdData1=b; //把b这个变量放到窗口变量1里面显示
/*---C语言学习区域的结束---------------------------------------------------------------------------*/
while(1)
{
initial();
key_service();
display_service();
}
}
查看运算结果的方法。如何在坚鸿51学习板上观察变量？按下S1或者S5按键即可切换显示不同的窗口，从而显示不同的变量。按下S9按键不松手就可以切换到十六进制的显示界面，松开手后会自动切换到十进制的界面。16个LED灯显示的就是当前变量的二进制数，亮代表1，灭代表0。上坚鸿51学习板观察程序执行的结果如下：
变量a为13（十六进制是0x0D，二进制是00001101）。
变量b为85（十六进制是0x55，二进制是01010101）。
下节预告：逻辑运算符的“异或”运算。
（未完待续）
本帖最后由 吴坚鸿 于 2015-8-23 16:49 编辑
第三十二节：逻辑运算符的“异或”运算。
“异或”运算是以位为单位进行运算的。位是指二进制中的某一位，位只能是0或者1。两个数的“异或”运算就是转换成二进制后每一位的“异或”运算。
“异或”运算的符号是“^”。运算规律是：两个位的“异或”运算，如果两个位都相同，那么运算结果就是0；如果两个位不同（相异），则运算结果是1。比如：
0^0等于0。(两个位相同)
0^1等于1。(两个位相异)
1^0等于1。(两个位相异)
1^1等于0。(两个位相同)
现在举一个完整的例子来分析“^”运算的规律。有两个unsigned char类型的十进制数分别是12和9，求12^9的结果是多少？分析步骤如下：
第一步：先把参与运算的两个数都转换成二进制的格式。十进制转二进制的方法请参考前面第13,14,15节的内容。
十进制12的二进制格式是：00001100。
十进制9的二进制格式是：00001001。
第二步：二进制数右对齐，按每一位进行“异或”运算。
00001100
^00001001
结果是 00000101。
第三步：把二进制的 00000101转换成十六进制是：0x05。转换成十进制是5。所以12^9的结果是5。
“异或”在哪些项目上经常应用？以我个人的项目经验，平时很少用“异或”，我唯一用过一次“异或”，是在制定串口通讯协议时，通过“异或”算法，增加一个校验字节，此校验字节是一串数据依次相“异或”的总结果，目的是为了增加数据传送时的抗干扰能力。
现在编写一个程序来练习刚才讲到的内容，最后把程序编译后下载到坚鸿51学习板观察结果。请直接复制第十节模板程序，修改的main程序代码如下：
void main() //主程序
{
/*---C语言学习区域的开始---------------------------------------------------------------------------*/
unsigned char a;
a=12^9;
GuiWdData0=a; //把a这个变量放到窗口变量0里面显示
/*---C语言学习区域的结束---------------------------------------------------------------------------*/
while(1)
{
initial();
key_service();
display_service();
}
}
查看运算结果的方法。如何在坚鸿51学习板上观察变量？按下S1或者S5按键即可切换显示不同的窗口，从而显示不同的变量。按下S9按键不松手就可以切换到十六进制的显示界面，松开手后会自动切换到十进制的界面。16个LED灯显示的就是当前变量的二进制数，亮代表1，灭代表0。上坚鸿51学习板观察程序执行的结果如下：
变量a为5（十六进制是0x05，二进制是00000101）。
下节预告：逻辑运算符的“按位取反”运算。
（未完待续）
本帖最后由 吴坚鸿 于 2015-8-30 07:26 编辑
第三十三节：逻辑运算符的“按位取反”和“非”。
“按位取反”运算的符号是波浪符号“~”。运算规律是：针对某个数的“按位取反”，先将其展开成二进制的格式，然后每个位取反，所谓取反就是1的变成0，0的变成1。
现在举一个完整的例子来分析“按位取反”运算的规律。有一个unsigned char类型的十进制数分别是5和0，求~5和~0的结果是多少？分析步骤如下：
第一步：先把参与运算的数转换成二进制的格式。十进制转二进制的方法请参考前面第13,14,15节的内容。
十进制5的二进制格式是：00000101。
十进制0的二进制格式是：00000000。
第二步：
(1)将5的二进制数每一位取反，1的变成0，0的变成1。
~00000101
结果是 11111010。
把二进制的11111010转换成十六进制是：0xFA。转换成十进制是250。所以~5的结果是250。
(2)将0的二进制数每一位取反，1的变成0，0的变成1。
~00000000
结果是 11111111。
把二进制的11111111转换成十六进制是：0xFF。转换成十进制是255。所以~0的结果是255。
讲完“按位取反”,现在接着讲“非”。 “非”跟“按位取反”有点相似，但是区别也明显。“按位取反”针对的是一个数的某一位，侧重在局部。而“非”是针对一个数的整体，侧重在全局。“非”只有两种状态“假”和“真”。0代表假，大于0的数值代表真，也可以说“非”假即真，“非”真即假。不是假的就是真的，不是真的就是假的。强调的是两种状态的切换。在数值表示上，用0代表假的状态，用1代表真的状态。
“非”运算的符号是感叹号“！”。运算规律是：针对某个数的“非”，不管此数有多大，只要它大于0，那么被“非”后就一定是0。也不管此数是什么变量类型，只要它数值等于0，那么被“非”后就一定是1。
现在举一个完整的例子来分析“非”运算的规律。有一个unsigned char类型的十进制数分别是5和0，求!5和!0的结果是多少？分析步骤如下：
第一步：5大于0，是一个整体，被“非”后为0.
第二步：0就是0，是一个整体，被“非”后为1.
现在编写一个程序来练习刚才讲到的内容，最后把程序编译后下载到坚鸿51学习板观察结果。请直接复制第十节模板程序，修改的main程序代码如下：
void main() //主程序
{
/*---C语言学习区域的开始---------------------------------------------------------------------------*/
unsigned char a=5;
unsigned char b=5;
unsigned char c=0;
unsigned char d=0;
a=~a;
b=!b;
c=~c;
d=!d;
GuiWdData0=a; //把a这个变量放到窗口变量0里面显示
GuiWdData1=b; //把a这个变量放到窗口变量1里面显示
GuiWdData2=c; //把a这个变量放到窗口变量2里面显示
GuiWdData3=d; //把a这个变量放到窗口变量3里面显示
/*---C语言学习区域的结束---------------------------------------------------------------------------*/
while(1)
{
initial();
key_service();
display_service();
}
}
查看运算结果的方法。如何在坚鸿51学习板上观察变量？按下S1或者S5按键即可切换显示不同的窗口，从而显示不同的变量。按下S9按键不松手就可以切换到十六进制的显示界面，松开手后会自动切换到十进制的界面。16个LED灯显示的就是当前变量的二进制数，亮代表1，灭代表0。上坚鸿51学习板观察程序执行的结果如下：
变量a为250（十六进制是0xFA，二进制是11111010）。
变量b为0（十六进制是0x00，二进制是00000000）。
变量c为255（十六进制是0xFF，二进制是11111111）。
变量d为1（十六进制是0x01，二进制是00000001）。
下节预告：移位运算的左移。
（未完待续）
楼主能不能给个SPI的例程学习下，最近在研究这个，但规范的例程几乎找不到。
本帖最后由 吴坚鸿 于 2015-9-5 13:44 编辑
第三十四节：移位运算的左移。
前面讲的“与，或，异或”运算，漏讲了它们的简写格式的内容，在本节开始之前先把这部分内容补上。在“与，或，异或”这些运算中，当赋值语句左边的“保存变量”是参与运算的变量本身时，也存在简写的语法格式，比如：
a&=0x01;//相当于a=a&0x01;
a|=0x01;//相当于a=a|0x01;
a^=0x01;//相当于a=a^0x01;
现在正式开始本节内容“移位运算的左移”。左移的运算符号是“<<”，语法格式如下：
保存变量=被移数<<n;
其中n代表“被移数”需要左移的位数。
整句语法的含义是：“被移数”的二进制格式数据被整体往左边移动了n位，原来高n位数据被直接覆盖，新空出的低n位数据填入0。最后把移位结果存入“保存变量”。
现在举一个完整的例子来分析“按位取反”运算的规律。有2个unsigned char类型的变量a和b,a的初始值是十进制数5，a=a<<1的结果是多少？b的初始值也是十进制数5，b=b<<2的结果是多少？
分析步骤如下：
第一步：先把参与运算的数转换成二进制的格式。十进制转二进制的方法请参考前面第13,14,15节的内容。
十进制5的二进制格式是：00000101。
第二步：
(1)将5的二进制数整体往左边移动1位：
原来是：00000101
整体往左移动1位后变成：00001010
把二进制的00001010转换成十六进制是：0x0A。转换成十进制是10。所以a初始值是5,左移1位后的结果是10.
(2)将5的二进制数整体往左边移动2位：
原来是：00000101
整体往左移动2位后变成：00010100
把二进制的00010100转换成十六进制是：0x14。转换成十进制是20。所以b初始值是5,左移2位后的结果是20.
仔细观察上述两个例子，发现了一个重要的规律：某数左移1位相当于此数乘以2，左移多少位相当于乘以多少个2.比如上述例子中5左移1位相当于5乘以2，结果等于10。而5左移2位相当于5乘以2再乘以2，5*2*2的结果等于20。既然左移1位相当于某个数乘以2，那么为什么不直接用乘法来替代左移呢？原因是一条左移语句的运算速度比一条乘法语句的运算速度要快很多倍。
左移是在单片机项目中很常用的语法，也经常应用在一些数据类型之间的合并中。比如有两个unsigned char单字节的类型数据H和L，H的初始值是十六进制的0x12，L的初始值是十六进制的0x34，要将两个单字节的H和L合并成一个unsigned int双字节的数据c，其中H是高8位字节，L是低八位字节，合并成c后，c的值应该是十六进制的0x1234，此程序如何写？就需要用到左移。程序分析如下：
unsigned char H=0x12;//单字节
unsigned char L=0x34;//单字节
unsigned int c; //双字节
c=H;//c的低8位被H覆盖，也就是c的低8位得到了H的各位值。
c=c<<8; //及时把c的低8位移动到高8位，同时c原来的低8位被填入0
c=c+L;//此时c再加L，c的低8位就L的值。
程序运行结果:c就等于十六进制的0x1234，十进制是4660。
再多讲一下知识点，左移也存在简写格式，比如：
d<<=1; //就相当于d=d<<1;
e<<=2; //就相当于e=e<<2;
现在编写一个程序来练习刚才讲到的主要内容，最后把程序编译后下载到坚鸿51学习板观察结果。请直接复制第十节模板程序，修改的main程序代码如下：
void main() //主程序
{
/*---C语言学习区域的开始---------------------------------------------------------------------------*/
unsigned char a=5;
unsigned char b=5;
unsigned char H=0x12;//单字节
unsigned char L=0x34;//单字节
unsigned int c; //双字节
a=a<<1; //a左移1位，从原来的5变成了10.
b=b<<2; //b左移2位，从原来的5变成了20.
c=H; //c的低8位被H覆盖，也就是此时c的低8位得到了H的各位值。
c=c<<8;//及时把c的低8位移动到高8位，同时c原来的低8位被填入0
c=c+L; //此时c再加L，c的低8位就L的值。此时c得到了H和L合并而来的值。
GuiWdData0=a; //把a这个变量放到窗口变量0里面显示
GuiWdData1=b; //把b这个变量放到窗口变量1里面显示
GuiWdData2=c; //把c这个变量放到窗口变量2里面显示
/*---C语言学习区域的结束---------------------------------------------------------------------------*/
while(1)
{
initial();
key_service();
display_service();
}
}
查看运算结果的方法。如何在坚鸿51学习板上观察变量？按下S1或者S5按键即可切换显示不同的窗口，从而显示不同的变量。按下S9按键不松手就可以切换到十六进制的显示界面，松开手后会自动切换到十进制的界面。16个LED灯显示的就是当前变量的二进制数，亮代表1，灭代表0。上坚鸿51学习板观察程序执行的结果如下：
变量a为10 （十六进制是0x0A，二进制是00001010）。
变量b为20（十六进制是0x14，二进制是00010100）。
变量c为4660（十六进制是0x1234，二进制是0001 0010 0011 0100）。
下节预告：移位运算的右移。
（未完待续）
本帖最后由 吴坚鸿 于 2015-9-6 07:37 编辑
第三十五节：移位运算的右移。
右移的运算符号是“>>”，语法格式如下：
保存变量=被移数>>n;
其中n代表“被移数”需要右移的位数。
整句语法的含义是：“被移数”的二进制格式数据被整体往右边移动了n位，原来低n位数据被直接覆盖，新空出的高n位数据填入0。最后把移位结果存入“保存变量”。
现在举一个完整的例子来分析“右移”运算的规律。有2个unsigned char类型的变量a和b,a的初始值是十进制数5，a=a>>1的结果是多少？b的初始值也是十进制数5，b=b>>2的结果是多少？
分析步骤如下：
第一步：先把参与运算的数转换成二进制的格式。十进制转二进制的方法请参考前面第13,14,15节的内容。
十进制5的二进制格式是：00000101。
第二步：
(1)将5的二进制数整体往右边移动1位：
原来是：00000101
整体往右移动1位后变成：00000010
把二进制的00000010转换成十六进制是：0x02。转换成十进制是2。所以a初始值是5, 右移1位后的结果是2.
(2)将5的二进制数整体往右边移动2位：
原来是：00000101
整体往右移动2位后变成：00000001
把二进制的00000001转换成十六进制是：0x01。转换成十进制是1。所以b初始值是5, 右移2位后的结果是1。
上一节讲的“左移”1位有乘以2的规律，相反，这节讲的“右移”也存在整除的规律：某数右移1位相当于此数整除2，右移多少位相当于整除多少个2.比如上述例子中5右移1位相当于5整除2，结果等于2。而5右移2位相当于5整除2再整除2，5/2/2的结果等于1。既然右移1位相当于某个数整除2，那么为什么不直接用整除来替代右移呢？原因是一条右移语句的运算速度比一条整除语句的运算速度要快很多倍。
右移是在单片机项目中很常用的语法，也经常应用在一些数据类型之间的拆分中。比如有一个双字节unsigned int类型的变量c，它的初始值是0x1234，要把它拆分成两个unsigned char单字节的类型数据H和L，其中H是高8位字节，L是低八位字节，拆分后H应该等于0x12，L应该等于0x34，此程序如何写？就需要用到右移。程序分析如下：
unsigned char H;//单字节
unsigned char L;//单字节
unsigned int c=0x1234; //双字节
L=c;//c的低8位直接赋值给单字节的L
H=c>>8;//c先把高8位右移到低8位，然后再把这8位数据赋值给H
程序运行结果:H就等于十六进制的0x12，十进制是18。L就等于十六进制的0x34，十进制是52.提一个问题，请问执行完上述最后一条语句H=c>>8后，此时c的值是多少？答案是0x1234,因为只要它没有赋值给它自己，执行完语句后就不会改变它自己本身。
再多讲一下知识点，右移也存在简写格式，比如：
e>>=1; //就相当于e=e>>1;
f>>=2; //就相当于f=f>>2;
现在编写一个程序来练习刚才讲到的主要内容，最后把程序编译后下载到坚鸿51学习板观察结果。请直接复制第十节模板程序，修改的main程序代码如下：
void main() //主程序
{
/*---C语言学习区域的开始---------------------------------------------------------------------------*/
unsigned char a=5;
unsigned char b=5;
unsigned char H;//单字节
unsigned char L;//单字节
unsigned int c=0x1234; //双字节
unsigned int d;
a=a>>1;
b=b>>2;
L=c;//c的低8位直接赋值给单字节的L
H=c>>8;//c先把高8位右移到低8位，然后再把这8位数据赋值给H
//执行上述语句后，此时的c变量的数值是多少呢？
//答案是0x1234,因为只要没有赋值给它自己，就不会改变它自己.
d=c;//此时d就等于c，是十六进制的0x1234.十进制是4660
GuiWdData0=a; //把a这个变量放到窗口变量0里面显示
GuiWdData1=b; //把b这个变量放到窗口变量1里面显示
GuiWdData2=H; //把H这个变量放到窗口变量2里面显示
GuiWdData3=L; //把L这个变量放到窗口变量3里面显示
GuiWdData4=d; //把d这个变量放到窗口变量4里面显示
/*---C语言学习区域的结束---------------------------------------------------------------------------*/
while(1)
{
initial();
key_service();
display_service();
}
}
查看运算结果的方法。如何在坚鸿51学习板上观察变量？按下S1或者S5按键即可切换显示不同的窗口，从而显示不同的变量。按下S9按键不松手就可以切换到十六进制的显示界面，松开手后会自动切换到十进制的界面。16个LED灯显示的就是当前变量的二进制数，亮代表1，灭代表0。上坚鸿51学习板观察程序执行的结果如下：
变量a为2 （十六进制是0x02，二进制是00000010）。
变量b为1（十六进制是0x01，二进制是00000001）。
变量H为18（十六进制是0x12，二进制是00010010）。
变量L为52（十六进制是0x34，二进制是00110100）。
变量d为4660（十六进制是0x1234，二进制是0001 0010 0011 0100）。
下节预告：括号改变优先级。
（未完待续）
等着看出新书
第三十六节：括号改变优先级。
C语言的加减乘除，与或取反，左移右移等运算符是有严格优先级顺序的，但是我本人记忆力有限，做项目哪能记住这么多优先级的前后顺序，只是大概明白乘除的优先级比加减的优先级高，其它方面真的记不住那么多，怎么办？为了确保万一，我用到了括号。
括号的用法跟我们日常的数据运算公式的用法一直，先运行括号里面的运算，再执行其它运算。比如：
a=a<<2+5;
到底是先把变量a左移2位后再加5，还是先2加5等于7再让变量a左移7位？对于像我这样不能熟记C语言运算优先级顺序的人，这条语句很容易让我搞混。但是加上括号就明了：
a=(a<<2)+5;
a=a<<（2+5）;
不用多说，加上括号后，上述两行代码传递了清晰的优先级顺序。再看一个例子：
c=1+3*c;
到底是1加3的结果再乘以变量c，还是3乘以变量c的结果再加1？因为我记得乘除法的优先级比加减法的优先级高，所以答案是3乘以变量c的结果再加1。对于初学者，为了避免出错，可以加上括号就更加清晰了，比如：
c=(1+3)*c;
c=1+(3*c);
加括号后，优先级顺序一目了然。
现在编写一个程序来练习刚才讲到的主要内容，最后把程序编译后下载到坚鸿51学习板观察结果。请直接复制第十节模板程序，修改的main程序代码如下：
void main() //主程序
{
/*---C语言学习区域的开始---------------------------------------------------------------------------*/
unsigned char a=0x01;
unsigned char b=0x01;
unsigned char c=0x02;
unsigned char d=0x02;
a=(a<<2)+5;//a左移2位后变成4，再加5等于9
b=b<<(2+5);//2加5等于7，b再左移动7位等于128
c=(1+3)*c;//1加3等于4，再乘以变量c等于8
d=1+(3*d);//3乘以d等于6，再加1等于7
GuiWdData0=a; //把a这个变量放到窗口变量0里面显示
GuiWdData1=b; //把b这个变量放到窗口变量1里面显示
GuiWdData2=c; //把c这个变量放到窗口变量2里面显示
GuiWdData3=d; //把d这个变量放到窗口变量3里面显示
/*---C语言学习区域的结束---------------------------------------------------------------------------*/
while(1)
{
initial();
key_service();
display_service();
}
}
查看运算结果的方法。如何在坚鸿51学习板上观察变量？按下S1或者S5按键即可切换显示不同的窗口，从而显示不同的变量。按下S9按键不松手就可以切换到十六进制的显示界面，松开手后会自动切换到十进制的界面。16个LED灯显示的就是当前变量的二进制数，亮代表1，灭代表0。上坚鸿51学习板观察程序执行的结果如下：
变量a为9。
变量b为128。
变量c为8。
变量d为7。
下节预告：if判断语句和等于关系符“==”。
（未完待续）
支持楼主的分享精神
必须赞一下！！！
第三十七节：if判断语句以及常量变量真假的判断。
“if”是C语言的判断语句关键词，意思是如果if小括号里面的条件满足，就执行条件后面大括号里的语句；如果条件不满足，则直接跳过条件后面大括号里的语句。“if”语句的常见格式如下：
if(条件)
{
语句1;
语句2;
语句3;
……
}
还有一种省略大括号的书写格式，但是要注意，当if条件语句后面省略了大括号时，如果if小括号里面的条件满足，仅仅执行条件后面第一条语句，如果条件不满足，则跳过条件后面第一条语句。比如：
if(条件)
语句1;
语句2;
语句3;
……
上述格式省略了大括号，实际上默认相当于：
if(条件)
{
语句1;
}
语句2;
语句3;
……
上述语句分析：当条件满足时，就执行语句1，如果不满足，就跳过语句1，直接从语句2处开始往后执行。在实际项目中，为了阅读清晰，建议大家不要省略大括号。
接着讲另一个新的知识点，对于if(条件)，if语句的条件包含两种，一种是常量或者变量真假的判断，另一种是关系判断。本节内容先举例讲常量或变量的判断。比如：
if(常量或者变量)
{
语句1;
语句2;
}
语句3;
语句4;
……
当小括号里面的常量或者变量大于0时，就代表小括号里面的条件满足；当小括号里面的常量或者变量等于0时，就代表小括号里面的条件不满足。还有一种专业的说法，条件满足称之为“真”，条件不满足称之为“假”。在这里，常量或者变量大于0称之为“真”，等于0称之为“假”。还可以换一种思路来记忆，常量或者变量不等于0称之为“真”，等于0称之为“假”。比如刚才的例子：
if(常量或者变量)
{
语句1;
语句2;
}
语句3;
语句4;
……
若条件为真，则从语句1处开始执行，若条件为假，则跳过语句1和语句2，直接从语句3开始执行。
现在编写一个程序，有5条if判断语句，如果条件为真，累加统计变量就会自动加1，最后看看条件为真的语句有几条。最后把程序编译后下载到坚鸿51学习板观察结果。请直接复制第十节模板程序，修改的main程序代码如下：
void main() //主程序
{
/*---C语言学习区域的开始---------------------------------------------------------------------------*/
unsigned char x=2;
unsigned char y=0;
unsigned char a=0;//此变量统计有多少条语句是真的
if(1) //常量大于0，因此为真
{
a=a+1;//a由0自加1后变成1。
}
if(0) //常量等于0，因此为假
{
a=a+1;//由于条件为假，这条语句没有被执行，因此此时a仍然是1
}
if(15) //常量大于0，因此为真
{
a=a+1;//a由1自加1后变成2。
}
if(x) //变量x为2，大于0，因此为真
{
a=a+1;//a由,2自加1后变成3。
}
if(y) //变量y为0，等于0，因此为假
{
a=a+1;//由于条件为假，这条语句没有被执行，因此此时a仍然是3
}
GuiWdData0=a; //把a这个变量放到窗口变量0里面显示
/*---C语言学习区域的结束---------------------------------------------------------------------------*/
while(1)
{
initial();
key_service();
display_service();
}
}
查看运算结果的方法。如何在坚鸿51学习板上观察变量？按下S1或者S5按键即可切换显示不同的窗口，从而显示不同的变量。按下S9按键不松手就可以切换到十六进制的显示界面，松开手后会自动切换到十进制的界面。16个LED灯显示的就是当前变量的二进制数，亮代表1，灭代表0。上坚鸿51学习板观察程序执行的结果如下：
变量a为3。
下节预告：等于关系符“==”和不等于关系符“!=”。
（未完待续）
第三十八节：等于关系符“==”和不等于关系符“!=”。
上一节讲了if(条件)语句中当条件是纯常量或者变量的情况，这节开始讲if语句的关系判断。要进行关系判断，就涉及到关系符语句。本节先讲等于关系符“==”和不等于关系符“!=”。
一. 等于关系符“==”语句。
（1）等于关系符“==”语句的常见格式如下：
if(常量或变量==常量或变量)
{
语句1;
语句2;
}
语句3;
……
语句N;
上述格式的含义是：如果等于号”==”左边的数确实等于右边的数，就执行大括号里的语句1和语句2；如果左右的数不相等，直接跳过大括号里的语句1和语句2，从语句3开始继续往下执行。
if语句省略大括号时的执行顺序上一节已经讲过了，本节和以后的章节就不再重复讲这方面的内容。
（2）被判断的左右两个数中，如果有一个数是常量，另外一个是变量，针对这种情况建议大家尽量把常量放在等于号“==”的左边，原因是:万一程序员不小心把等于号“==”误写成赋值符号“=”时，编译器在编译时，能及时报错，因为常量在左边是无法赋值的，编译器能及时发现错误。但是如果变量在左边，因为变量是允许赋值的，所以有一些C语言编译器未必会报错，就会留下不易察觉的程序隐患。比如：
if(a==5)
{
语句1;
}
建议改成
if(5==a)
{
语句1;
}
二. 不等于关系符“!=”语句。
（1）不等于关系符“!=”语句的常见格式如下：
if(常量或变量!=常量或变量)
{
语句1;
语句2;
}
语句3;
……
语句N;
上述格式的含义是：如果不等于号”!=”左边的数确实不等于右边的数，就执行大括号里的语句1和语句2；如果左右的数恰好相等，就直接跳过大括号里的语句1和语句2，从语句3开始继续往下执行。
（2）被判断的左右两个数中，如果有一个数是常量，另外一个是变量，针对这种情况建议大家尽量把常量放在不等于号“!=”的左边，原因是:万一程序员不小心把不等于号“!=”误写成赋值符号“=”时，编译器在编译时，能及时报错，因为常量在左边是无法赋值的，编译器能及时发现错误。但是如果变量在左边，因为变量是允许赋值的，所以有一些C语言编译器未必会报错，就会留下不易察觉的程序隐患。比如：
if(a!=5)
{
语句1;
}
建议改成
if(5!=a)
{
语句1;
}
现在编写一个实验程序，一共有8个给定的数，要统计其中数值等于85的数有几个，统计其中数值不等于75的数有几个。最后把程序编译后下载到坚鸿51学习板观察结果。请直接复制第十节模板程序，修改的main程序代码如下：
void main() //主程序
{
/*---C语言学习区域的开始---------------------------------------------------------------------------*/
unsigned char x1=90; //给定的第1个数
unsigned char x2=65; //给定的第2个数
unsigned char x3=85; //给定的第3个数
unsigned char x4=79; //给定的第4个数
unsigned char x5=95; //给定的第5个数
unsigned char x6=65; //给定的第6个数
unsigned char x7=75; //给定的第7个数
unsigned char x8=85; //给定的第8个数
unsigned char a=0; //统计等于85的变量总数
unsigned char b=0; //统计不等于75的变量总数
if(85==x1)//把常量85放在等于号的左边
{
a++; //相当于a=a+1，用来统计等于85的总数
}
if(85==x2)//把常量85放在等于号的左边
{
a++; //相当于a=a+1，用来统计等于85的总数
}
if(85==x3)//把常量85放在等于号的左边
{
a++; //相当于a=a+1，用来统计等于85的总数
}
if(85==x4)//把常量85放在等于号的左边
{
a++; //相当于a=a+1，用来统计等于85的总数
}
if(85==x5)//把常量85放在等于号的左边
{
a++; //相当于a=a+1，用来统计等于85的总数
}
if(85==x6)//把常量85放在等于号的左边
{
a++; //相当于a=a+1，用来统计等于85的总数
}
if(85==x7)//把常量85放在等于号的左边
{
a++; //相当于a=a+1，用来统计等于85的总数
}
if(85==x8)//把常量85放在等于号的左边
{
a++; //相当于a=a+1，用来统计等于85的总数
}
if(75!=x1)//把常量75放在不等于号的左边
{
b++; //相当于b=b+1，用来统计不等于75的总数
}
if(75!=x2)//把常量75放在不等于号的左边
{
b++; //相当于b=b+1，用来统计不等于75的总数
}
if(75!=x3)//把常量75放在不等于号的左边
{
b++; //相当于b=b+1，用来统计不等于75的总数
}
if(75!=x4)//把常量75放在不等于号的左边
{
b++; //相当于b=b+1，用来统计不等于75的总数
}
if(75!=x5)//把常量75放在不等于号的左边
{
b++; //相当于b=b+1，用来统计不等于75的总数
}
if(75!=x6)//把常量75放在不等于号的左边
{
b++; //相当于b=b+1，用来统计不等于75的总数
}
if(75!=x7)//把常量75放在不等于号的左边
{
b++; //相当于b=b+1，用来统计不等于75的总数
}
if(75!=x8)//把常量75放在不等于号的左边
{
b++; //相当于b=b+1，用来统计不等于75的总数
}
GuiWdData0=a; //把a这个变量放到窗口变量0里面显示
GuiWdData1=b; //把b这个变量放到窗口变量1里面显示
/*---C语言学习区域的结束---------------------------------------------------------------------------*/
while(1)
{
initial();
key_service();
display_service();
}
}
查看运算结果的方法。如何在坚鸿51学习板上观察变量？按下S1或者S5按键即可切换显示不同的窗口，从而显示不同的变量。按下S9按键不松手就可以切换到十六进制的显示界面，松开手后会自动切换到十进制的界面。16个LED灯显示的就是当前变量的二进制数，亮代表1，灭代表0。上坚鸿51学习板观察程序执行的结果如下：
变量a为2。（等于85的有x3,x8这2个）
变量b为7。（不等于75的有x1,x2,x3,x4,x5,x6,x8这7个）
下节预告：大于关系符“>”和大于等于关系符“>=”。
（未完待续）
必须顶！感谢楼主分享！
吴坚鸿 发表于 2015-2-24 15:10
第一节：跟我学单片机到底是学什么？我的两个比喻和一个规则。
开篇第一节，我问大家一个问题，跟我 ...
谢谢楼主先
本帖最后由 吴坚鸿 于 2015-10-4 10:24 编辑
第三十九节：大于关系符“>”和大于等于关系符“>=”。
一. 再复习一遍if语句的通用格式：
if(条件)
{
语句1;
语句2;
}
语句3;
……
语句N;
上述格式的含义是：如果if语句里的条件满足（为真），就执行大括号里的语句1和语句2；如果条件不满足（为假），直接跳过大括号里的语句1和语句2，从语句3开始继续往下执行。
if语句省略大括号时的执行顺序前面章节已经讲过了，本节和以后的章节就不再重复讲这方面的内容。
二. 大于关系符“>”语句。
if(常量或变量>常量或变量)
上述if条件的真假判断规则是：如果左边的数大于右边的数，此条件为真（条件满足）。否则，为假（条件不满足）。
三. 大于等于关系符“>=”语句。
if(常量或变量>=常量或变量)
上述if条件的真假判断规则是：如果左边的数大于或者等于右边的数，此条件为真（条件满足）。否则，为假（条件不满足）。
现在编写一个实验程序，一共有8个给定的数，要统计其中数值大于79的数有几个，统计其中数值大于等于79的数有几个。最后把程序编译后下载到坚鸿51学习板观察结果。请直接复制第十节模板程序，修改的main程序代码如下：
void main() //主程序
{
/*---C语言学习区域的开始---------------------------------------------------------------------------*/
unsigned char x1=90; //给定的第1个数
unsigned char x2=65; //给定的第2个数
unsigned char x3=85; //给定的第3个数
unsigned char x4=79; //给定的第4个数
unsigned char x5=95; //给定的第5个数
unsigned char x6=65; //给定的第6个数
unsigned char x7=75; //给定的第7个数
unsigned char x8=85; //给定的第8个数
unsigned char a=0; //统计大于79的变量总数
unsigned char b=0; //统计大于等于79的变量总数
if(x1>79)//如果条件为真，则执行下面大括号里面的语句。
{
a++; //相当于a=a+1，用来统计大于79的总数
}
if(x2>79)//如果条件为真，则执行下面大括号里面的语句。
{
a++; //相当于a=a+1，用来统计大于79的总数
}
if(x3>79)//如果条件为真，则执行下面大括号里面的语句。
{
a++; //相当于a=a+1，用来统计大于79的总数
}
if(x4>79)//如果条件为真，则执行下面大括号里面的语句。
{
a++; //相当于a=a+1，用来统计大于79的总数
}
if(x5>79)//如果条件为真，则执行下面大括号里面的语句。
{
a++; //相当于a=a+1，用来统计大于79的总数
}
if(x6>79)//如果条件为真，则执行下面大括号里面的语句。
{
a++; //相当于a=a+1，用来统计大于79的总数
}
if(x7>79)//如果条件为真，则执行下面大括号里面的语句。
{
a++; //相当于a=a+1，用来统计大于79的总数
}
if(x8>79)//如果条件为真，则执行下面大括号里面的语句。
{
a++; //相当于a=a+1，用来统计大于79的总数
}
if(x1>=79)//如果条件为真，则执行下面大括号里面的语句。
{
b++; //相当于b=b+1，用来统计大于等于79的总数
}
if(x2>=79)//如果条件为真，则执行下面大括号里面的语句。
{
b++; //相当于b=b+1，用来统计大于等于79的总数
}
if(x3>=79)//如果条件为真，则执行下面大括号里面的语句。
{
b++; //相当于b=b+1，用来统计大于等于79的总数
}
if(x4>=79)//如果条件为真，则执行下面大括号里面的语句。
{
b++; //相当于b=b+1，用来统计大于等于79的总数
}
if(x5>=79)//如果条件为真，则执行下面大括号里面的语句。
{
b++; //相当于b=b+1，用来统计大于等于79的总数
}
if(x6>=79)//如果条件为真，则执行下面大括号里面的语句。
{
b++; //相当于b=b+1，用来统计大于等于79的总数
}
if(x7>=79)//如果条件为真，则执行下面大括号里面的语句。
{
b++; //相当于b=b+1，用来统计大于等于79的总数
}
if(x8>=79)//如果条件为真，则执行下面大括号里面的语句。
{
b++; //相当于b=b+1，用来统计大于等于79的总数
}
GuiWdData0=a; //把a这个变量放到窗口变量0里面显示
GuiWdData1=b; //把b这个变量放到窗口变量1里面显示
/*---C语言学习区域的结束---------------------------------------------------------------------------*/
while(1)
{
initial();
key_service();
display_service();
}
}
查看运算结果的方法。如何在坚鸿51学习板上观察变量？按下S1或者S5按键即可切换显示不同的窗口，从而显示不同的变量。按下S9按键不松手就可以切换到十六进制的显示界面，松开手后会自动切换到十进制的界面。16个LED灯显示的就是当前变量的二进制数，亮代表1，灭代表0。上坚鸿51学习板观察程序执行的结果如下：
变量a为4。（大于79的有x1,x3, x5,x8这4个）
变量b为5。（大于等于79的有x1,x3, x4, x5,x8这5个）
下节预告：小于关系符“<”和小于等于关系符“<=”。
（未完待续）
第四十节：小于关系符“<”和小于等于关系符“<=”。
一. 小于关系符“<”语句。
if(常量或变量<常量或变量)
上述if条件的真假判断规则是：如果左边的数小于右边的数，此条件为真（条件满足）。否则，为假（条件不满足）。
二. 小于等于关系符“<=”语句。
if(常量或变量<=常量或变量)
上述if条件的真假判断规则是：如果左边的数小于或者等于右边的数，此条件为真（条件满足）。否则，为假（条件不满足）。
现在编写一个实验程序，一共有8个给定的数，要统计其中数值小于79的数有几个，统计其中数值小于等于79的数有几个。最后把程序编译后下载到坚鸿51学习板观察结果。请直接复制第十节模板程序，修改的main程序代码如下：
void main() //主程序
{
/*---C语言学习区域的开始---------------------------------------------------------------------------*/
unsigned char x1=90; //给定的第1个数
unsigned char x2=65; //给定的第2个数
unsigned char x3=85; //给定的第3个数
unsigned char x4=79; //给定的第4个数
unsigned char x5=95; //给定的第5个数
unsigned char x6=65; //给定的第6个数
unsigned char x7=75; //给定的第7个数
unsigned char x8=85; //给定的第8个数
unsigned char a=0; //统计小于79的变量总数
unsigned char b=0; //统计小于等于79的变量总数
if(x1<79)//如果条件为真，则执行下面大括号里面的语句。
{
a++; //相当于a=a+1，用来统计小于79的总数
}
if(x2<79)//如果条件为真，则执行下面大括号里面的语句。
{
a++; //相当于a=a+1，用来统计小于79的总数
}
if(x3<79)//如果条件为真，则执行下面大括号里面的语句。
{
a++; //相当于a=a+1，用来统计小于79的总数
}
if(x4<79)//如果条件为真，则执行下面大括号里面的语句。
{
a++; //相当于a=a+1，用来统计小于79的总数
}
if(x5<79)//如果条件为真，则执行下面大括号里面的语句。
{
a++; //相当于a=a+1，用来统计小于79的总数
}
if(x6<79)//如果条件为真，则执行下面大括号里面的语句。
{
a++; //相当于a=a+1，用来统计小于79的总数
}
if(x7<79)//如果条件为真，则执行下面大括号里面的语句。
{
a++; //相当于a=a+1，用来统计小于79的总数
}
if(x8<79)//如果条件为真，则执行下面大括号里面的语句。
{
a++; //相当于a=a+1，用来统计小于79的总数
}
if(x1<=79)//如果条件为真，则执行下面大括号里面的语句。
{
b++; //相当于b=b+1，用来统计小于等于79的总数
}
if(x2<=79)//如果条件为真，则执行下面大括号里面的语句。
{
b++; //相当于b=b+1，用来统计小于等于79的总数
}
if(x3<=79)//如果条件为真，则执行下面大括号里面的语句。
{
b++; //相当于b=b+1，用来统计小于等于79的总数
}
if(x4<=79)//如果条件为真，则执行下面大括号里面的语句。
{
b++; //相当于b=b+1，用来统计小于等于79的总数
}
if(x5<=79)//如果条件为真，则执行下面大括号里面的语句。
{
b++; //相当于b=b+1，用来统计小于等于79的总数
}
if(x6<=79)//如果条件为真，则执行下面大括号里面的语句。
{
b++; //相当于b=b+1，用来统计小于等于79的总数
}
if(x7<=79)//如果条件为真，则执行下面大括号里面的语句。
{
b++; //相当于b=b+1，用来统计小于等于79的总数
}
if(x8<=79)//如果条件为真，则执行下面大括号里面的语句。
{
b++; //相当于b=b+1，用来统计小于等于79的总数
}
GuiWdData0=a; //把a这个变量放到窗口变量0里面显示
GuiWdData1=b; //把b这个变量放到窗口变量1里面显示
/*---C语言学习区域的结束---------------------------------------------------------------------------*/
while(1)
{
initial();
key_service();
display_service();
}
}
查看运算结果的方法。如何在坚鸿51学习板上观察变量？按下S1或者S5按键即可切换显示不同的窗口，从而显示不同的变量。按下S9按键不松手就可以切换到十六进制的显示界面，松开手后会自动切换到十进制的界面。16个LED灯显示的就是当前变量的二进制数，亮代表1，灭代表0。上坚鸿51学习板观察程序执行的结果如下：
变量a为3。（小于79的有x2,x6, x7这3个）
变量b为4。（小于等于79的有x2, x4,x6, x7这4个）
下节预告：与“&&”，或“||”的关系符。
（未完待续）
这贴干干的。值得好好看看{:lol:}
第四十一节：与“&&”，或“||”的关系符。
一．前面第30,31节内容讲了运算符的与或“&”“|”，它们与本节关系符的与或“&&”“||”有相似之处，同时又有什么区别呢？
（1）一个叫运算符，一个叫关系符。
（2）运算符是在一个变量二进制的位与位之间进行1和0的运算（1为真，0为假），而关系符是强调两个以上条件判断的整体与整体之间进行真和假的判断运算。
（3）运算符的书写符号是“&”“|”， 关系符的书写符号是“&&”“||”。
二．与“&&”语句。它的中文表达含义是：假如有两个条件判断，既满足第1个条件判断，又满足第2个条件判断，则此整体判断裁定为真（条件满足）。否则，只要一个条件判断不满足，此整体判断就裁定为假（条件不满足）。比如：
if(第1个条件判断&&第2个条件判断…&&第N个条件判断)
在上述if括号的条件中，如果所有的关系判断都为真，则此整体判断为真（条件满足），否则，只要有一个关系判断为假，则此整体判断为假（条件不满足）。
比如要取从70到80之间的所有数据，那么既要大于等于70，同时又要小于等于80，因此可以这样书写：
if(a>=70&&a<=80)
{
语句1;
语句2;
……
语句N;
}
三．或“||”语句。它的中文表达含义是：假如有两个条件判断，只要有一个条件判断为真，则此整体判断裁定为真（条件满足）。否则，必须所有的条件判断都不满足，此整体判断才会裁定为假（条件不满足）。比如：
if(第1个条件判断||第2个条件判断…||第N个条件判断)
在上述if括号的条件中，只要有1个条件判断为真，此整体判断就裁定为真。否则，必须所有的条件判断为假，此整体判断才裁定为假。
比如要取除了70到80之间以外的所有数据，也就是要么小于70，或者要么大于80，可以这样写：
if(a<70||a>80)
{
语句1;
语句2;
……
语句N;
}
现在编写一个实验程序，一共有8个给定的数，要统计其中数值从70到80之间的数有几个，统计其中取除了70到80之间以外的数有几个。最后把程序编译后下载到坚鸿51学习板观察结果。请直接复制第十节模板程序，修改的main程序代码如下：
void main() //主程序
{
/*---C语言学习区域的开始---------------------------------------------------------------------------*/
unsigned char x1=90; //给定的第1个数
unsigned char x2=65; //给定的第2个数
unsigned char x3=85; //给定的第3个数
unsigned char x4=79; //给定的第4个数
unsigned char x5=95; //给定的第5个数
unsigned char x6=65; //给定的第6个数
unsigned char x7=75; //给定的第7个数
unsigned char x8=85; //给定的第8个数
unsigned char a=0; //统计从70到80的变量总数
unsigned char b=0; //统计除了70到80以外的变量总数
if(x1>=70&&x1<=80)//如果条件为真，则执行下面大括号里面的语句。
{
a++; //相当于a=a+1，用来统计从70到80的总数
}
if(x2>=70&&x2<=80)//如果条件为真，则执行下面大括号里面的语句。
{
a++; //相当于a=a+1，用来统计从70到80的总数
}
if(x3>=70&&x3<=80)//如果条件为真，则执行下面大括号里面的语句。
{
a++; //相当于a=a+1，用来统计从70到80的总数
}
if(x4>=70&&x4<=80)//如果条件为真，则执行下面大括号里面的语句。
{
a++; //相当于a=a+1，用来统计从70到80的总数
}
if(x5>=70&&x5<=80)//如果条件为真，则执行下面大括号里面的语句。
{
a++; //相当于a=a+1，用来统计从70到80的总数
}
if(x6>=70&&x6<=80)//如果条件为真，则执行下面大括号里面的语句。
{
a++; //相当于a=a+1，用来统计从70到80的总数
}
if(x7>=70&&x7<=80)//如果条件为真，则执行下面大括号里面的语句。
{
a++; //相当于a=a+1，用来统计从70到80的总数
}
if(x8>=70&&x8<=80)//如果条件为真，则执行下面大括号里面的语句。
{
a++; //相当于a=a+1，用来统计从70到80的总数
}
if(x1<70||x1>80)//如果条件为真，则执行下面大括号里面的语句。
{
b++; //相当于b=b+1，用来统计除了70到80以外的总数
}
if(x2<70||x2>80)//如果条件为真，则执行下面大括号里面的语句。
{
b++; //相当于b=b+1，用来统计除了70到80以外的总数
}
if(x3<70||x3>80)//如果条件为真，则执行下面大括号里面的语句。
{
b++; //相当于b=b+1，用来统计除了70到80以外的总数
}
if(x4<70||x4>80)//如果条件为真，则执行下面大括号里面的语句。
{
b++; //相当于b=b+1，用来统计除了70到80以外的总数
}
if(x5<70||x5>80)//如果条件为真，则执行下面大括号里面的语句。
{
b++; //相当于b=b+1，用来统计除了70到80以外的总数
}
if(x6<70||x6>80)//如果条件为真，则执行下面大括号里面的语句。
{
b++; //相当于b=b+1，用来统计除了70到80以外的总数
}
if(x7<70||x7>80)//如果条件为真，则执行下面大括号里面的语句。
{
b++; //相当于b=b+1，用来统计除了70到80以外的总数
}
if(x8<70||x8>80)//如果条件为真，则执行下面大括号里面的语句。
{
b++; //相当于b=b+1，用来统计除了70到80以外的总数
}
GuiWdData0=a; //把a这个变量放到窗口变量0里面显示
GuiWdData1=b; //把b这个变量放到窗口变量1里面显示
/*---C语言学习区域的结束---------------------------------------------------------------------------*/
while(1)
{
initial();
key_service();
display_service();
}
}
查看运算结果的方法。如何在坚鸿51学习板上观察变量？按下S1或者S5按键即可切换显示不同的窗口，从而显示不同的变量。按下S9按键不松手就可以切换到十六进制的显示界面，松开手后会自动切换到十进制的界面。16个LED灯显示的就是当前变量的二进制数，亮代表1，灭代表0。上坚鸿51学习板观察程序执行的结果如下：
变量a为2。（数值从70到80之间的有x4, x7这2个）
变量b为6。（除了70到80之间以外的有x1, x2,x3,x5, x6, x8这6个）
下节预告：括号改变判断的优先级。
（未完待续）
楼主，什么时候在一楼更新一下索引
第四十二节：小括号改变判断的优先级。
小括号如何改变判断优先级？ C语言有规定，凡是在判断语句里插入了小括号，程序就会优先执行最里面小括号的判断语句，之后才会根据判断符的优先级执行其它相关语句。
小括号的意义何在？C语言中的判断符号众多，非常不利于程序员对各符号优先级的记忆，小括号却解决了这个问题。小括号因为可以改变判断的优先级，所以为实际项目带来了两个好处：一个是明确判断顺序，一个是改变判断顺序。
比如在上一节提到的两个判断语：
if(a>=70&&a<=80)和if(a<70||a>80)
有一些朋友喜欢插入两个小括号变成：
if((a>=70)&&(a<=80))和if((a<70)||(a>80))
上述的修改，在不知道 “>,>=,<,<=” 这类语句跟 “&&,||” 这类语句哪个优先级更高的前提下，插入了小括号，可以更加明确判断的顺序，这种做法也挺好的，值得肯定。我个人平时在面对“>,>=,<,<=”这类语句跟 “&&,||” 这类语句时，也就是针对上述那种情况，由于我比较肯定的清楚“>,>=,<,<=”这类语句比“&&,||” 这类语句的优先级高，所以我不需要在此插入小括号来明确判断顺序。但是在下面将要提到的这种情况，我是会百分百插入小括号来明确和改变判断的顺序。什么情况呢？如下：
if(判断条件1||判断条件2&&判断条件3)
到底是先“判断条件1” 跟“判断条件2”相或，最后再跟“判断条件3”相与？还是先“判断条件2” 跟“判断条件3”相与，最后再跟“判断条件1”相或？此时应该插入小括号明确它们判断的先后顺序。
要么第一种顺序：
if((判断条件1||判断条件2)&&判断条件3)
要么第二种顺序：
if(判断条件1||（判断条件2&&判断条件3))
具体选择哪种一种判断顺序要根据项目的需要来决定。同样的3个判断条件，如果判断的顺序不一样，那么结果也可能出现不一样，比如，上述判断条件：
假设“判断条件1”为真，
假设“判断条件2”为真，
假设“判断条件3”为假，
第一种顺序：
if((真||真)&&假)
分析结论：先”真”和”真”相或结果为”真”，然后再把第一步判断结果的”真”和”假”相与，最后结果是”假”。
第二种顺序：
if(真||(真&&假))
分析结论：先”真”和” 假”相与结果为” 假”，然后再把第一步判断结果的” 假”和”真”相或，最后结果是”真”。
现在编写一个实验程序验证上述两种判断顺序，最后把程序编译后下载到坚鸿51学习板观察结果。请直接复制第十节模板程序，修改的main程序代码如下：
void main() //主程序
{
/*---C语言学习区域的开始---------------------------------------------------------------------------*/
//x,y这三个变量作为条件判断的变量
unsigned char x=5;
unsigned char y=6;
//a,b这两个变量作为输出判断结果的真假，0代表假，1代表真。
unsigned char a=0;//默认为0，也就是默认为假
unsigned char b=0;//默认为0，也就是默认为假
if((x<y||y>x)&&x==y) //里面的条件是((真||真)&&假)，最终结果判断是假
{
a=1;
}
if(x<y||(y>x&&x==y)) //里面的条件是(真||(真&&假))，最终结果判断是真
{
b=1;
}
GuiWdData0=a; //把a这个变量结果放到窗口变量0里面显示
GuiWdData1=b; //把b这个变量结果放到窗口变量1里面显示
/*---C语言学习区域的结束---------------------------------------------------------------------------*/
while(1)
{
initial();
key_service();
display_service();
}
}
查看运算结果的方法。如何在坚鸿51学习板上观察变量？按下S1或者S5按键即可切换显示不同的窗口，从而显示不同的变量。按下S9按键不松手就可以切换到十六进制的显示界面，松开手后会自动切换到十进制的界面。16个LED灯显示的就是当前变量的二进制数，亮代表1，灭代表0。上坚鸿51学习板观察程序执行的结果如下：
变量a为0。（0代表此条件判断结果为假）
变量b为1。（1代表此条件判断结果为真）
下节预告：if,elseif,else的5种组合判断语句。
（未完待续）
不错
难得一见的贴子啊,楼主辛苦了.我会一直关注的,也请楼主一直保持更新吧,学习了很多{:handshake:}{:handshake:}{:handshake:}
第四十三节：if,else if,else的5种组合判断语句。
if,else if,else可以组成5种组合判断语句，这类组合语句可以这样通俗的解读：在众多条件判断中，先从第一个条件开始判断，如果第一个条件是真，那么不管后面的条件是否为真，都不再判断，直接执行条件1大括号后面的语句，组合语句中其它剩下的条件不再判断直接跳过，否则，就挨个条件往下判断，只要其中一个条件满足，就不再判断剩余的条件，也就是我们日常所说的多选一，甚至某些组合语句如果所有条件都不满足，那么什么也不选。总之，在如此众多的条件中，最多只能执行一个条件后面大括号的语句。组合语句还有一个规律：if语句只能出现在第一个条件判断，而且只能出现一次；else只能出现在最后一个条件判断，而且也只能出现一次；而else if语句总是出现在中间，绝对不能出现在第一个条件判断，如果没有else，也可以出现在最后的条件判断。接下来挨个仔细分析这5种组合语句的特点。
第一种：
if(条件1) //if只能出现第一个条件，并且只能出现一次
{
语句1；
}
else //else只能出现最后，并且也只能出现一次。
{
语句2；
}
分析：如果“条件1”为真，就直接执行“条件1”后面大括号的“语句1”，不再执行else后面的“语句2”。否则，如果“条件1”为假，那么就不执行“条件1”后面大括号的“语句1”，而是直接执行else后面的大括号“语句2”。简单概括就是两个必选一个，如果第一个条件1为假，就直接执行else后面大括号里的语句，也就是本例子中的“语句2”。
第二种：
if(条件1) //if只能出现第一个条件，并且只能出现一次
{
语句1；
}
elseif(条件2)//else if只能出现中间，可以出现多次
{
语句2；
}
分析：如果“条件1”为真，就直接执行“条件1”后面大括号的“语句1”，这时不管else if后面的“条件2”是否为真，都不再判断的“条件2”，这种情况当然也不会执行到“语句2”。否则，如果“条件1”为假，那么就不执行“条件1”后面大括号的“语句1”，而是继续判断else if后面的“条件2”，如果“条件2”为真，就会执行后面大括号的“语句2”，否则如果“条件2”也为假，那么“语句2”也不会执行。简单概括就是在两个条件中最多只能选一个，如果两个条件都为假，那么都不选。
第三种：
if(条件1) //if只能出现第一个条件，并且只能出现一次
{
语句1；
}
elseif(条件2) //else if只能出现中间，可以出现多次
{
语句2；
}
else //else只能出现最后，并且也只能出现一次。
{
语句3；
}
分析：如果“条件1”为真，就直接执行“条件1”后面大括号的“语句1”，这时不管else if后面的“条件2”是否为真，都不再判断的“条件2”，这种情况当然也不会执行到后面的“语句2”，更加不会执行到else 后面的“语句3”。否则，如果“条件1”为假，那么就不执行“条件1”后面大括号的“语句1”，而是继续判断else if后面的“条件2”，如果“条件2”为真，就会执行后面大括号的“语句2”，而else后面的“语句3”就不会被执行到，否则如果“条件2”也为假，那么“语句2”也不会执行，此时就直接执行else后面的“语句3”。简单概括就是在三个条件中必须选一个，如果前面两个条件都为假，那么就直接执行else后面大括号里的语句，也就是本例子中的“语句3”。
第四种：
if(条件1) //if只能出现第一个条件，并且只能出现一次
{
语句1；
}
elseif(条件2) //else if只能出现中间，可以出现多次
{
语句2；
}
……
elseif(条件N) //else if只能出现中间，可以出现多次
{
语句N；
}
分析：从“条件1”开始往下判断，只要有一个条件满足了，就执行当前条件后面大括号的语句，剩余的条件不再判断直接跳过，如果所有的条件都不满足，那么里面的语句都不执行。简单概括就是在N个条件中最多只能选一个，如果所有的条件都为假，那么都不选。
第五种：
if(条件1) //if只能出现第一个条件，并且只能出现一次
{
语句1；
}
elseif(条件2) //else if只能出现中间，可以出现多次
{
语句2；
}
……
elseif(条件N) //else if只能出现中间，可以出现多次
{
语句N；
}
else
{
语句N+1；
}
分析：从“条件1”开始往下判断，只要有一个条件满足了，就执行当前条件后面大括号的语句，剩余的条件不再判断直接跳过，如果所有的条件都不满足，那么就直接执行else后面大括号里的语句，也就是本例子中的“语句N+1”。简单概括就是在N+1个条件中必须选一个，如果前面所有N个条件都为假，最后就直接执行else后面大括号的语句，也就是本例子中的“语句N+1”。
现在编写一个程序来实验上述5种组合语句。最后把程序编译后下载到坚鸿51学习板观察结果。请直接复制第十节模板程序，修改的main程序代码如下：
void main() //主程序
{
/*---C语言学习区域的开始---------------------------------------------------------------------------*/
//x这个变量作为条件判断的变量
unsigned char x=5;
//a,b,c,d,e这5个变量作为输出判断结果,0代表什么语句都没执行，1代表执行了语句1，
//2代表执行语句2，3代表执行语句3，4代表执行语句4，5代表执行语句5。
unsigned char a=0;
unsigned char b=0;
unsigned char c=0;
unsigned char d=0;
unsigned char e=0;
//第一种
if(x>6)//x默认是5
{
a=1; //语句1
}
else
{
a=2;//语句2
}
//第二种
if(x>6)//x默认是5
{
b=1; //语句1
}
else if(x==7)//x默认是5
{
b=2;//语句2
}
//第三种
if(x>6)//x默认是5
{
c=1; //语句1
}
else if(x==7)//x默认是5
{
c=2;//语句2
}
else
{
c=3;//语句3
}
//第四种
if(x>6)//x默认是5
{
d=1; //语句1
}
else if(x==7)//x默认是5
{
d=2;//语句2
}
else if(x==5)//x默认是5
{
d=3;//语句3
}
else if(x==4)//x默认是5
{
d=4;//语句4
}
//第五种
if(x>6)//x默认是5
{
e=1; //语句1
}
else if(x==7)//x默认是5
{
e=2;//语句2
}
else if(x==5)//x默认是5
{
e=3;//语句3
}
else if(x==4)//x默认是5
{
e=4;//语句4
}
else
{
e=5;//语句5
}
GuiWdData0=a; //把a这个变量结果放到窗口变量0里面显示
GuiWdData1=b; //把b这个变量结果放到窗口变量1里面显示
GuiWdData2=c; //把c这个变量结果放到窗口变量2里面显示
GuiWdData3=d; //把d这个变量结果放到窗口变量3里面显示
GuiWdData4=e; //把e这个变量结果放到窗口变量4里面显示
/*---C语言学习区域的结束---------------------------------------------------------------------------*/
while(1)
{
initial();
key_service();
display_service();
}
}
查看运算结果的方法。如何在坚鸿51学习板上观察变量？按下S1或者S5按键即可切换显示不同的窗口，从而显示不同的变量。按下S9按键不松手就可以切换到十六进制的显示界面，松开手后会自动切换到十进制的界面。16个LED灯显示的就是当前变量的二进制数，亮代表1，灭代表0。上坚鸿51学习板观察程序执行的结果如下：
变量a为2。（2代表执行了语句2）
变量b为0。（0代表什么语句都没执行）
变量c为3。（3代表执行了语句3）
变量d为3。（3代表执行了语句3）
变量e为3。（3代表执行了语句3）
下节预告：一维数组。
（未完待续）
佩服楼主的敬业精神！一定要顶起！虽然帖子都有得看，还是期待楼主出书，只为收藏！
相当基础的教学，不错，收藏学习了！
一直在关注LZ，学到很多！
加油！
第四十四节：一维数组能批量定义变量的特点。
一维数组有两个特点：
第一个：批量定义变量。我们之前的章节用unsignedchar, unsignedint, unsigned long定义变量时，往往一条语句只习惯定义一个变量，而用数组可以一条语句定义N个变量，只要不超过单片机的RAM范围。
第二个：数组的每个元素变量的地址都是挨个相临的。第一个元素变量的地址是该数组的首地址，后面的下标是以此首地址为原点的偏移地址。这个特点跟以后学到的循环语句或者指针配合起来，只需简单几行代码就可以实现很多复杂实用的算法。
上述第二个特点的内容等以后学到循环语句和指针时再深入讲解，本节重点讲解一维数组的书写格式和第一个特点。
一维数组未带初始化时的通用定义格式如下：
类型 数组名[数组元素个数N];
比如：
unsigned charx;//此处的3不是下标，而是元素个数
分析：此数组一行代码定义了三个变量，分别是x, x, x，此时中括号里的0,1,2称为数组的下标，注意，数组的下标是从0开始的，从N-1结束，此时的N代表数组元素个数。因此，上述数组不存在x这个元素变量，只有x, x, x这三个变量，如果非要使用x这个元素变量，那就会导致数组越界出现异常或者编译不通过。
一维数组带初始化时的通用定义格式如下：
类型 数组名[数组元素个数N]={ 元素0, 元素1，…元素N-1};
比如：
unsigned chary={10,11,12};
分析：此数组一行代码定义了三个变量，分别是y, y, y。而y初始化为10，y初始化为11，y初始化为12。
在程序中，调用数组某个变量元素时，下标可以是常量，比如y,此时的0就是常量；下标也可以是变量，比如y，此时的i就是变量。再强调一次，下标常量或者变量i的数值必须小于y数组定义时的元素个数，否则就会导致数组越界出现异常或者编译不通过。
现在编写一个程序来熟悉一下一维数组的书写和使用格式。最后把程序编译后下载到坚鸿51学习板观察结果。请直接复制第十节模板程序，修改的main程序代码如下：
void main() //主程序
{
/*---C语言学习区域的开始---------------------------------------------------------------------------*/
unsigned charx;//此处的3不是下标，而是元素个数，里面的3个变量没有初始化
unsigned chary={10,11,12}; //里面三个元素变量y,y,y分别初始化为10,11,12
unsigned chari=0; //定义和初始化一个变量。用来做x数组的下标。
x=25;//此时下标i为0.相当于把25赋值给x
i=i+1; //i由0变成1.
x=26;//此时下标i为1.相当于把26赋值给x
i=i+1; //i由1变成2.
x=27;//此时下标i为2.相当于把27赋值给x
x=x+1; //此时x自加1变成了28
GuiWdData0=x; //把x这个元素变量放到窗口变量0里面显示
GuiWdData1=x; //把x这个元素变量放到窗口变量1里面显示
GuiWdData2=x; //把x这个元素变量放到窗口变量2里面显示
GuiWdData3=y; //把y这个元素变量放到窗口变量3里面显示
GuiWdData4=y; //把y这个元素变量放到窗口变量4里面显示
GuiWdData5=y; //把y这个元素变量放到窗口变量5里面显示
/*---C语言学习区域的结束---------------------------------------------------------------------------*/
while(1)
{
initial();
key_service();
display_service();
}
}
查看运算结果的方法。如何在坚鸿51学习板上观察变量？按下S1或者S5按键即可切换显示不同的窗口，从而显示不同的变量。按下S9按键不松手就可以切换到十六进制的显示界面，松开手后会自动切换到十进制的界面。16个LED灯显示的就是当前变量的二进制数，亮代表1，灭代表0。上坚鸿51学习板观察程序执行的结果如下：
变量元素x为25。
变量元素x为26。
变量元素x为28。
变量元素y为10。
变量元素y为11。
变量元素y为12。
下节预告：二维数组能批量定义变量的特点。
（未完待续）
等待鸿哥更新{:titter:}
鸿哥太棒了，谢谢慷慨分享
第四十五节：二维数组。
上一节讲一维数组时漏讲了一个知识点，一维数组在定义时，如果预先给它填写若干个初始化的数据，也可以省略中括号里面的元素个数N，这样编译器在编译时会根据初始化的个数来自动识别和定义此一维数组实际元素个数。比如：
unsigned chary={10,11,12};
跟
unsigned chary[]={10,11,12};
的意义是一样的。注意，省略元素个数时必须要有初始化的数据，否则编译器不知道此数组的长度可能导致编译出错。
继续回到本节的内容，二维数组。一维数组只有一个下标，像由很多点连成的一条直线，而二维数组有两个下标，布下了一行行的点像一张矩形的网，它的两个下标分别代表了行和列，行和列又像我们所学的y轴和x轴坐标，通过y轴和x轴坐标就可以找到所需的点，也就是数组的某个元素。
上述是对二维数组的感性描述，二维数组是由一维数组发展而来，所以具备了很多一维数组的特点。二维数组的所有”网点”元素的地址都是挨个相临的，先第0行，再第1行，再第2行…再第N行，上一行尾元素跟下一行头元素的地址是相临连续的。
二维数组未带初始化时的通用定义格式如下：
类型 数组名[行数Y][列数X];
比如：
unsigned chara; //此处的2代表有2行，3代表有3列。
分析：此二维数组定义了6个变量，跟一维数组一样，下标都是从0开始，到(N-1)时结束，此处的N代表行数或者列数。所以a数组的元素挨个分别是a,a, a, a, a, a这6个变量。
二维数组有两种常用初始化格式，一种是逐行初始化，一种是整体初始化。
第一种逐行初始化：
unsigned char a=
{
{0,1,2},
{3,4,5}
};
在逐行初始化定义二维数组时，只要有初始化的数据，也可以省略行下标，但是列下标不能省略，比如：
unsigned char a[]=
{
{0,1,2},
{3,4,5}
};
此时编译器会根据元素的个数来确定行数是多少。
第二种整体初始化，跟一维数组一样,内部数据元素不需要额外增加大括号来分行。
unsigned char a=
{
0,1,2,3,4,5
};
或者
unsigned char a=
{
0,1,2,
3,4,5
};
都行。
C语言是很自由很丰富的语言，比如二维数组还允许不完全初始化的一些情况，我就不再深入讲解，我讲解的都是挑选一些针对以后单片机项目中可能会经常用到的语法。
二维数组我在很多项目上还是经常用到的，比如用在一些需要把所得的信息进行查表判断的项目，在每一行里放一条关键词字符串信息，利用循环语句进行逐行查找匹配。至于二维数组如何存放字符串的知识点以后再讲。这节的重点是让大家对二维数组有个初步的认识。
现在编写一个程序来熟悉一下二维数组的书写和使用格式。最后把程序编译后下载到坚鸿51学习板观察结果。请直接复制第十节模板程序，修改的main程序代码如下：
void main() //主程序
{
/*---C语言学习区域的开始---------------------------------------------------------------------------*/
unsigned chara=//定义和初始化一个二维数组
{
{0,1,2},
{3,4,5}
};
GuiWdData0=a; //把a这个元素变量放到窗口变量0里面显示
GuiWdData1=a; //把a这个元素变量放到窗口变量1里面显示
GuiWdData2=a; //把a这个元素变量放到窗口变量2里面显示
GuiWdData3=a; //把a这个元素变量放到窗口变量3里面显示
GuiWdData4=a; //把a这个元素变量放到窗口变量4里面显示
GuiWdData5=a; //把a这个元素变量放到窗口变量5里面显示
/*---C语言学习区域的结束---------------------------------------------------------------------------*/
while(1)
{
initial();
key_service();
display_service();
}
}
查看运算结果的方法。如何在坚鸿51学习板上观察变量？按下S1或者S5按键即可切换显示不同的窗口，从而显示不同的变量。按下S9按键不松手就可以切换到十六进制的显示界面，松开手后会自动切换到十进制的界面。16个LED灯显示的就是当前变量的二进制数，亮代表1，灭代表0。上坚鸿51学习板观察程序执行的结果如下：
变量元素a为0。
变量元素a为1。
变量元素a为2。
变量元素a为3。
变量元素a为4。
变量元素a为5。
下节预告：while循环语句。
（未完待续）
与鸿哥近距离了！等到鸿哥更新了{:titter:}
第四十六节：while循环语句。
46.1 程序的跑道
“程序跑起来了吗？”同行交流经常用的一句话。程序在哪里跑？有跑道吗？有的。循环语句就像一条椭圆的跑道，程序在跑道上不停的跑，永无止境，一秒几百万圈的速度。单片机main主函数内往往有一条while(1)语句，这就是单片机的“循环跑道”，称之为主循环，主循环内还可以继续嵌套多层while循环语句。
46.2 while循环的常见格式
while(条件)
{
语句1;
语句2;
……
语句N;
}
分析：
(1)先判断条件是否为真。如果为假，就不执行花括号循环体内的语句1至语句N。如果为真，才执行花括号循环体内的语句1至语句N，当执行完花括号循环体内最后的“语句N“时，单片机继续返回while(条件)处，继续判断条件是否为真，如果为假就跳过花括号循环体，如果为真就继续从“语句1“执行到“语句N“，然后再返回while(条件)处，依次循环下去，直到条件为假时才罢休，否则一直循环下去。
（2）while(条件)语句中，条件判断真假的规则跟if语句一模一样，有两种类型：一种是纯常量或者变量类型的，只要此数值不等于0就认为是真，所以while(1)也称死循环语句，因为里面的条件永远不为0，如果不遇到break,return,goto这些语句，那么就永远也别想跳出这个循环；另外一种是关系判断，以及关系语句之间的“与或”判断，跟if语句规则一样，不多讲。break,return,goto这些语句后面章节会讲到。
46.3 while省略花括号，后面第一条语句前没带分号
while(条件)
语句1;
语句2;
……
语句N;
分析：
跟if语句一样，此时循环体默认只包含“语句1”，相当于：
while(条件)
{
语句1;
}
语句2;
……
语句N;
46.4 while省略花括号，后面第一条语句前带分号
while(条件);
语句1;
语句2;
……
语句N;
分析：
注意，此时循环体默认不包含“语句1”，而是相当于：
while(条件)
; //一个分号代表一条空语句，语法上要求加上分号
语句1;
语句2;
……
语句N;
此时如果条件一直为真，单片机就一直在空循环耗着，执行不到语句1的语句。直到条件为假才罢休。
46.5 编写程序
编写一个程序来熟悉一下while语句的书写和使用格式。最后把程序编译后下载到坚鸿51学习板观察结果。请直接复制第十节模板程序，修改的main程序代码如下：
void main() //主程序
{
/*---C语言学习区域的开始---------------------------------------------------------------------------*/
unsigned char a=0;//观察这个数最后的变化
unsigned char b=0;//观察这个数最后的变化
unsigned char i;//控制循环体的条件判断变量
i=3;
while(i)//i不断变为0时才跳出此循环体
{
a=a+1;
i=i-1; //循环的条件不断发生变化，不断减小
}
i=0;
while(i<3)//i大于等于3时才跳出此循环体
{
b=b+2;
i=i+1; //循环的条件不断发生变化，不断增加
}
GuiWdData0=a; //把a这个变量放到窗口变量0里面显示
GuiWdData1=b; //把b这个变量放到窗口变量1里面显示
/*---C语言学习区域的结束---------------------------------------------------------------------------*/
while(1)
{
initial();
key_service();
display_service();
}
}
查看运算结果的方法。如何在坚鸿51学习板上观察变量？按下S1或者S5按键即可切换显示不同的窗口，从而显示不同的变量。按下S9按键不松手就可以切换到十六进制的显示界面，松开手后会自动切换到十进制的界面。16个LED灯显示的就是当前变量的二进制数，亮代表1，灭代表0。上坚鸿51学习板观察程序执行的结果如下：
变量a为3。
变量b为6。
下节预告：while循环语句的嵌套与break语句。
（未完待续）
标记学习。。。。。
鼓励吴老师
老鸟偶尔看看基础的东西也有好多收货！{:lol:}
收藏学习了!加油！
第四十七节：循环语句do while和for。
47.1 do while语句的常见格式
do{
语句1;
语句2;
……
语句N;
} while(条件);
分析：
单片机从上往下执行语句，先从do那里无条件进来，从语句1开始往下执行，一直执行到语句N，然后开始判断while(条件)的条件是否为真，如果为真继续返回到do的入口处，继续从语句1开始往下执行，依次循环。大家留意到了吗，do while和while语句有什么差别？差别是，dowhile是先无条件进来执行一次循环体（花括号里所有的程序代码），执行到循环体最底部才判断while(条件)的条件是否为真来决定是否继续循环，先上车再买票。而while语句是先判断条件是否为真再决定是否需要进入循环体，先买票再上车。
47.2 for语句的简介
for语句也是循环语句，任何for语句实现的功能都可以用while语句来编程实现同样的功能，那for语句和while语句有什么差别呢？for语句把变量初始化，变量的条件判断，变量在执行循环体后的步进变化这三个常见要素集成在语句内部，以标准的格式书写出来。在很多场合下，for在书写和表达方面比while语句显得更加简洁和直观。
47.3 for语句的自加格式。
for(变量的初始化语句; 变量的条件判断;变量在执行一次循环体后自加的步进变化)
{
语句1;
语句2;
……
语句N;
}
在把上述变成具体一点如下：
for(i=0; i<3;i++)
{
语句1;
语句2;
……
语句N;
}
分析：
单片机从上往下，在进入循环体前，先把变量i初始化赋值0，然后判断i是否小于3这个条件，如果此条件为真，就开始从语句1往下执行到语句N，执行完一次循环体后，i因为“i++”语句就自加1，此时i从原来初始化的0变成了1，接着再返回来到for语句的第二句条件判断”i<3”那里，判断i是否继续小于3这个条件，如果此条件为真就继续往下执行，否则就跳过循环体。因此上述for语句的功能如果用while语句来写，相当于以下代码：
i=0;//进入循环体之前先初始化给予初值
while(i<3)
{
语句1;
语句2;
……
语句N;
i++; //执行一次循环体之后此变量自加发生变化
}
上述的循环语句只执行了3次循环体。
47.4 for语句的自减格式
刚才讲的for(i=0; i<3;i++)格式，它的变量i是不断自加的，还有一种比较常见的格式是i不断自减的。如下：
for(i=3; i>0;i--)
{
语句1;
语句2;
……
语句N;
}
上述自减的for语句功能如果用while语句来写，相当于以下代码：
i=3;//进入循环体之前先初始化给予初值
while(i>0)
{
语句1;
语句2;
……
语句N;
i--; //执行一次循环体之后此变量自减发生变化
}
上述的循环语句也是只执行了3次循环体。
47.5 for省略花括号，后面第一条语句前没带分号
for(i=0; i<3;i++)
语句1;
语句2;
……
语句N;
分析：
跟if语句一样，此时循环体默认只包含“语句1”，相当于：
for(i=0; i<3;i++)
{
语句1;
}
语句2;
……
语句N;
47.6 for省略花括号，后面第一条语句前带分号
for(i=0; i<3;i++);
语句1;
语句2;
……
语句N;
分析：
注意，此时循环体默认不包含“语句1”，而是相当于：
for(i=0; i<3;i++)
;//一个分号代表一条空语句，语法上要求加上分号
语句1;
语句2;
……
语句N;
此时循环体内先循环执行三次空语句，然后才会结束for循环，接着从语句1开始往下执行。
47.7 编写程序
编写一个程序来熟悉一下do while和for语句的使用。最后把程序编译后下载到坚鸿51学习板观察结果。请直接复制第十节模板程序，修改的main程序代码如下：
void main() //主程序
{
/*---C语言学习区域的开始---------------------------------------------------------------------------*/
unsigned char a=0;//观察这个数最后的变化
unsigned char b=0;//观察这个数最后的变化
unsigned char c=0;//观察这个数最后的变化
unsigned char i;//控制循环体的条件判断变量
i=3;
do
{
a=a+1;//每执行一次循环体a就增加1,此行代码被循环执行了3次
i=i-1;//i不断变小
}while(i); //i不断变小，当i变为0时才跳出此循环体
for(i=0;i<3;i++)
{
b=b+2;//此行代码被循环执行了3次
}
for(i=3;i>0;i--)
{
c=c+3;//此行代码被循环执行了3次
}
GuiWdData0=a; //把a这个变量放到窗口变量0里面显示
GuiWdData1=b; //把b这个变量放到窗口变量1里面显示
GuiWdData2=c; //把c这个变量放到窗口变量1里面显示
/*---C语言学习区域的结束---------------------------------------------------------------------------*/
while(1)
{
initial();
key_service();
display_service();
}
}
查看运算结果的方法。如何在坚鸿51学习板上观察变量？按下S1或者S5按键即可切换显示不同的窗口，从而显示不同的变量。按下S9按键不松手就可以切换到十六进制的显示界面，松开手后会自动切换到十进制的界面。16个LED灯显示的就是当前变量的二进制数，亮代表1，灭代表0。上坚鸿51学习板观察程序执行的结果如下：
变量a为3。
变量b为6。
变量c为9。
下节预告：循环体内的continue和break语句。
（未完待续）
吴老师！顶您一下
谢谢楼主分享。
第四十八节：循环体内的continue和break语句。
48.1 continue语句
通常情况下，单片机在循环体里从上往下执行，一直执行到最底部的花括号才会返回到循环体入口处准备第二次循环，但是，如果在循环体中途遇到continue语句，单片机虽然没有执行到最底部的花括号，也会马上返回到循环体入口处准备第二次循环，在continue语句之后至最底部花括号之间的语句没有被执行到。比如：
while(…)或者for(…) //循环体的条件判断入口处
{ //循环体开始
语句1;
语句2;
continue；
语句3;
……
语句N;
} //循环体结束
分析：
上述语句中，单片机从语句1开始执行到continue语句，然后马上就返回到循环体的条件判断入口处，也就是语句3至语句N是不可能被执行到的，上述语句简化后相当于：
while(…)或者for(…) //循环体的条件判断入口处
{ //循环体开始
语句1;
语句2;
} //循环体结束
既然可以如此简化，还要continue语句有什么用呢？我们一般应用continue的时候不会像上面那样单独使用，而是配合这if条件判断语句来用，这样continue才有它存在价值，比如：
while(…)或者for(…) //循环体的条件判断入口处
{ //循环体开始
语句1;
语句2;
if(某条件)
{
continue；
}
语句3;
……
语句N;
} //循环体结束
48.2 break语句
continue语句是提前结束当前这一次的循环，准备进入下一次的新循环，是某次结束的概念。而break语句是直接跳出当前循环体，结束当前循环体，是整体结束的概念。
while(…)或者for(…) //循环体的条件判断入口处
{ //循环体开始
语句1;
语句2;
break;
语句3;
……
语句N;
} //循环体结束
语句(N+1);//循环体之外语句
分析：
上述语句中，单片机从语句1开始执行到break语句，无需判断while或者for的条件，直接马上跳出循环体，执行到循环体之外的语句(N+1)。在实际项目中，break往往也是会配合if条件判断语句一起使用，比如：
while(…)或者for(…) //循环体的条件判断入口处
{ //循环体开始
语句1;
语句2;
if(某条件)
{
break；
}
语句3;
……
语句N;
} //循环体结束
语句(N+1);//循环体之外语句
48.3 break语句能跳多远
break语句能跳多远？预知答案请先分析以下这个例子：
while(…)
{
语句1;
语句2;
while(…)
{
语句3;
break;
语句4;
}
语句5;
}
语句6;
上述例子中，在while循环里面有藏着第二个while循环，这种循环之中还有循环，通常称之为循环嵌套。单片机从上往下执行语句，当遇到break后，它会跳到语句5那里呢，还是会跳到语句6那里？正确答案是语句5那里。说明了break语句跳远范围仅仅刚好能跳出当前的循环体。在上述循环嵌套的例子中，最内层的break只能跳出最内层的循环体，不能跳到最外层的语句6那里，如果需要继续跳出最外层的语句6那里，可以继续在外层的循环体内再增加一个break语句。
48.4 还有哪些语句可以无条件退出循环体
还有return和goto语句可以跳出循环体。这部分的内容大家只需大概了解一下即可。return语句比break语句还厉害，它不仅仅跳出当前循环体，还是跳出了当前函数，也就是提前结束了当前函数，这部分的内容后面章节会讲到，暂时不用管。而goto语句在C语言中大家都公认不建议用，因为它很容易扰乱大家常用的C语言编程结构，我本人也从来没有用过goto语句，所以这条语句我也不再深入讲解它。
48.5 编写程序
编写一个程序来熟悉一下continue和break语句的使用。最后把程序编译后下载到坚鸿51学习板观察结果。请直接复制第十节模板程序，修改的main程序代码如下：
void main() //主程序
{
/*---C语言学习区域的开始---------------------------------------------------------------------------*/
unsigned char a=0;//观察这个数最后的变化
unsigned char b=0;//观察这个数最后的变化
unsigned char c=0;//观察这个数最后的变化
unsigned char d=0;//观察这个数最后的变化
unsigned char i;//控制循环体的条件判断变量
//i<6的条件判断是在进入循环体之前判断，而i的自加1是在执行完一次循环体之后才自加的。
for(i=0;i<6;i++)
{
a=a+1; //被执行了6次，分别是第0,1,2,3,4,5次
if(i>=3)
{
continue;//提前结束本次循环，准备进入下一次循环
}
b=b+1;//被执行了3次，分别是第0,1,2次
}
//i<6的条件判断是在进入循环体之前判断，而i的自加1是在执行完一次循环体之后才自加的。
for(i=0;i<6;i++)
{
c=c+1; //被执行了4次，分别是第0,1,2,3次
if(i>=3)
{
break; //马上跳出当前循环体
}
d=d+1; //被执行了3次，分别是第0,1,2次
}
GuiWdData0=a; //把a这个变量放到窗口变量0里面显示
GuiWdData1=b; //把b这个变量放到窗口变量1里面显示
GuiWdData2=c; //把c这个变量放到窗口变量2里面显示
GuiWdData3=d; //把d这个变量放到窗口变量3里面显示
/*---C语言学习区域的结束---------------------------------------------------------------------------*/
while(1)
{
initial();
key_service();
display_service();
}
}
查看运算结果的方法。如何在坚鸿51学习板上观察变量？按下S1或者S5按键即可切换显示不同的窗口，从而显示不同的变量。按下S9按键不松手就可以切换到十六进制的显示界面，松开手后会自动切换到十进制的界面。16个LED灯显示的就是当前变量的二进制数，亮代表1，灭代表0。上坚鸿51学习板观察程序执行的结果如下：
变量a为6。
变量b为3。
变量c为4。
变量d为3。
下节预告：for和while的循环嵌套。
（未完待续）
来顶鸿哥的{:titter:}
第四十九节：for和while循环体的嵌套。
49.1 循环体嵌套的执行顺序
for循环体内又包含了for循环体可以称为循环体嵌套。比如：
for(i=0;i<2;i++)//大循环
{
语句1;
for(k=0;k<3;k++) //内嵌的小循环
{
语句2;
}
语句3;
}
上述例子中，带i的for称为大循环，带k的for称为小循环，单片机从大循环入口进来，由上往下执行，执行第1次大循环，先执行1次“语句1”，接着进入小循环，小循环要连续循环执行3次“语句2”才跳出小循环，之后执行1次“语句3”，然后再返回到大循环入口判断i条件是否满足，此时条件满足，继续执行第2次大循环，1次“语句1”，3次“语句2”，1次“语句3”，第2次循环结束后又返回到大循环入口判断i条件，此时i已经等于2不再小于2了，因此条件不满足，结束整个循环嵌套。上述执行的语句顺序如下：
语句1; //第1次大循环开始
语句2;
语句2;
语句2;
语句3;
语句1; //第2次大循环开始
语句2;
语句2;
语句2;
语句3;
根据此顺序，再看一个具体的程序例子：
a=0;
b=0;
for(i=0;i<2;i++)//大循环
{
a=a+1;//被执行了2次
for(k=0;k<3;k++) //内嵌的小循环
{
b= b+1;//被执行了6次
}
}
上述例子中，执行完程序后，a的值变成了2，b的值变成了6。重点分析b的变化，“b=b+1”在内嵌循环体里被执行了6次，6次从何而来？就是i乘以k等于6。这个乘法次数是循环嵌套一个很重要的特性。上述程序如果用while语句来实现如下：
a=0;
b=0;
i=0;//控制大循环的变量初始化
while(i<2)//大循环
{
a=a+1;//被执行了2次
k=0; //控制小循环的变量初始化
while(k<3) //内嵌的小循环
{
b= b+1;//被执行了6次
k=k+1;
}
i=i+1;
}
49.2 循环嵌套的常见用途---二维数组的应用
前面章节讲到了二维数组a，它有6个变量，在没有学for语句之前，要依次把每个元素单独赋值清零真不容易，要写6次赋值语句如下：
a=0;
a=0;
a=0;
a=0;
a=0;
a=0;
自从懂了for嵌套语句之后，直接写代码如下，简洁了许多：
for(i=0;i<2;i++)//大循环
{
for(k=0;k<3;k++) //内嵌的小循环
{
a=0;
}
}
49.3 循环嵌套的常见用途---大延时
以后接触单片机项目后，会经常会用到delay这个延时函数，大部分都是利用for循环来实现，小延时函数往往不用嵌套，直接如下编写：
for(k=0;k<N;k++);
上述的N是控制循环次数，每次循环都要消耗单片机一点时间，如果N越大需要消耗的时间就越多，起到延时的作用。但是N所能取的最大值受它所定义的类型所限制，比如是unsigned char类型时最大范围是255，是unsigned int类型时最大范围是65535，是unsigned long类型时最大范围是4294967295。如果要实现更大的延时怎么办？就可以用for的循环嵌套，利用循环嵌套次数的乘法翻倍特性，很容易编写大的延时函数。比如：
for(i=0;i<M;i++)//大循环
{
for(k=0;k<N;k++); //内嵌的小循环
}
此时循环的次数是N乘以M的乘积。
现在编写一个循环嵌套的练习程序，最后把程序编译后下载到坚鸿51学习板观察结果。请直接复制第十节模板程序，修改的main程序代码如下：
void main() //主程序
{
/*---C语言学习区域的开始---------------------------------------------------------------------------*/
unsigned char a=0;//观察这个数最后的变化
unsigned char b=0;//观察这个数最后的变化
unsigned char c=0;//观察这个数最后的变化
unsigned char i;//控制大循环体的条件判断变量
unsigned char k;//控制内嵌小循环体的条件判断变量
for(i=0;i<2;i++)//大循环
{
a=a+1; //被执行了2次
for(k=0;k<3;k++)//内嵌小循环
{
b=b+1;//被执行了6次，也就是i乘以k，2乘以3等于6.
}
c=c+1; //被执行了2次
}
GuiWdData0=a; //把a这个变量放到窗口变量0里面显示
GuiWdData1=b; //把b这个变量放到窗口变量1里面显示
GuiWdData2=c; //把c这个变量放到窗口变量2里面显示
/*---C语言学习区域的结束---------------------------------------------------------------------------*/
while(1)
{
initial();
key_service();
display_service();
}
}
查看运算结果的方法。如何在坚鸿51学习板上观察变量？按下S1或者S5按键即可切换显示不同的窗口，从而显示不同的变量。按下S9按键不松手就可以切换到十六进制的显示界面，松开手后会自动切换到十进制的界面。16个LED灯显示的就是当前变量的二进制数，亮代表1，灭代表0。上坚鸿51学习板观察程序执行的结果如下：
变量a为2。
变量b为6。
变量c为2。
下节预告：switch语句。
（未完待续）
学习了，再次感谢鸿哥！
每次看一到一篇，都是绝对的震撼。{:lol:}
谢谢楼主的无私分享
第五十节：switch语句。
switch是非常重要的语句，我几乎所有的单片机项目都是用switch搭建程序主框架。如果说while和for是一对孪生兄弟，那么if-elseif和switch也是一对孪生兄弟，凡是用switch语句能实现的功能都可以用if-elseif实现。switch有条件分支的功能，在条件超过3个以上的条件分支功能里，switch书写会比if-else if更加直观清晰。
50.1 switch语句的语法
以下是switch语句常见的格式:
switch(变量) //根据变量的数值大小从对应的case入口进来
{
case 0: //入口0
语句0;
break; //switch程序体的出口之一
case 1://入口1
语句1;
break; //switch程序体的出口之一
case 2: //入口2
语句2;
break; //switch程序体的出口之一
} //最下面的花括号也是一个switch程序体的出口之一
执行顺序分析：
单片机从switch(变量)进来，根据变量的数值大小，进入对应的case入口里。假如变量等于1，就直接进入到case 1入口，执行“语句1”后，遇到break语句就跳出整个switch程序体。假如变量等于3,单片机从switch(变量)进来，因为没有发现case 3，所以直接跳出switch程序体没有执行任何语句。多补充一句，在case 2选项中，语句2最后的break可以省略，因为case 2是最后一个case，即使没有遇到break也会遇到最下面的花括号而跳出switch程序体。上述程序功能如果用if-elseif语句来实现如下：
if(变量==0)
{
语句0;
}
else if(变量==1)
{
语句1;
}
else if(变量==2)
{
语句2;
}
50.2 switch语句的break
大家从50.1的例子中看到了三个关键字分别是:switch,case,break。其实并不是每个case都必须要break配套，break只是起到一个出口的功能。假如没有遇到break，程序会一直往下执行，直到遇到break或者switch最下面的花括号为止。比如:
switch(变量) //根据变量的数值大小从对应的case入口进来
{
case 0: //入口0
语句0;
break;
case 1://入口1
语句1;
case 2: //入口2
语句2;
break;
case 3: //入口3
语句3;
break;
} //最下面的花括号也是一个switch程序体的出口之一
执行顺序分析：
假如此时switch(变量)的变量等于1，就直接进入到case 1入口，执行“语句1”后，没有遇到break语句，继续执行“语句2”，紧接着遇到break语句，才跳出整个switch程序体。本例子中case 1没有break语句，就继续往下执行下面case2里面的语句，直到遇到break或者最下面的花括号为止。
50.3 switch语句的case有规定顺序吗？必须连贯吗？
switch程序体内部可以写很多case入口，这些case入口是不是必须按从小到大的顺序？是不是规定必须case数字连贯？答：没有规定顺序，也没有规定case数字连贯，case的数值只是代表入口。比如以下两种写法都是合法的：
50.3.1 case不按从小到大的顺序:
switch(变量)
{
case 2:
语句2;
break;
case 0:
语句0;
break;
case 1:
语句1;
break;
}
50.3.2 case的数字不连贯
switch(变量)
{
case 0:
语句0;
break;
case 3:
语句3;
break;
case 9:
语句9;
break;
}
50.4 switch语句的default。
default和break一样，也不是必须的语句，应根据程序需要来选择。default相当于if-else if-else 语句中的else，也就是当switch(变量)的变量没有匹配的case入口时，就会默认进入default入口，就像if-else if-else 语句中当前面所有的条件不满足时，就进入else语句的程序体，比如：
switch(变量) //根据变量的数值大小从对应的case入口进来
{
case 0: //入口0
语句0;
break; //switch程序体的出口之一
case 1://入口1
语句1;
break; //switch程序体的出口之一
case 2: //入口2
语句2;
break; //switch程序体的出口之一
default://当所有的case不满足，就进入default入口
语句3;
break;
} //最下面的花括号也是一个switch程序体的出口之一
执行顺序分析：
假如switch(变量)的变量等于35，因为没有找到case 35，所以就直接从默认的default入口进来执行” 语句3”，然后遇到break语句就跳出switch程序体。上述程序功能如果用if-elseif-else语句来实现如下：
if(变量==0)
{
语句0;
}
else if(变量==1)
{
语句1;
}
else if(变量==2)
{
语句2;
}
else //相当于switch中的default
{
语句3;
}
50.5 switch语句中内嵌switch
if语句也可以内嵌if语句，while语句也可以内嵌while语句，switch语句当然也可以内嵌switch。比如
switch(a)
{
case 1:
switch(b)
{
case 1:
Break;
case 2:
Break;
}
Break;
case 2:
Break;
}
这种switch内嵌switch语句也是合法的，而且在实际项目中也很常用，大家目前先有个大概的了解即可，暂时不深入讲解。
50.6 switch练习程序
现在编写一个switch的练习程序，最后把程序编译后下载到坚鸿51学习板观察结果。请直接复制第十节模板程序，修改的main程序代码如下：
void main() //主程序
{
/*---C语言学习区域的开始---------------------------------------------------------------------------*/
unsigned char k; //此变量为switch的入口判断变量
unsigned char a; //观察此变量的变化来理解switch的执行顺序
a=0;
k=2;
switch(k)
{
case 0://入口0
a++;
break; //跳出switch
case 1://入口1
a++;
case 2://入口2,上述k等于2所以从这里进来
a++;
case 3://入口3
a++;
case 4://入口4
a++;
break;//跳出switch
case 5://入口5
a++;
break;//跳出switch
default: //入口default，相当于else。当前面没有遇到对应的case入口时，就默认进入此default入口
a++;
break;//跳出switch
} //最后一个switch的花括号也是跳出switch
GuiWdData0=a; //把a这个变量放到窗口变量0里面显示
/*---C语言学习区域的结束---------------------------------------------------------------------------*/
while(1)
{
initial();
key_service();
display_service();
}
}
查看运算结果的方法。如何在坚鸿51学习板上观察变量？按下S1或者S5按键即可切换显示不同的窗口，从而显示不同的变量。按下S9按键不松手就可以切换到十六进制的显示界面，松开手后会自动切换到十进制的界面。16个LED灯显示的就是当前变量的二进制数，亮代表1，灭代表0。上坚鸿51学习板观察程序执行的结果如下：
变量a为3。
下节预告：空返回空形参的函数。
（未完待续）
彻底！！！
第五十一节：函数的三要素和执行顺序。
51.1 增加子函数内容后如何运用第10节模板程序调试
前面章节讲的内容因为没有涉及到子函数，范例程序的编辑调试只需要在一个main主函数里操作就可以，原来的调试方式如下：
void main() //主函数
{
/*---C语言学习区域的开始---------------------------------------------------------------------------*/
unsigned chara;//普通局部变量的定义
unsigned charb;//普通局部变量的定义
…… //一些程序代码
……
……
GuiWdData0=a; //把a这个变量放到窗口变量0里面显示
GuiWdData1=b; //把b这个变量放到窗口变量1里面显示
……
/*---C语言学习区域的结束---------------------------------------------------------------------------*/
while(1)
{
initial();
key_service();
display_service();
}
}
本节开始增加子函数内容，所以以后的调试方式如下：
/*---C语言学习区域的开始---------------------------------------------------------------------------*/
void hanshu(void);//子函数的声明
unsigned charx;//全局变量的定义
unsigned chary;//全局变量的定义
void hanshu(void)//子函数的定义
{
unsigned charc;//普通局部变量的定义子函数的语句;
……
}
void main() //主函数
{
unsigned chara;//普通局部变量的定义
unsigned charb;//普通局部变量的定义
…… //其它一些程序代码
hanshu() ; //子函数的调用
…… //其它一些程序代码
GuiWdData0=a; //把a这个变量放到窗口变量0里面显示
GuiWdData1=b; //把b这个变量放到窗口变量1里面显示
……
/*---C语言学习区域的结束---------------------------------------------------------------------------*/
while(1)
{
initial();
key_service();
display_service();
}
}
对比原来，现在的“C语言学习区域的开始”分割线往上移动增大了范围，其它部分内容不用变，还是直接在第10节的模板程序里更改和添加这部分的内容就可以了。
51.2 函数的三要素。
有的人习惯把函数称为程序，比如主程序，子程序，这时的主程序对应主函数，子程序对应子函数，是一回事，只是每个人的表达习惯不一样而已。函数的三要素是声明，定义，调用。新构造一个函数时，尽量遵守这个三个要素来做就可以减少一些差错。什么叫函数的声明，定义，调用？先让大家有一个感性的认识，请先看下面这个例程：
/*---C语言学习区域的开始---------------------------------------------------------------------------*/
void hanshu(void); //子函数的声明
void hanshu(void) //子函数的定义
{
…… //子函数的代码语句
}
void main() //主函数
{
hanshu() ; //子函数的调用
/*---C语言学习区域的结束---------------------------------------------------------------------------*/
while(1)
{
……
}
}
51.3 子函数在主函数里的执行顺序
子函数被其它函数调用时，子函数的名字就相当于一个跳转地址，而子函数的定义就是要跳转的实际地址，单片机在主函数里遇到子函数名称，就直接跳转到子函数定义那里执行子函数定义部分的代码，执行完子函数后再返回到主函数，继续执行子函数名称后面部分的代码，请看下面这个代码的执行顺序，就可以一目了然：
/*---C语言学习区域的开始---------------------------------------------------------------------------*/
void hanshu(void); //子函数的声明
void hanshu(void) //子函数的定义
{
语句1;
语句2;
}
void main() //主函数
{
语句3;
hanshu() ; //子函数的调用
语句4;
/*---C语言学习区域的结束---------------------------------------------------------------------------*/
while(1)
{
……
}
}
执行顺序分析：
单片机从主函数main那里进来往下执行，先执行“语句3”，接着遇到hanshu名称的跳转地址，然后马上跳转到hanshu的定义部分，执行“语句1”,“语句2”，执行完子函数hanshu的定义部分，就马上返回到主函数，继续执行hanshu名称后面的“语句4”。整个执行语句的先后顺序如下：
语句3;
语句1;
语句2;
语句4;
下节预告：普通局部变量和全局变量在函数里的作用域和优先级。
（未完待续）
支持楼主的分享精神
第五十二节：从局部变量和全局变量中感悟“栈”为何物。
52.1什么是局部变量，什么是全局变量。
局部变量就是在函数内部定义的变量，全局变量就是在函数外面定义的变量。下面举的例子能很清晰的说明局部变量和全局变量的特点：
unsigned char a; //在函数外面定义的，所以是全局变量。
void main()
{
unsigned char b; //在函数内部定义的，所以是局部变量。
}
52.2局部变量和全局变量的内存模型。
我在第三节里讲到，单片机内存包括ROM和RAM两部分，ROM存储的是单片机程序中的指令和一些不可更改的常量数据，而RAM存放的是可以被更改的数据，这些可以被程序更改的数据就叫做变量。变量包括局部变量和全局变量，但是局部变量和全局变量在RAM中的数据结构有本质不同。欲知不同在哪，首先要从RAM说起。对于大部分的单片机，RAM都至少分成两部分，一部分是给全局变量，一部分是给局部变量。给全局变量那部分的RAM叫全局数据区，给局部变量那部分的RAM叫做“栈”，因为我后面会用宾馆来比喻“栈”，所以为了方便记忆，可以把“栈”想象成 “客栈”来记忆。 全局数据区就像你自己家的房间，是唯一的，一个房间的地址只能你一个人住，而且是永久的，所以说每个全局变量都有唯一对应的RAM地址，不可能重复的。而“栈”就像宾馆客栈，每天晚上住的人不一样，每个人在里面居住的时间是有期限的，不是长久的，一个房间的地址每天可能住进不同的人，不是唯一的。全局区的全局变量拥有永久产权，“栈”区的局部变量只能临时居住在宾馆客栈，地址不是唯一的，有期限的。全局变量像私人区，局部变量像公共区。
52.3借用宾馆客栈比喻局部变量的期限。
void hanshu(void); //子函数的声明
void hanshu(void) //子函数的定义
{
unsigned char a; //局部变量
a=1;
}
void main() //主函数
{
hanshu() ; //子函数的调用
}
请看上面的程序例子，单片机从主函数main往下执行，首先遇到hanshu子函数的调用，所以就跳到hanshu函数的定义那里开始执行，此时的局部变量a开始被分配在RAM的栈区的某个地址，相当于你入住宾馆被分配到某个房间。单片机执行完子函数hanshu后，局部变量a在RAM的栈区所分配的地址被收回，局部变量a消失，被收回的RAM地址可能会被系统重新分配给其它被调用的函数的局部变量，此时相当于你离开宾馆，原来在宾馆居住那个房间被收回，你离开宾馆，从此你跟那个宾馆的房间没有啥关系，它可能会被宾馆老板重新分配给其他的客人入住。结论：局部变量的作用域就是它所在函数的内部范围，而全局变量的作用域是永久性不受范围限制的。
52.4局部变量和全局变量的优先级。
上面最后一段话中得到一个结论：局部变量的作用域就是它所在函数的内部范围，而全局变量的作用域是永久性并且不受范围限制的。那么问题来，假如局部变量和全局变量的名字重名了，此时函数内部执行的变量到底是局部变量还是全局变量？这个问题就涉及到优先级。注意，当面对同名的局部变量和全局变量时，函数内部执行的变量是局部变量，也就是局部变量在函数内部要比全局变量的优先级高。
52.4.1 请看第一个例子：
/*---C语言学习区域的开始---------------------------------------------------------------------------*/
unsigned char a=5; //全局变量的定义
void main() //主程序
{
unsigned char a=2;//局部变量的定义
GuiWdData0=a; //把a这个数值放到窗口变量0里面显示，此时的a是局部变量2,而不是5
/*---C语言学习区域的结束---------------------------------------------------------------------------*/
while(1)
{
initial();
key_service();
display_service();
}
}
此时输出显示2。
52.4.2 请看第二个例子：
/*---C语言学习区域的开始---------------------------------------------------------------------------*/
void hanshu(void); //函数声明
unsigned char a=5; //全局变量的定义
void hanshu(void) //函数定义
{
unsigned char a=3;//局部变量的定义
}
void main() //主程序
{
unsigned char a=2; //局部变量的定义
hanshu();//子函数被调用
GuiWdData0=a; //把a这个数值放到窗口变量0里面显示，此时的a是局部变量2
/*---C语言学习区域的结束---------------------------------------------------------------------------*/
while(1)
{
initial();
key_service();
display_service();
}
}
此时输出显示2。
分析：虽然子函数hanshu内部也有一个a=3，但是当hanshu被调用完结束后，这个a就消失不起作用了，所以此时显示的是main函数内部的局部变量。
52.4.3 请看第三个例子：
/*---C语言学习区域的开始---------------------------------------------------------------------------*/
void hanshu(void); //函数声明
unsigned char a=5; //全局变量的定义
void hanshu(void) //函数定义
{
unsigned char a=3;//局部变量的定义
}
void main() //主程序
{
hanshu();//子函数被调用
GuiWdData0=a; //把a这个数值放到窗口变量0里面显示，此时的a是全部变量5
/*---C语言学习区域的结束---------------------------------------------------------------------------*/
while(1)
{
initial();
key_service();
display_service();
}
}
此时输出显示5。
分析：子函数hanshu 里面的a的作用域只是它本身，因此子函数hanshu里面的a没办法影响到其它函数的a。而main函数内部没有了局部变量，那么此时起作用的只能是全局变量，因此显示5。假如此时连全局变量也没有了怎么办？这种情况是语法错误不能编译通过，因为任何变量的调用都必须要被先定义，定义有两种，要么是在函数内被定义成局部变量，要么是在函数外被定义成全局变量。
52.5 局部变量和全局变量的总结归纳.
（1）每定义一个新的全局变量，就意味着多开销一个新的RAM内存。而每定义一个局部变量，只要在函数内部所定义的局部变量总数不超过单片机的“栈”区，此时的局部变量不开销新的RAM内存，因为局部变量是临时借用“栈”区的，使用后就还给“栈”，“栈”是公共区，可以重复利用，可以服务若干个不同的函数内部局部变量。
（2）单片机每次进入执行函数时，局部变量都会被初始化改变，而全局变量则不会被初始化，全局变量是一直保存之前最后一次更改的值。
下节预告：空返回空形参的函数。
（未完待续）
又来听讲了{:titter:}
本帖最后由 吴坚鸿 于 2016-1-4 05:21 编辑
第五十三节：函数的作用和四种常见书写类型。
【53.1 函数的作用和分类。】
函数的作用。通常把一些可能反复用到的算法或者过程封装成一个函数，函数就是一个模块，给它输入特定的参数，就可以输出想要的结果，比如一个加法函数，只要输入加数和被加数，然后就会输出相加结果之和，里面具体的算法过程只要写一次就可以重复调用，极大的节省单片机程序容量，也节省程序开发人员的工作量。
函数的分类。从输入输出的角度来看，有四种常见的书写类型。分别是无输出无输入，无输出有输入，有输出无输入，有输出有输入。输出是看函数名的前缀，前缀如果是void表示无输出，否则就是有输出。输入是看函数名括号里的内容，如果是void或者是空着就表示无输入，否则就是有输入。输出和输入是比较通俗的说法，专业一点的说法是，有输出表示函数有返回，无输出表示函数无返回。有输入表示有形参，无输入表示无形参。下面举一个加法函数的例子，分别用四种不同的函数类型来实现。大家对比一下它们在书写方面有哪些不同，又有哪些规律。
【53.2 无输出无输入的函数。】
unsigned char a;//此变量用来接收最后相加结果的和。
unsigned char g=2;
unsigned char h=3;
void hanshu(void)//无输出无输入函数的定义。
{
a=g+h;
}
main()
{
hanshu();//函数调用时的样子。
}
分析：
void hanshu(void)，此函数名的前缀是void，括号内也是void，属于无输出无输入函数。这类函数表面看是无输出无输入，其实在实际应用中也可以通过全局变量来输入输出，比如上面的例子就是靠a,g,h这三个全局变量来传递信息，只不过表达方式上像隐藏起来一样没有那么直观。
【53.3 无输出有输入的函数。】
unsigned char b;//此变量用来接收最后相加结果的和。
void hanshu(unsigned char i,unsigned char k) //无输出有输入函数的定义
{
b=i+k;
}
main()
{
hanshu(2,3);//函数调用时的样子。
}
分析：
void hanshu(unsigned char i,unsigned char k)，此函数名的前缀是void，括号内是(unsigned char i,unsigned char k)，属于无输出有输入的函数。括号的两个变量i和k是函数内的局部变量，也是跟对外的桥梁接口，它们有一个专业的名称叫形参。外部要调用此函数时，只要给括号填入对应的变量或者数值，这些变量和数值就会被复制一份传递给作为函数形参的局部变量，从而外部调用者跟函数内部就发生了数据信息的传递。这种书写方式的特点是把输入接口封装了出来。
【53.4 有输出无输入的函数。】
unsigned char c; //此变量用来接收最后相加结果的和。
unsigned char m=2;
unsigned char n=3;
unsigned char hanshu(void) //有输出无输入函数的定义。
{
unsigned char p;
p=m+n;
return p;
}
main()
{
c= hanshu();//函数调用时的样子。
}
分析：
unsigned char hanshu(void)，此函数名的前缀是unsigned char类型，括号内是void，属于有输出无输入的函数。函数前缀的unsigned char表示此函数最后退出时会返回一个unsigned char类型的数据给外部调用者。而且这类函数内部必须有一个return语句配套，表示立即退出当前函数并且返回某个变量或者常量的数值给外部调用者。这种书写方式的特点是把输出接口封装了出来。
【53.5 有输出有输入的函数。】
unsigned char d; //此变量用来接收最后相加结果的和。
unsigned char hanshu(unsigned char r,unsigned char s) //有输出无输入函数的定义
{
unsigned char t;
t=r+s;
return t;
}
main()
{
d= hanshu(2,3);//函数调用时的样子。
}
分析：
unsigned char hanshu(unsigned char r,unsigned char s)，此函数名的前缀是unsigned char类型，括号内是(unsigned char r,unsigned char s)，属于有输出有输入的函数。输入输出的特点跟前面介绍的函数一样，不多讲。这种书写方式的特点是把输出和输入接口都封装了出来。
【53.6 调用函数时特别要注意。】
注意：在函数调用时，凡是“void”关键词都要省略，否则编译不通过。
【53.7 练习程序。】
现在把上述的4种加法函数写成一个程序，最后把程序编译后下载到坚鸿51学习板观察结果。请直接复制第十节模板程序，添加和修改main程序代码如下：
/*---C语言学习区域的开始---------------------------------------------------------------------------*/
//第1种：无输出无输入函数的声明。
void hanshu_1(void);
//第2种：无输出有输入函数的声明。
void hanshu_2(unsigned char i,unsigned char k);
//第3种：有输出无输入函数的声明。
unsigned char hanshu_3(void);
//第4种：有输出无输入函数的声明。
unsigned char hanshu_4(unsigned char r,unsigned char s);
//第1种：无输出无输入
unsigned char a;//此变量用来接收最后相加结果的和。
unsigned char g=2;
unsigned char h=3;
//第2种：无输出有输入
unsigned char b;//此变量用来接收最后相加结果的和。
//第3种：有输出无输入
unsigned char c; //此变量用来接收最后相加结果的和。
unsigned char m=2;
unsigned char n=3;
//第4种：有输出有输入
unsigned char d; //此变量用来接收最后相加结果的和。
//第1种：无输出无输入函数的定义。
void hanshu_1(void)
{
a=g+h;
}
//第2种：无输出有输入函数的定义
void hanshu_2(unsigned char i,unsigned char k)
{
b=i+k;
}
//第3种：有输出无输入函数的定义。
unsigned char hanshu_3(void)
{
unsigned char p;
p=m+n;
return p;
}
//第4种：有输出无输入函数的定义
unsigned char hanshu_4(unsigned char r,unsigned char s)
{
unsigned char t;
t=r+s;
return t;
}
void main() //主程序
{
hanshu_1(); //第1种：无输出无输入函数。
hanshu_2(2,3); //第2种：无输出有输入函数。
c=hanshu_3(); //第3种：有输出无输入函数。
d=hanshu_4(2,3); //第4种：有输出无输入函数。
GuiWdData0=a; //把a这个数值放到窗口变量0里面显示。
GuiWdData1=b; //把b这个数值放到窗口变量1里面显示。
GuiWdData2=c; //把c这个数值放到窗口变量2里面显示。
GuiWdData3=d; //把d这个数值放到窗口变量3里面显示。
/*---C语言学习区域的结束---------------------------------------------------------------------------*/
while(1)
{
initial();
key_service();
display_service();
}
}
查看运算结果的方法。如何在坚鸿51学习板上观察变量？按下S1或者S5按键即可切换显示不同的窗口，从而显示不同的变量。按下S9按键不松手就可以切换到十六进制的显示界面，松开手后会自动切换到十进制的界面。16个LED灯显示的就是当前变量的二进制数，亮代表1，灭代表0。上坚鸿51学习板观察程序执行的结果如下：
变量a为5。
变量b为5。
变量c为5。
变量d为5。
下节预告：return语句在函数中的作用。
（未完待续）
资料好！！再次的学习51了！！！
谢谢老师
第五十四节：return语句在函数中的作用以及容易被忽略的四个功能。
【54.1 return深入讲解】
“return”在英语单词中有“返回”的意思，在上一节提到，凡是“有输出函数”，函数内部必须有一个“return+变量或者常量”与之配套，表示返回的结果给外部调用者接收，这个初学者都很容易理解，容易被忽略的是return另外四个功能：
第一个是return语句隐含了立即退出的功能。退出哪？退出当前函数。只要执行到return语句，就马上退出当前函数。即使return语句身陷多层while或者for的循环中，它也毫不犹豫立即退出当前函数。
第二个是return语句可以出现在函数内的任何位置。可以出现在第一行代码，也可以出现在中间的某行代码，也可以出现在最后一行的代码，它的位置不受限制。很多初学者有个错觉，以为return只能出现在最后一行，这是错的。
第三个是return语句不仅仅可以用在“有输出函数”，也可以用在“无输出函数”，也就是可以用在前缀是void的函数里。回顾上一节，在“有输出函数”函数里，return后面紧跟一个变量或者常量，表示返回的数，但是在“无输出函数”里，因为是“无输出”，此时return后面不用跟任何变量或者常量，表示返回的是空的。此时return主要起到立即退出当前函数的作用。
第四个是return语句可以在一个函数里出现N次，次数不受限制，不一定必须只能一次。不管一个函数内有多少个return语句，只要任何一个return语句被单片机执行到，立即退出当前函数。
【54.2 中途立即退出的功能。】
下面的书写格式是合法的：
void hanshu(void)//无输出/函数的定义。
{
语句1;
return; //立即退出当前函数。
语句2;
return; //立即退出当前函数。
语句3;
return; //立即退出当前函数。
}
分析：
当hanshu此函数被调用时，单片机从“语句1”往下执行，当遇到第一个return语句后，马上退出当前函数。在此函数里，后面的“语句2”等代码永远不会被执行到。
【54.3 身陷多层while或者for的循环时的惊人表现。】
下面的书写格式是合法的：
void hanshu(void)//无输出/函数的定义。
{
语句1;
while(1)//第一个循环
{
while(1)//第二个循环中的循环
{
return; //立即退出当前函数。
}
语句2;
return; //立即退出当前函数。
}
语句3;
return; //立即退出当前函数。
}
分析：
当hanshu此函数被调用时，单片机从“语句1”往下执行，先进入第一个循环，接着进入第二个循环中的循环，然后遇到第一个return语句，马上退出当前函数。在此函数里，后面的“语句2”等代码也是永远不会被执行到。虽然表面看起来有那么多可怕的循环约束着，但是一旦碰上return语句都是浮云，立刻退出当前函数。
【54.4 “有输出函数”时是什么样子的？】
把上面例子中“无输出函数”改成“有输出函数”后：
unsigned char hanshu(void)//有输出/函数的定义。
{
unsigned char a=9;
语句1;
while(1)//第一个循环
{
while(1)//第二个循环中的循环
{
return a; //返回a变量的值，并且立即退出当前函数。
}
语句2;
return a; //返回a变量的值，并且立即退出当前函数。
}
语句3;
return a; //返回a变量的值，并且立即退出当前函数。
}
分析：
因为此函数是“有输出/函数”，所以return语句后面必须配套一个变量或者常量，而执行顺序跟前面54.3的例子是一样的。当hanshu函数被调用时，单片机从“语句1”往下执行，先进入第一个循环，接着进入第二个循环中的循环，然后遇到第一个“return a”语句，马上退出当前函数。在此函数里，后面的“语句2”等代码也是永远不会被执行到的。再一次说明了，return语句不仅有返回某数的功能，还有立即退出的重要功能。
【54.5 项目应用时，中间的return语句往往是跟if语句搭配使用的。】
前面的例子只是为了解释return语句的执行顺序和功能，实际项目中，如果中间有多个return语句，中间的return语句不可能像前面的例子那样单独使用，它往往是跟if语句一起搭配使用的，否则单独用return就没有什么意义。比如：
void hanshu(void)//无输出/函数的定义。
{
语句1;
if(某条件满足)
{
return; //立即退出当前函数。
}
语句2;
if(某条件满足)
{
return; //立即退出当前函数。
}
语句3;
}
分析：
单片机从“语句1”开始往下执行，至于在哪个“return”语句处退出当前函数，就要看哪个if的条件满不满足了，如果所有的if的条件都不满足，此函数会一直执行完最后的“语句3”才退出当前函数。
【54.6 函数和变量的命名规则。】
函数的名字和变量的名字一样，第一个字符不能是数字，必须是字母或者下划线“_”，后面紧跟的第2个字符开始可以是数字。在C语言中名字是区分大小写的。可以用下划线“_”，但是不可以用横杠“-”。名字不能跟C编译系统已经征用的关键字重名，比如不能用“unsigned ”,“char”,“static”等系统关键词，跟古代时不能跟皇帝重名一样，要避尊者讳。
【54.7 练习程序。】
写一个简单的除法函数，在除法运算中，除数不能为0，如果发现除数为0，就立即退出当前函数，并且返回运算结果默认为0。最后把程序编译后下载到坚鸿51学习板观察结果。请直接复制第十节模板程序，添加和修改main程序代码如下：
/*---C语言学习区域的开始---------------------------------------------*/
//函数的声明。
unsigned int chu_fa(unsigned int bei_chu_shu,unsigned int chu_shu);
unsigned int a;//此变量用来接收除法的运算结果。
unsigned int b;//此变量用来接收除法的运算结果。
//函数的定义。
unsigned int chu_fa(unsigned int bei_chu_shu,unsigned int chu_shu)
{
unsigned int shang;//返回的除法运算结果：商。
if(0==chu_shu) //如果除数等于0，就立即退出当前函数，并返回0
{
return 0; // 退出当前函数并且返回0.此时后面的代码不会被执行。
}
shang=bei_chu_shu/chu_shu;//除法运算的算法
return shang;//返回最后的运算结果：商。并且退出当前函数。
}
void main() //主程序
{
a=chu_fa(128,0);//函数调用。128除以0，把商返回给a变量。
b=chu_fa(128,2);//函数调用。128除以2，把商返回给b变量。
GuiWdData0=a; //把a这个数值放到窗口变量0里面显示。
GuiWdData1=b; //把b这个数值放到窗口变量1里面显示。
/*---C语言学习区域的结束---------------------------------------------*/
while(1)
{
initial();
key_service();
display_service();
}
}
查看运算结果的方法。如何在坚鸿51学习板上观察变量？按下S1或者S5按键即可切换显示不同的窗口，从而显示不同的变量。按下S9按键不松手就可以切换到十六进制的显示界面，松开手后会自动切换到十进制的界面。16个LED灯显示的就是当前变量的二进制数，亮代表1，灭代表0。上坚鸿51学习板观察程序执行的结果如下：
变量a为0。
变量b为64。
下节预告：static静态局部变量在函数中的重要作用。
（未完待续）
鸿哥V5{:lol:}
不错不错{:handshake:}
在这里也看到了这个帖子
本帖最后由 吴坚鸿 于 2016-1-17 11:52 编辑
第五十五节：static静态局部变量在函数中的重要作用。
【55.1 变量前加入static关键词后发生“化学反应”】
前面介绍了两类变量，一类全局变量，一类局部变量。定义时，在任何一类变量前面加入static关键词，变量原有的特性都会发生某些变化，此时static像化学里的催化剂，具有神奇的功能。加static关键词的书写格式如下：
static unsigned char a;//全局变量前加的static关键词
void hanshu(void)
{
static unsigned char i; //局部变量前加的static关键词
}
【55.2 在全局变量前加static】
static读作“静态”，全局变量前加static，称为静态全局变量。静态全局变量和普通全局变量的功能大体相同，仅在有效范围(作用域)方面有差异。假设整个工程有多个文件组成，普通全局变量的有效范围能覆盖全部文件，在任何一个文件里都畅通无阻。而静态全局变量只能在当前定义的那个文件里起作用，活动范围完全被限定在一个文件，彷佛被加了紧箍咒，由不得你任性。这部分的内容有个大致印象就可以，暂时不用深入研究，等以后学到多文件编程时再关注，因为我当前的程序例子只有一个源文件，还没涉及多文件编程。
【55.3 在局部变量前加static】
这是本节重点。我常把局部变量比喻宾馆的客房，客人入住时被分配在哪间客房是随机临时安排的，第二天退房时宾馆会把客房收回继续分配给下一位其他的客人，是临时公共区。而加入static后的局部变量，发生了哪些变化？加入static后的局部变量，称为静态局部变量。静态局部变量就像宾馆的VIP客户，VIP客户财大气粗，把宾馆分配的客房永远包了下来，永远不许再给其它客人入住。总结了静态局部变量的两个重要特性：
第一个，静态局部变量不会在函数调用时被初始化，它只在单片机刚上电时被编译器初始化了一次，因为它的内存模型不是被分配在“栈”，而是在全局变量同一类数据区，拥有自己唯一的地址。但是跟全局变量又有差别，全局变量的有效范围（作用域）是整个工程，而静态局部变量毕竟是“局部”，仅局限于当前函数。而普通局部变量，众所周知，每次被函数调用时，都会被重新初始化。
第二个，每次函数调用时，静态局部变量比普通局部变量少开销一条潜在的“初始化语句”，原因是普通局部变量每次被函数调用时都要重新初始化，而静态局部变量不用进行这个操作。也就是说，静态局部变量比普通局部变量的效率高一点，虽然这个“点”的时间开销微不足道，但是不留意这“点”，写程序时容易出现瑕疵。
【55.4 静态局部变量的应用场合】
静态局部变量适用在那些频繁调用的函数，比如main函数主循环while(1)里直接调用的所有函数，还有以后讲到的定时器中断函数，等等。因为静态局部变量每次被调用都不会被重新初始化，用在这类函数时就省去了每次初始化语句的时间。还有就是那些规定不能被函数初始化的场合，比如在很多用switch搭建的程序函数里，这类switch程序俗称为状态机思路。
【55.5 能用全局变量替代静态局部变量吗】
能用全局变量替代静态局部变量吗？能。哪怕在整个程序里全部用全局变量都可以。全局变量是一把牛刀，什么场合都用牛刀虽然也能解决问题，但是显得鲁莽没有条理。尽量把全局变量，普通局部变量，静态局部变量各自优势充分发挥出来才是编程之道。能用局部变量的尽量用局部变量，这样可以减少全局变量的使用。当局部变量帮分担一部分工作时，最后全局变量只起到一个作用，那就是在各函数之间传递信息。局部变量与全局变量的分工定位明确了，程序代码阅读起来就没有那么凌乱，思路也清晰很多。
【55.6 程序分析】
编写一个程序来学习刚才讲到的内容，最后把程序编译后下载到坚鸿51学习板观察结果。请直接复制第十节模板程序，添加和修改main程序代码如下：
/*---C语言学习区域的开始-----------------------------------------*/
unsigned char hanshu(void); //函数声明
unsigned char hanshu_static(void);//函数声明
unsigned char hanshu(void)//函数定义
{
unsigned char i=0; //普通局部变量，每次函数调用都被初始化为0.
i++;//i自加1
return i;
}
unsigned char hanshu_static(void)//函数定义
{
static unsigned char i=0; //静态局部变量，只在上电是此初始化语句才起作用。
i++;//i自加1
return i;
}
void main() //主程序
{
unsigned char a; //用来接收函数返回的结果。
unsigned char b;
unsigned char c;
unsigned char d; //用来接收函数返回的结果。
unsigned char e;
unsigned char f;
//下面函数内的i是普通局部变量。
a=hanshu();//函数内的i每次重新初始化为0，再自加1，所以a等于1。
b=hanshu();//函数内的i每次重新初始化为0，再自加1，所以b等于1。
c=hanshu();//函数内的i每次重新初始化为0，再自加1，所以c等于1。
//下面函数内的i是静态局部变量，第一次上电后默认为0，就不会再被初始化，
d=hanshu_static(); //d由0自加1后等于1。
e=hanshu_static(); //e由1自加1后等于2。
f=hanshu_static(); //f由2自加1后等于3。
GuiWdData0=a; //把a这个变量放到窗口变量0里面显示，下同。
GuiWdData1=b;
GuiWdData2=c;
GuiWdData3=d;
GuiWdData4=e;
GuiWdData5=f;
/*---C语言学习区域的结束----------------------------------------*/
while(1)
{
initial();
key_service();
display_service();
}
}
查看运算结果的方法。如何在坚鸿51学习板上观察变量？按下S1或者S5按键即可切换显示不同的窗口，从而显示不同的变量。按下S9按键不松手就可以切换到十六进制的显示界面，松开手后会自动切换到十进制的界面。16个LED灯显示的就是当前变量的二进制数，亮代表1，灭代表0。上坚鸿51学习板观察程序执行的结果如下：
变量a为1。
变量b为1。
变量c为1。
变量d为1。
变量e为2。
变量f 为3。
【55.7 为什么中止此连载帖的更新了】
我以前一直想写两本书，一本讲单片机入门基础，一本讲单片机程序框架。现在发现，单片机基础和程序框架并没有明显的分水岭，基础中有框架，框架中有基础，应该合二为一，读起来才会连贯舒畅。所以我决定中止当前已写到55节的《从业十年，教你单片机入门基础》连载帖，另外新开一个连载帖叫《从单片机基础到程序框架（连载）》，希望大家关注我的新连载帖。
再提一下我2014年写的《从业将近十年，手把手教你单片机程序框架》，一方面受到很多网友的好评，另一方面也有一些热心网友提出了宝贵的意见，我今天看来，确实还有一些可待改进的地方。本来计划在2017年重写《……单片机程序框架》那个老帖，现在看来不用那么折腾了，只要把《……单片机程序框架》的内容也整合到新开的帖子里就可以了，这样对我也比较省事。我的时间计划是，先花4年时间写一个初稿，然后再花2年时间重写一次，最后再花1年时间整理成书，整个过程大概7年时间左右，今年是2016年，估计到2023年左右就可以新书出版了。
感谢各位朋友的支持。
感谢前辈，受益匪浅
楼主，你好！看你贴子前面说你在开发运动控制相关系统，请问那有一那些书是和运动控制相关的?请推存几本，我对这个比较感兴趣！谢谢！
吴坚鸿 发表于 2015-3-14 09:33
第四节：平台软件和编译器软件的简介。
C语言代码写在哪里，谁负责把它翻译成Hex格式机器码？这就涉 ...
keil4有没有 “C STM32编译器”
keil4有C51编译器，我类比一下
谢谢分享 谢谢
谢谢楼主的分享
这种孜孜不倦的精神让人敬佩
楼主可以考虑出个视频