从业十年，教你单片机入门基础。（连载）

jianhong_wu

第二十六节：乘法运算的溢出。

     乘法的溢出规律跟加法的溢出规律是一样的。举一个例子如下：

1.    unsigned char k=30;
   
2.    unsigned char n=10;
   
3.    unsigned char a;
   
4.    a=k*n;  

复制代码

分析：

k和n相乘，相当于30乘以10，运算结果是300（十六进制是0x012c）保存在一个隐藏中间变量，根据前面加法运算的规律，我猜测这个隐藏中间变量可能是unsigned int类型，然后再把这个中间变量赋值给单字节变量a，a只能接收十六进制的低8位字节0x2c，所以运算后a的数值由于溢出变成了十六进制的0x2c（十进制是44）。

由于乘法的溢出规律跟加法的溢出规律是一样的，所以不再多举例子。在实际项目中，为了避免一不小心就溢出的问题，我强烈建议，不管加减乘除，凡是参与运算的变量全部都要转化成unsigned long变量，转化的方法也跟加减运算的转换方法一致，不再详细解决这方面的内容。

现在编写一个程序来练习刚才讲到的内容，最后把程序编译后下载到坚鸿51学习板观察结果。请直接复制第十节模板程序，修改的main程序代码如下：

1. void main() //主程序
   
2. {
   
3. /*---C语言学习区域的开始-----------------------------------------------------------------
   
4. 
   
5. ----------*/
   
6.       
   
7.    unsigned char k=30;
   
8.    unsigned char n=10;
   
9.    unsigned char a;
   
10. 
    
11.    a=k*n;  
    
12. 
    
13.    GuiWdData0=a;   //把变量a这个数值放到窗口变量0里面显示
    
14. 
    
15. 
    
16. 
    
17.         
    
18. /*---C语言学习区域的结束-----------------------------------------------------------------
    
19. 
    
20. ----------*/
    
21.    while(1)  
    
22.    {
    
23.       initial();
    
24.       key_service();
    
25.       display_service();
    
26.    }
    
27. 
    
28. }
    

复制代码

    查看运算结果的方法。如何在坚鸿51学习板上观察变量？按下S1或者S5按键即可切换显示不同的窗口，从而显示不同的变量。按下S9按键不松手就可以切换到十六进制的显示界面，松开手后会自动切换到十进制的界面。上坚鸿51学习板观察程序执行的结果如下：

       变量a为0x2c(十进制是44)。

     下节预告：除法运算的常见格式。

（未完待续）

jianhong_wu

第二十七节：整除求商的运算。

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。比如：

1. a=23 /y;  //假设除数变量y里面是0，那么a的结果是255(十六进制的0xff)。
   
2. b=23 /0;  //除数是常量0，那么b的结果是1。

复制代码

（2）当被除数小于“除数”时。商等于0。比如：

1. c=7 / 10;  //c的结果是0。

复制代码

（3）当被除数等于“除数”时。商等于1。比如：

1. d=10/ 10;  //d的结果是1。

复制代码

（4）当被除数大于“除数”时。商大于0。

比如：

1. e=10/ 4;  //e的结果是2。
   
2. f=10/ 3;  //f的结果是3。

复制代码

（5）自除运算的简写。跟前面加减法一样，当“被除数”是“保存变量”时，存在自除运算的简写。

“保存变量”=“保存变量” /  “除数” ;

上述自除运算的简写如下：

“保存变量” / =“除数” ;

比如：

1. g/=5;  //相当于g=g/5;

复制代码

加减法有自加1“++g”和自减1“g--”的特殊写法，但是除法不存在这种自除1的特殊写法，因为一个数除以1还是等于它本身，所以自除1没有任何意义，因此C语言语法中没有这种写法。

   （6）除法的溢出规律跟加法的溢出规律是一样的，所以不再多举例子。在实际项目中，为了避免一不小心就溢出的问题，我强烈建议，不管加减乘除，凡是参与运算的变量全部都要转化成unsigned long变量，转化的方法也跟加减运算的转换方法一致，不再详细讲解这方面的内容。

现在编写一个程序来练习刚才讲到的内容，最后把程序编译后下载到坚鸿51学习板观察结果。请直接复制第十节模板程序，修改的main程序代码如下：

1. 
   
2. void main() //主程序
   
3. {
   
4. /*---C语言学习区域的开始---------------------------------------------------------------------------*/
   
5.         
   
6.   unsigned char a;
   
7.   unsigned char b;
   
8.   unsigned char c;
   
9.   unsigned char d;
   
10.   unsigned char e;
    
11.   unsigned char f;
    
12.         unsigned char g=10;  //初始化为10
    
13.         unsigned char y=0; //除数变量初始化为0。
    
14.         a=23/y;
    
15.         b=23/0;
    
16.         c=7/10;
    
17.         d=10/10;
    
18.         e=10/4;
    
19.         f=10/3;
    
20.         g/=5;  //相当于g=g/5;
    
21.        
    
22.   GuiWdData0=a;   //把a这个变量放到窗口变量0里面显示
    
23.   GuiWdData1=b;   //把b这个变量放到窗口变量1里面显示
    
24.   GuiWdData2=c;   //把c这个变量放到窗口变量2里面显示
    
25.   GuiWdData3=d;   //把d这个变量放到窗口变量3里面显示
    
26.   GuiWdData4=e;   //把e这个变量放到窗口变量4里面显示
    
27.   GuiWdData5=f;   //把f这个变量放到窗口变量5里面显示
    
28.   GuiWdData6=g;   //把g这个变量放到窗口变量5里面显示
    
29.         
    
30. /*---C语言学习区域的结束---------------------------------------------------------------------------*/
    
31.    while(1)  
    
32.    {
    
33.                   initial();
    
34.       key_service();
    
35.       display_service();
    
36.    }
    
37. 
    
38. }

复制代码

    查看运算结果的方法。如何在坚鸿51学习板上观察变量？按下S1或者S5按键即可切换显示不同的窗口，从而显示不同的变量。按下S9按键不松手就可以切换到十六进制的显示界面，松开手后会自动切换到十进制的界面。上坚鸿51学习板观察程序执行的结果如下：

     变量a为255(十六进制是0xff)。

     变量b为1。

     变量c为0。

     变量d为1。

    变量e为2。

    变量f为3。

    变量g为2。

     下节预告：整除求余的运算。

（未完待续）

jianhong_wu

第二十八节：整除求余的运算。

    求余跟上一节讲的求商都是属于整除运算，区别是：求余返回余数，求商返回商。整除求余的余数有一个很明显的规律：余数永远小于除数（除数不为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。这就是本实验的意义所在。

    比如：

1. a=23%y;  //假设除数变量y里面是0，那么a的结果是23。
   
2. b=23%0;  //除数是常量0，那么b的结果是1。
   
3. b=g%0;  //这种特殊情况编译不通过：“被除数”是变量，而“除数”是常量的0。

复制代码

（2）当被除数小于“除数”时。余数等于被除数本身。比如：

1. c=7%10;  //c的结果是7。

复制代码

（3）当被除数等于“除数”时。余数等于0。比如：

1. d=10%10;  //d的结果是0。

复制代码

（4）当被除数大于“除数”时。余数也必然小于“除数”。

比如：

1. e=10%4;  //e的结果是2。
   
2. f=10% 3;  //f的结果是1。

复制代码

（5）自除求余运算的简写。跟前面加减法一样，当“被除数”是“保存变量”时，存在自除求余运算的简写。

“保存变量”=“保存变量” % “除数” ;

上述自除运算的简写如下：

“保存变量” % =“除数” ;

比如：

1. g%=5;  //相当于g=g%5;

复制代码

加减法有自加1“++g”和自减1“g--”的特殊写法，但是除法不存在这种自除1的特殊写法，因为一个数除以1还是等于它本身，所以自除1没有任何意义，因此C语言语法中没有这种写法。

   （6）除法的溢出规律跟加法的溢出规律是一样的，所以不再多举例子。在实际项目中，为了避免一不小心就溢出的问题，我强烈建议，不管加减乘除，凡是参与运算的变量全部都要转化成unsigned long变量，转化的方法也跟加减运算的转换方法一致，不再详细讲解这方面的内容。

现在编写一个程序来练习刚才讲到的内容，最后把程序编译后下载到坚鸿51学习板观察结果。请直接复制第十节模板程序，修改的main程序代码如下：

1. void main() //主程序
   
2. {
   
3. /*---C语言学习区域的开始---------------------------------------------------------------------------*/
   
4.         
   
5.   unsigned char a;
   
6.   unsigned char b;
   
7.   unsigned char c;
   
8.   unsigned char d;
   
9.   unsigned char e;
   
10.   unsigned char f;
    
11.         unsigned char g=10;  //初始化为10
    
12.         unsigned char y=0; //除数变量初始化为0。
    
13.         a=23%y;
    
14.         b=23%0;
    
15.         //b=g%0;  //这种特殊情况编译不通过：“被除数”是变量，而“除数”是常量的0。
    
16.         c=7%10;
    
17.         d=10%10;
    
18.         e=10%4;
    
19.         f=10%3;
    
20.         g%=5;  //相当于g=g%5;
    
21.        
    
22.   GuiWdData0=a;   //把a这个变量放到窗口变量0里面显示
    
23.   GuiWdData1=b;   //把b这个变量放到窗口变量1里面显示
    
24.   GuiWdData2=c;   //把c这个变量放到窗口变量2里面显示
    
25.   GuiWdData3=d;   //把d这个变量放到窗口变量3里面显示
    
26.   GuiWdData4=e;   //把e这个变量放到窗口变量4里面显示
    
27.   GuiWdData5=f;   //把f这个变量放到窗口变量5里面显示
    
28.   GuiWdData6=g;   //把g这个变量放到窗口变量5里面显示
    
29.         
    
30. /*---C语言学习区域的结束---------------------------------------------------------------------------*/
    
31.    while(1)  
    
32.    {
    
33.                   initial();
    
34.       key_service();
    
35.       display_service();
    
36.    }
    
37. 
    
38. }

复制代码

    查看运算结果的方法。如何在坚鸿51学习板上观察变量？按下S1或者S5按键即可切换显示不同的窗口，从而显示不同的变量。按下S9按键不松手就可以切换到十六进制的显示界面，松开手后会自动切换到十进制的界面。上坚鸿51学习板观察程序执行的结果如下：

     变量a为23。

     变量b为1。

     变量c为7。

     变量d为0。

    变量e为2。

    变量f为1。

    变量g为0。

     下节预告：利用“整除求商求余”来提取一个数的个十百千位。

（未完待续）

jianhong_wu

第二十九节：利用“整除求商求余”来拆分提取一个数的个十百千位。

上两节讲了整除的求商求余运算符，这两个运算不仅能用在数学运算中，还可以用来拆分提取一个数的个十百千位。提取这些位有什么用呢？因为在以后的单片机显示程序中，不管是液晶屏还是数码管，必须用到这种提取算法，先把一个数的个十百千位一个个拆分提取出来，然后再送到显示屏上显示，所以这种算法很常见和实用。上述提到的“个，十，百，千”位只是一个虚数，具体是多少应该根据实际项目而定，也有可能是“个，十，百，千，万，十万，百万...”等位，但是处理的思路和方法都是一致的。

拆分提取的思路。比如8562这个数，千位是8，百位是5，十位是6，个位是2。可以依次看成是：

1. 8=8562/1000;
   
2. 5=562/100;
   
3. 6=62/10;
   
4. 2=2/1;

复制代码

上述用到了整除求商，但是562,62,2又是如何通过8562分解得到的呢？需要用到整除求余：

1. 562=8562%1000;
   
2. 62=8562%100;
   
3. 2=8562%10;

复制代码

最后综合在一起,连在一起写：

1. 8=8562/1000;
   
2. 5=8562%1000/100;
   
3. 6=8562%100/10;
   
4. 2=8562%10/1;

复制代码

因为我们预先知道了这个数最大位是千位，所以千位直接整除1000求商就可以了。实际项目中，我们只是用某个变量，而这个变量的大小我们并不知道具体是什么，它的最大位可能并不止千位，也有可能是万位，所以需要把上述最高位的千位也做一下整除10000求余数，然后在整除1000求商，最后整理如下：

1. 8=8562%10000/1000;
   
2. 5=8562%1000/100;
   
3. 6=8562%100/10;
   
4. 2=8562%10/1;

复制代码

大家仔细观察和品味一下，很容易发现规律和原因，如果求万，十万，百万，也是用一样的方法。多提醒一句，根据我的经验，有一些单片机的C编译器可能不支持long类型数据的求余求商连写在一起，那么就要用一个中间变量分两步走，先求余，再求商，分开来操作。比如：

1. 8=8562%10000/1000;

复制代码

分成两步走：

1. a=8562%10000;
   
2. a=a/1000;

复制代码

上述的变量a就是引入的中间变量。

现在编写一个程序来练习刚才讲到的内容，最后把程序编译后下载到坚鸿51学习板观察结果。请直接复制第十节模板程序，修改的main程序代码如下：

1. void main() //主程序
   
2. {
   
3. /*---C语言学习区域的开始---------------------------------------------------------------------------*/
   
4.         
   
5.   unsigned char a;
   
6.   unsigned char b;
   
7.   unsigned char c;
   
8.   unsigned char d;
   
9.         unsigned int  x=8562;  //初始化为8562，注意必须是int类型以上，不能是char类型，char最大范围是255。
   
10. 
    
11.   a=x%10000/1000;  //拆分提取千位
    
12.   b=x%1000/100;    //拆分提取百位
    
13.   c=x%100/10;      //拆分提取十位
    
14.   d=x%10/1;        //拆分提取个位
    
15. 
    
16. 
    
17.        
    
18.   GuiWdData0=a;   //把a这个变量放到窗口变量0里面显示
    
19.   GuiWdData1=b;   //把b这个变量放到窗口变量1里面显示
    
20.   GuiWdData2=c;   //把c这个变量放到窗口变量2里面显示
    
21.   GuiWdData3=d;   //把d这个变量放到窗口变量3里面显示
    
22. 
    
23.         
    
24. /*---C语言学习区域的结束---------------------------------------------------------------------------*/
    
25.    while(1)  
    
26.    {
    
27.       initial();
    
28.       key_service();
    
29.       display_service();
    
30.    }
    
31. 
    
32. }

复制代码

    查看运算结果的方法。如何在坚鸿51学习板上观察变量？按下S1或者S5按键即可切换显示不同的窗口，从而显示不同的变量。按下S9按键不松手就可以切换到十六进制的显示界面，松开手后会自动切换到十进制的界面。上坚鸿51学习板观察程序执行的结果如下：

     变量a为8。

     变量b为5。

     变量c为6。

     变量d为2。

     下节预告：逻辑运算符的“与”运算。

（未完待续）

jianhong_wu

第三十节：逻辑运算符的“与”运算。

       单片机任何数字的底层运算都是以二进制的形式进行，前面讲的加减乘除也不例外。只不过加减乘除是生活常用的运算，任意给两个十进制的数据让单片机运算，我们都可以凭借既有的生活经验通过口算或者笔算来计算出结果，不需要刻意模拟单片机底层的二进制运算。但是本节讲的“与”运算却不行，它是为二进制而生的，若想使用它，必先把参与运算的数据双双转换成二进制格式的数据，你才能分析“与”运算的含义和规律。“与”运算是以位来进行运算的，位就是代表二进制中的每一位，每一个位只能是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程序代码如下：

1. void main() //主程序
   
2. {
   
3. /*---C语言学习区域的开始---------------------------------------------------------------------------*/
   
4.         
   
5.   unsigned char a;
   
6.   unsigned char b=85;  //十六进制是0x55，二进制是01010101。
   
7. 
   
8.   a=12&9;
   
9.   b=b&0xfe;   
   
10. 
    
11. 
    
12.   GuiWdData0=a;   //把a这个变量放到窗口变量0里面显示
    
13.   GuiWdData1=b;   //把b这个变量放到窗口变量1里面显示
    
14. 
    
15.         
    
16. /*---C语言学习区域的结束---------------------------------------------------------------------------*/
    
17.    while(1)  
    
18.    {
    
19.       initial();
    
20.       key_service();
    
21.       display_service();
    
22.    }
    
23. 
    
24. }
    

复制代码

        查看运算结果的方法。如何在坚鸿51学习板上观察变量？按下S1或者S5按键即可切换显示不同的窗口，从而显示不同的变量。按下S9按键不松手就可以切换到十六进制的显示界面，松开手后会自动切换到十进制的界面。16个LED灯显示的就是当前变量的二进制数，亮代表1，灭代表0。上坚鸿51学习板观察程序执行的结果如下：

        变量a为8（十六进制是0x08，二进制是00001000）。

        变量b为84（十六进制是0x54，二进制是01010100）。

        下节预告：逻辑运算符的“或”运算。

（未完待续）

jianhong_wu

第三十一节：逻辑运算符的“或”运算。

       “或”运算是以位为单位进行运算的。位是指二进制中的某一位，位只能是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程序代码如下：

1. void main() //主程序
   
2. {
   
3. /*---C语言学习区域的开始---------------------------------------------------------------------------*/
   
4.         
   
5.   unsigned char a;
   
6.   unsigned char b=84;  //十六进制是0x54，二进制是01010100。
   
7. 
   
8.   a=12|9;
   
9.   b=b|0x01;   
   
10. 
    
11. 
    
12.   GuiWdData0=a;   //把a这个变量放到窗口变量0里面显示
    
13.   GuiWdData1=b;   //把b这个变量放到窗口变量1里面显示
    
14. 
    
15.         
    
16. /*---C语言学习区域的结束---------------------------------------------------------------------------*/
    
17.    while(1)  
    
18.    {
    
19.       initial();
    
20.       key_service();
    
21.       display_service();
    
22.    }
    
23. 
    
24. }

复制代码

       查看运算结果的方法。如何在坚鸿51学习板上观察变量？按下S1或者S5按键即可切换显示不同的窗口，从而显示不同的变量。按下S9按键不松手就可以切换到十六进制的显示界面，松开手后会自动切换到十进制的界面。16个LED灯显示的就是当前变量的二进制数，亮代表1，灭代表0。上坚鸿51学习板观察程序执行的结果如下：

      变量a为13（十六进制是0x0D，二进制是00001101）。

      变量b为85（十六进制是0x55，二进制是01010101）。

      下节预告：逻辑运算符的“异或”运算。

（未完待续）

jianhong_wu

第三十二节：逻辑运算符的“异或”运算。

       “异或”运算是以位为单位进行运算的。位是指二进制中的某一位，位只能是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程序代码如下：

1. 
   
2. void main() //主程序
   
3. {
   
4. /*---C语言学习区域的开始---------------------------------------------------------------------------*/
   
5.         
   
6.   unsigned char a;
   
7. 
   
8. 
   
9.   a=12^9;
   
10. 
    
11. 
    
12.   GuiWdData0=a;   //把a这个变量放到窗口变量0里面显示
    
13. 
    
14.         
    
15. /*---C语言学习区域的结束---------------------------------------------------------------------------*/
    
16.    while(1)  
    
17.    {
    
18.       initial();
    
19.       key_service();
    
20.       display_service();
    
21.    }
    
22. 
    
23. }

复制代码

         查看运算结果的方法。如何在坚鸿51学习板上观察变量？按下S1或者S5按键即可切换显示不同的窗口，从而显示不同的变量。按下S9按键不松手就可以切换到十六进制的显示界面，松开手后会自动切换到十进制的界面。16个LED灯显示的就是当前变量的二进制数，亮代表1，灭代表0。上坚鸿51学习板观察程序执行的结果如下：

        变量a为5（十六进制是0x05，二进制是00000101）。

        下节预告：逻辑运算符的“按位取反”运算。

（未完待续）

jianhong_wu

第三十三节：逻辑运算符的“按位取反”和“非”。

       “按位取反”运算的符号是波浪符号“~”。运算规律是：针对某个数的“按位取反”，先将其展开成二进制的格式，然后每个位取反，所谓取反就是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程序代码如下：

1. 
   
2. void main() //主程序
   
3. {
   
4. /*---C语言学习区域的开始---------------------------------------------------------------------------*/
   
5.         
   
6. 
   
7.   unsigned char a=5;
   
8.   unsigned char b=5;
   
9.   unsigned char c=0;
   
10.   unsigned char d=0;
    
11. 
    
12.   a=~a;
    
13.   b=!b;
    
14. 
    
15. 
    
16.   c=~c;
    
17.   d=!d;
    
18. 
    
19.   GuiWdData0=a;   //把a这个变量放到窗口变量0里面显示
    
20.   GuiWdData1=b;   //把a这个变量放到窗口变量1里面显示
    
21.   GuiWdData2=c;   //把a这个变量放到窗口变量2里面显示
    
22.   GuiWdData3=d;   //把a这个变量放到窗口变量3里面显示   
    
23. 
    
24. 
    
25. /*---C语言学习区域的结束---------------------------------------------------------------------------*/
    
26.    while(1)  
    
27.    {
    
28.                   initial();
    
29.       key_service();
    
30.       display_service();
    
31.    }
    
32. 
    
33. }
    

复制代码

       查看运算结果的方法。如何在坚鸿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）。

       下节预告：移位运算的左移。

（未完待续）

jianhong_wu

第三十四节：移位运算的左移。

        前面讲的“与，或，异或”运算，漏讲了它们的简写格式的内容，在本节开始之前先把这部分内容补上。在“与，或，异或”这些运算中，当赋值语句左边的“保存变量”是参与运算的变量本身时，也存在简写的语法格式，比如：

      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程序代码如下：

1. 
   
2. void main() //主程序
   
3. {
   
4. /*---C语言学习区域的开始---------------------------------------------------------------------------*/
   
5. 
   
6. 
   
7. unsigned char a=5;
   
8. unsigned char b=5;
   
9. 
   
10. unsigned char H=0x12; //单字节
    
11. unsigned char L=0x34; //单字节
    
12. unsigned int c; //双字节
    
13. 
    
14. a=a<<1; //a左移1位，从原来的5变成了10.
    
15. b=b<<2; //b左移2位，从原来的5变成了20.
    
16. 
    
17. 
    
18. c=H; //c的低8位被H覆盖，也就是此时c的低8位得到了H的各位值。
    
19. c=c<<8; //及时把c的低8位移动到高8位，同时c原来的低8位被填入0
    
20. c=c+L; //此时c再加L，c的低8位就L的值。此时c得到了H和L合并而来的值。
    
21. 
    
22. 
    
23. GuiWdData0=a; //把a这个变量放到窗口变量0里面显示
    
24. GuiWdData1=b; //把b这个变量放到窗口变量1里面显示
    
25. GuiWdData2=c; //把c这个变量放到窗口变量2里面显示
    
26. 
    
27. 
    
28. 
    
29. /*---C语言学习区域的结束---------------------------------------------------------------------------*/
    
30. while(1)
    
31. {
    
32. initial();
    
33. key_service();
    
34. display_service();
    
35. }
    
36. 
    
37. }
    
38. 
    

复制代码

        查看运算结果的方法。如何在坚鸿51学习板上观察变量？按下S1或者S5按键即可切换显示不同的窗口，从而显示不同的变量。按下S9按键不松手就可以切换到十六进制的显示界面，松开手后会自动切换到十进制的界面。16个LED灯显示的就是当前变量的二进制数，亮代表1，灭代表0。上坚鸿51学习板观察程序执行的结果如下：

        变量a为10 （十六进制是0x0A，二进制是00001010）。

        变量b为20（十六进制是0x14，二进制是00010100）。

        变量c为4660（十六进制是0x1234，二进制是0001 0010 0011 0100）。

        下节预告：移位运算的右移。

（未完待续）

jianhong_wu

第三十五节：移位运算的右移。

        右移的运算符号是“>>”，语法格式如下：

        保存变量=被移数>>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程序代码如下：

1. 
   
2. void main() //主程序
   
3. {
   
4. /*---C语言学习区域的开始---------------------------------------------------------------------------*/
   
5. 
   
6. unsigned char a=5;
   
7. unsigned char b=5;
   
8. 
   
9. 
   
10. unsigned char H; //单字节
    
11. unsigned char L; //单字节
    
12. unsigned int c=0x1234; //双字节
    
13. 
    
14. unsigned int d;
    
15. 
    
16. a=a>>1;
    
17. b=b>>2;
    
18. 
    
19. L=c; //c的低8位直接赋值给单字节的L
    
20. H=c>>8; //c先把高8位右移到低8位，然后再把这8位数据赋值给H
    
21. 
    
22. //执行上述语句后，此时的c变量的数值是多少呢？
    
23. //答案是0x1234,因为只要没有赋值给它自己，就不会改变它自己.
    
24. 
    
25. d=c; //此时d就等于c，是十六进制的0x1234.十进制是4660
    
26. 
    
27. GuiWdData0=a; //把a这个变量放到窗口变量0里面显示
    
28. GuiWdData1=b; //把b这个变量放到窗口变量1里面显示
    
29. GuiWdData2=H; //把H这个变量放到窗口变量2里面显示
    
30. GuiWdData3=L; //把L这个变量放到窗口变量3里面显示
    
31. GuiWdData4=d; //把d这个变量放到窗口变量4里面显示
    
32. 
    
33. /*---C语言学习区域的结束---------------------------------------------------------------------------*/
    
34. while(1)
    
35. {
    
36. initial();
    
37. key_service();
    
38. display_service();
    
39. }
    
40. 
    
41. }
    
42. 
    

复制代码

        查看运算结果的方法。如何在坚鸿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）。

     下节预告：括号改变优先级。

（未完待续）

jianhong_wu

第三十六节：括号改变优先级。

        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程序代码如下：

1. 
   
2. void main() //主程序
   
3. {
   
4. /*---C语言学习区域的开始---------------------------------------------------------------------------*/
   
5.         
   
6.   unsigned char a=0x01;
   
7.   unsigned char b=0x01;
   
8. 
   
9.   unsigned char c=0x02;
   
10.   unsigned char d=0x02;
    
11. 
    
12. 
    
13.   a=(a<<2)+5;  //a左移2位后变成4，再加5等于9
    
14.   b=b<<(2+5);  //2加5等于7，b再左移动7位等于128
    
15. 
    
16.   c=(1+3)*c;  //1加3等于4，再乘以变量c等于8
    
17.   d=1+(3*d);  //3乘以d等于6，再加1等于7
    
18. 
    
19.         
    
20.   GuiWdData0=a;   //把a这个变量放到窗口变量0里面显示
    
21.   GuiWdData1=b;   //把b这个变量放到窗口变量1里面显示
    
22.   GuiWdData2=c;   //把c这个变量放到窗口变量2里面显示
    
23.   GuiWdData3=d;   //把d这个变量放到窗口变量3里面显示
    
24. 
    
25.         
    
26. /*---C语言学习区域的结束---------------------------------------------------------------------------*/
    
27.    while(1)  
    
28.    {
    
29.       initial();
    
30.       key_service();
    
31.       display_service();
    
32.    }
    
33. 
    
34. }
    

复制代码

        查看运算结果的方法。如何在坚鸿51学习板上观察变量？按下S1或者S5按键即可切换显示不同的窗口，从而显示不同的变量。按下S9按键不松手就可以切换到十六进制的显示界面，松开手后会自动切换到十进制的界面。16个LED灯显示的就是当前变量的二进制数，亮代表1，灭代表0。上坚鸿51学习板观察程序执行的结果如下：

       变量a为9。

       变量b为128。

       变量c为8。

       变量d为7。

      下节预告：if判断语句和等于关系符“==”。

     （未完待续）

jianhong_wu

第三十七节：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程序代码如下：

1. 
   
2. void main() //主程序
   
3. {
   
4. /*---C语言学习区域的开始---------------------------------------------------------------------------*/
   
5.         
   
6.   unsigned char x=2;
   
7.   unsigned char y=0;
   
8.   unsigned char a=0;  //此变量统计有多少条语句是真的
   
9. 
   
10.   if(1)      //常量大于0，因此为真
    
11.   {
    
12.      a=a+1;  //a由0自加1后变成1。
    
13.   }
    
14. 
    
15. 
    
16.   if(0)   //常量等于0，因此为假
    
17.   {
    
18.      a=a+1;  //由于条件为假，这条语句没有被执行，因此此时a仍然是1
    
19.   }
    
20. 
    
21. 
    
22.   if(15)     //常量大于0，因此为真
    
23.   {
    
24.      a=a+1;  //a由1自加1后变成2。
    
25.   }
    
26. 
    
27. 
    
28. 
    
29.   if(x)     //变量x为2，大于0，因此为真
    
30.   {
    
31.      a=a+1;  //a由,2自加1后变成3。
    
32.   }
    
33. 
    
34. 
    
35.   if(y)     //变量y为0，等于0，因此为假
    
36.   {
    
37.      a=a+1;  //由于条件为假，这条语句没有被执行，因此此时a仍然是3
    
38.   }
    
39.         
    
40.   GuiWdData0=a;   //把a这个变量放到窗口变量0里面显示
    
41. 
    
42.         
    
43. /*---C语言学习区域的结束---------------------------------------------------------------------------*/
    
44.    while(1)  
    
45.    {
    
46.       initial();
    
47.       key_service();
    
48.       display_service();
    
49.    }
    
50. 
    
51. }
    

复制代码

         查看运算结果的方法。如何在坚鸿51学习板上观察变量？按下S1或者S5按键即可切换显示不同的窗口，从而显示不同的变量。按下S9按键不松手就可以切换到十六进制的显示界面，松开手后会自动切换到十进制的界面。16个LED灯显示的就是当前变量的二进制数，亮代表1，灭代表0。上坚鸿51学习板观察程序执行的结果如下：

         变量a为3。

         下节预告：等于关系符“==”和不等于关系符“!=”。

（未完待续）

jianhong_wu

第三十八节：等于关系符“==”和不等于关系符“!=”。

       上一节讲了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程序代码如下：

1. 
   
2. void main() //主程序
   
3. {
   
4. /*---C语言学习区域的开始---------------------------------------------------------------------------*/
   
5.   unsigned char x1=90; //给定的第1个数     
   
6.   unsigned char x2=65; //给定的第2个数   
   
7.   unsigned char x3=85; //给定的第3个数   
   
8.   unsigned char x4=79; //给定的第4个数   
   
9.   unsigned char x5=95; //给定的第5个数   
   
10.   unsigned char x6=65; //给定的第6个数   
    
11.   unsigned char x7=75; //给定的第7个数   
    
12.   unsigned char x8=85; //给定的第8个数  
    
13. 
    
14.   unsigned char a=0; //统计等于85的变量总数
    
15.   unsigned char b=0; //统计不等于75的变量总数
    
16. 
    
17.   if(85==x1)  //把常量85放在等于号的左边
    
18.   {
    
19.      a++;   //相当于a=a+1，用来统计等于85的总数
    
20.   }
    
21. 
    
22.   if(85==x2)  //把常量85放在等于号的左边
    
23.   {
    
24.      a++;   //相当于a=a+1，用来统计等于85的总数
    
25.   }
    
26. 
    
27. 
    
28.   if(85==x3)  //把常量85放在等于号的左边
    
29.   {
    
30.      a++;   //相当于a=a+1，用来统计等于85的总数
    
31.   }
    
32. 
    
33. 
    
34.   if(85==x4)  //把常量85放在等于号的左边
    
35.   {
    
36.      a++;   //相当于a=a+1，用来统计等于85的总数
    
37.   }
    
38. 
    
39. 
    
40.   if(85==x5)  //把常量85放在等于号的左边
    
41.   {
    
42.      a++;   //相当于a=a+1，用来统计等于85的总数
    
43.   }
    
44. 
    
45. 
    
46.   if(85==x6)  //把常量85放在等于号的左边
    
47.   {
    
48.      a++;   //相当于a=a+1，用来统计等于85的总数
    
49.   }
    
50. 
    
51. 
    
52.   if(85==x7)  //把常量85放在等于号的左边
    
53.   {
    
54.      a++;   //相当于a=a+1，用来统计等于85的总数
    
55.   }
    
56. 
    
57. 
    
58.   if(85==x8)  //把常量85放在等于号的左边
    
59.   {
    
60.      a++;   //相当于a=a+1，用来统计等于85的总数
    
61.   }
    
62. 
    
63. 
    
64. 
    
65.   if(75!=x1)  //把常量75放在不等于号的左边
    
66.   {
    
67.      b++;   //相当于b=b+1，用来统计不等于75的总数
    
68.   }
    
69. 
    
70. 
    
71.   if(75!=x2)  //把常量75放在不等于号的左边
    
72.   {
    
73.      b++;   //相当于b=b+1，用来统计不等于75的总数
    
74.   }
    
75. 
    
76. 
    
77. 
    
78.   if(75!=x3)  //把常量75放在不等于号的左边
    
79.   {
    
80.      b++;   //相当于b=b+1，用来统计不等于75的总数
    
81.   }
    
82. 
    
83. 
    
84. 
    
85.   if(75!=x4)  //把常量75放在不等于号的左边
    
86.   {
    
87.      b++;   //相当于b=b+1，用来统计不等于75的总数
    
88.   }
    
89. 
    
90. 
    
91. 
    
92. 
    
93.   if(75!=x5)  //把常量75放在不等于号的左边
    
94.   {
    
95.      b++;   //相当于b=b+1，用来统计不等于75的总数
    
96.   }
    
97. 
    
98. 
    
99.   if(75!=x6)  //把常量75放在不等于号的左边
    
100.   {
     
101.      b++;   //相当于b=b+1，用来统计不等于75的总数
     
102.   }
     
103. 
     
104. 
     
105. 
     
106.   if(75!=x7)  //把常量75放在不等于号的左边
     
107.   {
     
108.      b++;   //相当于b=b+1，用来统计不等于75的总数
     
109.   }
     
110. 
     
111. 
     
112. 
     
113.   if(75!=x8)  //把常量75放在不等于号的左边
     
114.   {
     
115.      b++;   //相当于b=b+1，用来统计不等于75的总数
     
116.   }
     
117. 
     
118.       
     
119.   GuiWdData0=a;   //把a这个变量放到窗口变量0里面显示
     
120.   GuiWdData1=b;   //把b这个变量放到窗口变量1里面显示
     
121.   
     
122.         
     
123. /*---C语言学习区域的结束---------------------------------------------------------------------------*/
     
124.    while(1)  
     
125.    {
     
126.                   initial();
     
127.       key_service();
     
128.       display_service();
     
129.    }
     
130. 
     
131. }

复制代码

         查看运算结果的方法。如何在坚鸿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个）

         下节预告：大于关系符“>”和大于等于关系符“>=”。

（未完待续）

jianhong_wu

第三十九节：大于关系符“>”和大于等于关系符“>=”。

        一. 再复习一遍if语句的通用格式：

if(条件)

{

    语句1;

    语句2;

}

语句3;

……

语句N;

       上述格式的含义是：如果if语句里的条件满足（为真），就执行大括号里的语句1和语句2；如果条件不满足（为假），直接跳过大括号里的语句1和语句2，从语句3开始继续往下执行。

if语句省略大括号时的执行顺序前面章节已经讲过了，本节和以后的章节就不再重复讲这方面的内容。

        二. 大于关系符“>”语句。

if(常量或变量>常量或变量)

       上述if条件的真假判断规则是：如果左边的数大于右边的数，此条件为真（条件满足）。否则，为假（条件不满足）。

        三. 大于等于关系符“>=”语句。

if(常量或变量>=常量或变量)

       上述if条件的真假判断规则是：如果左边的数大于或者等于右边的数，此条件为真（条件满足）。否则，为假（条件不满足）。

        现在编写一个实验程序，一共有8个给定的数，要统计其中数值大于79的数有几个，统计其中数值大于等于79的数有几个。最后把程序编译后下载到坚鸿51学习板观察结果。请直接复制第十节模板程序，修改的main程序代码如下：

1. void main() //主程序
   
2. {
   
3. /*---C语言学习区域的开始---------------------------------------------------------------------------*/
   
4.   unsigned char x1=90; //给定的第1个数     
   
5.   unsigned char x2=65; //给定的第2个数   
   
6.   unsigned char x3=85; //给定的第3个数   
   
7.   unsigned char x4=79; //给定的第4个数   
   
8.   unsigned char x5=95; //给定的第5个数   
   
9.   unsigned char x6=65; //给定的第6个数   
   
10.   unsigned char x7=75; //给定的第7个数   
    
11.   unsigned char x8=85; //给定的第8个数  
    
12. 
    
13.   unsigned char a=0; //统计大于79的变量总数
    
14.   unsigned char b=0; //统计大于等于79的变量总数
    
15. 
    
16. 
    
17. 
    
18.   if(x1>79)  //如果条件为真，则执行下面大括号里面的语句。
    
19.   {
    
20.      a++;   //相当于a=a+1，用来统计大于79的总数
    
21.   }
    
22. 
    
23. 
    
24.   if(x2>79)  //如果条件为真，则执行下面大括号里面的语句。
    
25.   {
    
26.      a++;   //相当于a=a+1，用来统计大于79的总数
    
27.   }
    
28. 
    
29. 
    
30.   if(x3>79)  //如果条件为真，则执行下面大括号里面的语句。
    
31.   {
    
32.      a++;   //相当于a=a+1，用来统计大于79的总数
    
33.   }
    
34. 
    
35.   if(x4>79)  //如果条件为真，则执行下面大括号里面的语句。
    
36.   {
    
37.      a++;   //相当于a=a+1，用来统计大于79的总数
    
38.   }
    
39. 
    
40. 
    
41.   if(x5>79)  //如果条件为真，则执行下面大括号里面的语句。
    
42.   {
    
43.      a++;   //相当于a=a+1，用来统计大于79的总数
    
44.   }
    
45. 
    
46. 
    
47.   if(x6>79)  //如果条件为真，则执行下面大括号里面的语句。
    
48.   {
    
49.      a++;   //相当于a=a+1，用来统计大于79的总数
    
50.   }
    
51. 
    
52. 
    
53.   if(x7>79)  //如果条件为真，则执行下面大括号里面的语句。
    
54.   {
    
55.      a++;   //相当于a=a+1，用来统计大于79的总数
    
56.   }
    
57. 
    
58.   if(x8>79)  //如果条件为真，则执行下面大括号里面的语句。
    
59.   {
    
60.      a++;   //相当于a=a+1，用来统计大于79的总数
    
61.   }
    
62. 
    
63. 
    
64.   if(x1>=79)  //如果条件为真，则执行下面大括号里面的语句。
    
65.   {
    
66.      b++;   //相当于b=b+1，用来统计大于等于79的总数
    
67.   }
    
68. 
    
69. 
    
70.   if(x2>=79)  //如果条件为真，则执行下面大括号里面的语句。
    
71.   {
    
72.      b++;   //相当于b=b+1，用来统计大于等于79的总数
    
73.   }
    
74. 
    
75. 
    
76.   if(x3>=79)  //如果条件为真，则执行下面大括号里面的语句。
    
77.   {
    
78.      b++;   //相当于b=b+1，用来统计大于等于79的总数
    
79.   }
    
80.       
    
81. 
    
82.   if(x4>=79)  //如果条件为真，则执行下面大括号里面的语句。
    
83.   {
    
84.      b++;   //相当于b=b+1，用来统计大于等于79的总数
    
85.   }
    
86. 
    
87. 
    
88.   if(x5>=79)  //如果条件为真，则执行下面大括号里面的语句。
    
89.   {
    
90.      b++;   //相当于b=b+1，用来统计大于等于79的总数
    
91.   }
    
92. 
    
93. 
    
94.   if(x6>=79)  //如果条件为真，则执行下面大括号里面的语句。
    
95.   {
    
96.      b++;   //相当于b=b+1，用来统计大于等于79的总数
    
97.   }
    
98. 
    
99. 
    
100.   if(x7>=79)  //如果条件为真，则执行下面大括号里面的语句。
     
101.   {
     
102.      b++;   //相当于b=b+1，用来统计大于等于79的总数
     
103.   }
     
104.       
     
105. 
     
106.   if(x8>=79)  //如果条件为真，则执行下面大括号里面的语句。
     
107.   {
     
108.      b++;   //相当于b=b+1，用来统计大于等于79的总数
     
109.   }
     
110. 
     
111.       
     
112.   GuiWdData0=a;   //把a这个变量放到窗口变量0里面显示
     
113.   GuiWdData1=b;   //把b这个变量放到窗口变量1里面显示
     
114.   
     
115.         
     
116. /*---C语言学习区域的结束---------------------------------------------------------------------------*/
     
117.    while(1)  
     
118.    {
     
119.                   initial();
     
120.       key_service();
     
121.       display_service();
     
122.    }
     
123. 
     
124. }

复制代码

         查看运算结果的方法。如何在坚鸿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个）

        下节预告：小于关系符“<”和小于等于关系符“<=”。

（未完待续）

jianhong_wu

第四十节：小于关系符“<”和小于等于关系符“<=”。

        一. 小于关系符“<”语句。

if(常量或变量<常量或变量)

       上述if条件的真假判断规则是：如果左边的数小于右边的数，此条件为真（条件满足）。否则，为假（条件不满足）。

        二. 小于等于关系符“<=”语句。

if(常量或变量<=常量或变量)

       上述if条件的真假判断规则是：如果左边的数小于或者等于右边的数，此条件为真（条件满足）。否则，为假（条件不满足）。

        现在编写一个实验程序，一共有8个给定的数，要统计其中数值小于79的数有几个，统计其中数值小于等于79的数有几个。最后把程序编译后下载到坚鸿51学习板观察结果。请直接复制第十节模板程序，修改的main程序代码如下：

1. 
   
2. void main() //主程序
   
3. {
   
4. /*---C语言学习区域的开始---------------------------------------------------------------------------*/
   
5.   unsigned char x1=90; //给定的第1个数     
   
6.   unsigned char x2=65; //给定的第2个数   
   
7.   unsigned char x3=85; //给定的第3个数   
   
8.   unsigned char x4=79; //给定的第4个数   
   
9.   unsigned char x5=95; //给定的第5个数   
   
10.   unsigned char x6=65; //给定的第6个数   
    
11.   unsigned char x7=75; //给定的第7个数   
    
12.   unsigned char x8=85; //给定的第8个数  
    
13. 
    
14.   unsigned char a=0; //统计小于79的变量总数
    
15.   unsigned char b=0; //统计小于等于79的变量总数
    
16. 
    
17. 
    
18.   if(x1<79)  //如果条件为真，则执行下面大括号里面的语句。
    
19.   {
    
20.      a++;   //相当于a=a+1，用来统计小于79的总数
    
21.   }
    
22. 
    
23.   if(x2<79)  //如果条件为真，则执行下面大括号里面的语句。
    
24.   {
    
25.      a++;   //相当于a=a+1，用来统计小于79的总数
    
26.   }
    
27. 
    
28.   if(x3<79)  //如果条件为真，则执行下面大括号里面的语句。
    
29.   {
    
30.      a++;   //相当于a=a+1，用来统计小于79的总数
    
31.   }
    
32. 
    
33.   if(x4<79)  //如果条件为真，则执行下面大括号里面的语句。
    
34.   {
    
35.      a++;   //相当于a=a+1，用来统计小于79的总数
    
36.   }
    
37. 
    
38.   if(x5<79)  //如果条件为真，则执行下面大括号里面的语句。
    
39.   {
    
40.      a++;   //相当于a=a+1，用来统计小于79的总数
    
41.   }
    
42. 
    
43.   if(x6<79)  //如果条件为真，则执行下面大括号里面的语句。
    
44.   {
    
45.      a++;   //相当于a=a+1，用来统计小于79的总数
    
46.   }
    
47. 
    
48.   if(x7<79)  //如果条件为真，则执行下面大括号里面的语句。
    
49.   {
    
50.      a++;   //相当于a=a+1，用来统计小于79的总数
    
51.   }
    
52. 
    
53.   if(x8<79)  //如果条件为真，则执行下面大括号里面的语句。
    
54.   {
    
55.      a++;   //相当于a=a+1，用来统计小于79的总数
    
56.   }
    
57. 
    
58.   if(x1<=79)  //如果条件为真，则执行下面大括号里面的语句。
    
59.   {
    
60.      b++;   //相当于b=b+1，用来统计小于等于79的总数
    
61.   }
    
62. 
    
63. 
    
64.   if(x2<=79)  //如果条件为真，则执行下面大括号里面的语句。
    
65.   {
    
66.      b++;   //相当于b=b+1，用来统计小于等于79的总数
    
67.   }
    
68. 
    
69. 
    
70.   if(x3<=79)  //如果条件为真，则执行下面大括号里面的语句。
    
71.   {
    
72.      b++;   //相当于b=b+1，用来统计小于等于79的总数
    
73.   }
    
74. 
    
75.   
    
76.   if(x4<=79)  //如果条件为真，则执行下面大括号里面的语句。
    
77.   {
    
78.      b++;   //相当于b=b+1，用来统计小于等于79的总数
    
79.   }
    
80. 
    
81.   if(x5<=79)  //如果条件为真，则执行下面大括号里面的语句。
    
82.   {
    
83.      b++;   //相当于b=b+1，用来统计小于等于79的总数
    
84.   }
    
85. 
    
86. 
    
87.   if(x6<=79)  //如果条件为真，则执行下面大括号里面的语句。
    
88.   {
    
89.      b++;   //相当于b=b+1，用来统计小于等于79的总数
    
90.   }
    
91. 
    
92. 
    
93.   if(x7<=79)  //如果条件为真，则执行下面大括号里面的语句。
    
94.   {
    
95.      b++;   //相当于b=b+1，用来统计小于等于79的总数
    
96.   }
    
97. 
    
98.   
    
99.   if(x8<=79)  //如果条件为真，则执行下面大括号里面的语句。
    
100.   {
     
101.      b++;   //相当于b=b+1，用来统计小于等于79的总数
     
102.   }
     
103.       
     
104.   GuiWdData0=a;   //把a这个变量放到窗口变量0里面显示
     
105.   GuiWdData1=b;   //把b这个变量放到窗口变量1里面显示
     
106.   
     
107.         
     
108. /*---C语言学习区域的结束---------------------------------------------------------------------------*/
     
109.    while(1)  
     
110.    {
     
111.                   initial();
     
112.       key_service();
     
113.       display_service();
     
114.    }
     
115. 
     
116. }
     

复制代码

         查看运算结果的方法。如何在坚鸿51学习板上观察变量？按下S1或者S5按键即可切换显示不同的窗口，从而显示不同的变量。按下S9按键不松手就可以切换到十六进制的显示界面，松开手后会自动切换到十进制的界面。16个LED灯显示的就是当前变量的二进制数，亮代表1，灭代表0。上坚鸿51学习板观察程序执行的结果如下：

         变量a为3。（小于79的有x2,x6, x7这3个）

         变量b为4。（小于等于79的有x2, x4,x6, x7这4个）

         下节预告：与“&&”，或“||”的关系符。

（未完待续）

jianhong_wu

第四十一节：与“&&”，或“||”的关系符。

       一．前面第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程序代码如下：

1. 
   
2. void main() //主程序
   
3. {
   
4. /*---C语言学习区域的开始---------------------------------------------------------------------------*/
   
5.   unsigned char x1=90; //给定的第1个数     
   
6.   unsigned char x2=65; //给定的第2个数   
   
7.   unsigned char x3=85; //给定的第3个数   
   
8.   unsigned char x4=79; //给定的第4个数   
   
9.   unsigned char x5=95; //给定的第5个数   
   
10.   unsigned char x6=65; //给定的第6个数   
    
11.   unsigned char x7=75; //给定的第7个数   
    
12.   unsigned char x8=85; //给定的第8个数  
    
13. 
    
14.   unsigned char a=0; //统计从70到80的变量总数
    
15.   unsigned char b=0; //统计除了70到80以外的变量总数
    
16. 
    
17. 
    
18.   if(x1>=70&&x1<=80)  //如果条件为真，则执行下面大括号里面的语句。
    
19.   {
    
20.      a++;   //相当于a=a+1，用来统计从70到80的总数
    
21.   }
    
22. 
    
23. 
    
24.   if(x2>=70&&x2<=80)  //如果条件为真，则执行下面大括号里面的语句。
    
25.   {
    
26.      a++;   //相当于a=a+1，用来统计从70到80的总数
    
27.   }
    
28. 
    
29. 
    
30.   if(x3>=70&&x3<=80)  //如果条件为真，则执行下面大括号里面的语句。
    
31.   {
    
32.      a++;   //相当于a=a+1，用来统计从70到80的总数
    
33.   }
    
34. 
    
35.   if(x4>=70&&x4<=80)  //如果条件为真，则执行下面大括号里面的语句。
    
36.   {
    
37.      a++;   //相当于a=a+1，用来统计从70到80的总数
    
38.   }
    
39. 
    
40.   if(x5>=70&&x5<=80)  //如果条件为真，则执行下面大括号里面的语句。
    
41.   {
    
42.      a++;   //相当于a=a+1，用来统计从70到80的总数
    
43.   }
    
44. 
    
45. 
    
46.   if(x6>=70&&x6<=80)  //如果条件为真，则执行下面大括号里面的语句。
    
47.   {
    
48.      a++;   //相当于a=a+1，用来统计从70到80的总数
    
49.   }
    
50. 
    
51. 
    
52.   if(x7>=70&&x7<=80)  //如果条件为真，则执行下面大括号里面的语句。
    
53.   {
    
54.      a++;   //相当于a=a+1，用来统计从70到80的总数
    
55.   }
    
56. 
    
57.   if(x8>=70&&x8<=80)  //如果条件为真，则执行下面大括号里面的语句。
    
58.   {
    
59.      a++;   //相当于a=a+1，用来统计从70到80的总数
    
60.   }
    
61. 
    
62.   if(x1<70||x1>80)  //如果条件为真，则执行下面大括号里面的语句。
    
63.   {
    
64.      b++;   //相当于b=b+1，用来统计除了70到80以外的总数
    
65.   }
    
66. 
    
67.   if(x2<70||x2>80)  //如果条件为真，则执行下面大括号里面的语句。
    
68.   {
    
69.      b++;   //相当于b=b+1，用来统计除了70到80以外的总数
    
70.   }
    
71. 
    
72.   if(x3<70||x3>80)  //如果条件为真，则执行下面大括号里面的语句。
    
73.   {
    
74.      b++;   //相当于b=b+1，用来统计除了70到80以外的总数
    
75.   }
    
76. 
    
77.   if(x4<70||x4>80)  //如果条件为真，则执行下面大括号里面的语句。
    
78.   {
    
79.      b++;   //相当于b=b+1，用来统计除了70到80以外的总数
    
80.   }
    
81. 
    
82.   if(x5<70||x5>80)  //如果条件为真，则执行下面大括号里面的语句。
    
83.   {
    
84.      b++;   //相当于b=b+1，用来统计除了70到80以外的总数
    
85.   }
    
86. 
    
87.   if(x6<70||x6>80)  //如果条件为真，则执行下面大括号里面的语句。
    
88.   {
    
89.      b++;   //相当于b=b+1，用来统计除了70到80以外的总数
    
90.   }
    
91. 
    
92.   if(x7<70||x7>80)  //如果条件为真，则执行下面大括号里面的语句。
    
93.   {
    
94.      b++;   //相当于b=b+1，用来统计除了70到80以外的总数
    
95.   }
    
96. 
    
97.   if(x8<70||x8>80)  //如果条件为真，则执行下面大括号里面的语句。
    
98.   {
    
99.      b++;   //相当于b=b+1，用来统计除了70到80以外的总数
    
100.   }
     
101. 
     
102.       
     
103.   GuiWdData0=a;   //把a这个变量放到窗口变量0里面显示
     
104.   GuiWdData1=b;   //把b这个变量放到窗口变量1里面显示
     
105.   
     
106.         
     
107. /*---C语言学习区域的结束---------------------------------------------------------------------------*/
     
108.    while(1)  
     
109.    {
     
110.                   initial();
     
111.       key_service();
     
112.       display_service();
     
113.    }
     
114. 
     
115. }

复制代码

        查看运算结果的方法。如何在坚鸿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个）

        下节预告：括号改变判断的优先级。

（未完待续）

jianhong_wu

第四十二节：小括号改变判断的优先级。

       小括号如何改变判断优先级？ 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程序代码如下：

1. 
   
2. void main() //主程序
   
3. {
   
4. /*---C语言学习区域的开始---------------------------------------------------------------------------*/
   
5.         
   
6.   //x,y这三个变量作为条件判断的变量
   
7.   unsigned char x=5;
   
8.   unsigned char y=6;
   
9.   
   
10.   //a,b这两个变量作为输出判断结果的真假，0代表假，1代表真。
    
11.   unsigned char a=0;  //默认为0，也就是默认为假
    
12.   unsigned char b=0;  //默认为0，也就是默认为假
    
13.   
    
14.   if((x<y||y>x)&&x==y) //里面的条件是((真||真)&&假)，最终结果判断是假
    
15.   {
    
16.      a=1;
    
17.   }
    
18. 
    
19.   if(x<y||(y>x&&x==y)) //里面的条件是(真||(真&&假))，最终结果判断是真
    
20.   {
    
21.      b=1;
    
22.   }
    
23.   
    
24.         
    
25.   GuiWdData0=a;   //把a这个变量结果放到窗口变量0里面显示
    
26.   GuiWdData1=b;   //把b这个变量结果放到窗口变量1里面显示
    
27. 
    
28.         
    
29. /*---C语言学习区域的结束---------------------------------------------------------------------------*/
    
30.    while(1)  
    
31.    {
    
32.       initial();
    
33.       key_service();
    
34.       display_service();
    
35.    }
    
36. 
    
37. }
    

复制代码

         查看运算结果的方法。如何在坚鸿51学习板上观察变量？按下S1或者S5按键即可切换显示不同的窗口，从而显示不同的变量。按下S9按键不松手就可以切换到十六进制的显示界面，松开手后会自动切换到十进制的界面。16个LED灯显示的就是当前变量的二进制数，亮代表1，灭代表0。上坚鸿51学习板观察程序执行的结果如下：

         变量a为0。（0代表此条件判断结果为假）

         变量b为1。（1代表此条件判断结果为真）

         下节预告：if,elseif,else的5种组合判断语句。

（未完待续）

jianhong_wu

第四十三节：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；

}

else  if(条件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；

}

else  if(条件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；

}

else  if(条件2)   //else if只能出现中间，可以出现多次

{

    语句2；

}

……

else  if(条件N)   //else if只能出现中间，可以出现多次

{

    语句N；

}

        分析：从“条件1”开始往下判断，只要有一个条件满足了，就执行当前条件后面大括号的语句，剩余的条件不再判断直接跳过，如果所有的条件都不满足，那么里面的语句都不执行。简单概括就是在N个条件中最多只能选一个，如果所有的条件都为假，那么都不选。

        第五种：

if(条件1)       //if只能出现第一个条件，并且只能出现一次

{

    语句1；

}

else  if(条件2)   //else if只能出现中间，可以出现多次

{

    语句2；

}

……

else  if(条件N)   //else if只能出现中间，可以出现多次

{

    语句N；

}

else   

{

    语句N+1；

}

       分析：从“条件1”开始往下判断，只要有一个条件满足了，就执行当前条件后面大括号的语句，剩余的条件不再判断直接跳过，如果所有的条件都不满足，那么就直接执行else后面大括号里的语句，也就是本例子中的“语句N+1”。简单概括就是在N+1个条件中必须选一个，如果前面所有N个条件都为假，最后就直接执行else后面大括号的语句，也就是本例子中的“语句N+1”。

       现在编写一个程序来实验上述5种组合语句。最后把程序编译后下载到坚鸿51学习板观察结果。请直接复制第十节模板程序，修改的main程序代码如下：

1. 
   
2. void main() //主程序
   
3. {
   
4. /*---C语言学习区域的开始---------------------------------------------------------------------------*/
   
5.         
   
6.   //x这个变量作为条件判断的变量
   
7.   unsigned char x=5;
   
8. 
   
9. 
   
10.   
    
11.   //a,b,c,d,e这5个变量作为输出判断结果,0代表什么语句都没执行，1代表执行了语句1，
    
12.   //2代表执行语句2，3代表执行语句3，4代表执行语句4，5代表执行语句5。
    
13.   unsigned char a=0;  
    
14.   unsigned char b=0;
    
15.   unsigned char c=0;  
    
16.   unsigned char d=0;
    
17.   unsigned char e=0;  
    
18. 
    
19.   //第一种
    
20.   if(x>6)  //x默认是5
    
21.   {
    
22.      a=1;   //语句1
    
23.   }
    
24.   else
    
25.   {
    
26.      a=2;  //语句2
    
27.   }
    
28. 
    
29. 
    
30.   //第二种
    
31.   if(x>6)  //x默认是5
    
32.   {
    
33.      b=1;   //语句1
    
34.   }
    
35.   else if(x==7)  //x默认是5
    
36.   {
    
37.      b=2;  //语句2
    
38.   }
    
39. 
    
40. 
    
41.   //第三种
    
42.   if(x>6)  //x默认是5
    
43.   {
    
44.      c=1;   //语句1
    
45.   }
    
46.   else if(x==7)  //x默认是5
    
47.   {
    
48.      c=2;  //语句2
    
49.   }
    
50.   else
    
51.   {
    
52.      c=3;  //语句3
    
53.   }
    
54. 
    
55.   //第四种
    
56.   if(x>6)  //x默认是5
    
57.   {
    
58.      d=1;   //语句1
    
59.   }
    
60.   else if(x==7)  //x默认是5
    
61.   {
    
62.      d=2;  //语句2
    
63.   }
    
64.   else if(x==5)  //x默认是5
    
65.   {
    
66.      d=3;  //语句3
    
67.   }
    
68.   else if(x==4)  //x默认是5
    
69.   {
    
70.      d=4;  //语句4
    
71.   }
    
72. 
    
73.   //第五种
    
74.   if(x>6)  //x默认是5
    
75.   {
    
76.      e=1;   //语句1
    
77.   }
    
78.   else if(x==7)  //x默认是5
    
79.   {
    
80.      e=2;  //语句2
    
81.   }
    
82.   else if(x==5)  //x默认是5
    
83.   {
    
84.      e=3;  //语句3
    
85.   }
    
86.   else if(x==4)  //x默认是5
    
87.   {
    
88.      e=4;  //语句4
    
89.   }
    
90.   else
    
91.   {
    
92.      e=5;  //语句5
    
93.   }
    
94. 
    
95.         
    
96.   GuiWdData0=a;   //把a这个变量结果放到窗口变量0里面显示
    
97.   GuiWdData1=b;   //把b这个变量结果放到窗口变量1里面显示
    
98.   GuiWdData2=c;   //把c这个变量结果放到窗口变量2里面显示
    
99.   GuiWdData3=d;   //把d这个变量结果放到窗口变量3里面显示
    
100.   GuiWdData4=e;   //把e这个变量结果放到窗口变量4里面显示
     
101. 
     
102.         
     
103. /*---C语言学习区域的结束---------------------------------------------------------------------------*/
     
104.    while(1)  
     
105.    {
     
106.       initial();
     
107.       key_service();
     
108.       display_service();
     
109.    }
     
110. 
     
111. }
     

复制代码

         查看运算结果的方法。如何在坚鸿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）

        下节预告：一维数组。

（未完待续）

szdzjs

鸿哥的大作又有更新了

jianhong_wu

第四十四节：一维数组能批量定义变量的特点。

       一维数组有两个特点：

       第一个：批量定义变量。我们之前的章节用unsigned  char, unsigned  int, unsigned long定义变量时，往往一条语句只习惯定义一个变量，而用数组可以一条语句定义N个变量，只要不超过单片机的RAM范围。

       第二个：数组的每个元素变量的地址都是挨个相临的。第一个元素变量的地址是该数组的首地址，后面的下标是以此首地址为原点的偏移地址。这个特点跟以后学到的循环语句或者指针配合起来，只需简单几行代码就可以实现很多复杂实用的算法。

       上述第二个特点的内容等以后学到循环语句和指针时再深入讲解，本节重点讲解一维数组的书写格式和第一个特点。

       一维数组未带初始化时的通用定义格式如下：

类型 数组名[数组元素个数N];

比如：

unsigned char  x[3];  //此处的3不是下标，而是元素个数

       分析：此数组一行代码定义了三个变量，分别是x[0], x[1], x[2]，此时中括号里的0,1,2称为数组的下标，注意，数组的下标是从0开始的，从N-1结束，此时的N代表数组元素个数。因此，上述数组不存在x[3]这个元素变量，只有x[0], x[1], x[2]这三个变量，如果非要使用x[3]这个元素变量，那就会导致数组越界出现异常或者编译不通过。

      一维数组带初始化时的通用定义格式如下：

类型 数组名[数组元素个数N]={ 元素0, 元素1，…元素N-1};

比如：

unsigned char  y[3]={10,11,12};

       分析：此数组一行代码定义了三个变量，分别是y[0], y[1], y[2]。而y[0]初始化为10，y[1]初始化为11，y[2]初始化为12。

在程序中，调用数组某个变量元素时，下标可以是常量，比如y[0],此时的0就是常量；下标也可以是变量，比如y，此时的i就是变量。再强调一次，下标常量或者变量i的数值必须小于y数组定义时的元素个数，否则就会导致数组越界出现异常或者编译不通过。

       现在编写一个程序来熟悉一下一维数组的书写和使用格式。最后把程序编译后下载到坚鸿51学习板观察结果。请直接复制第十节模板程序，修改的main程序代码如下：

1. 
   
2. void main() //主程序
   
3. {
   
4. /*---C语言学习区域的开始---------------------------------------------------------------------------*/
   
5.         
   
6.   unsigned char  x[3];  //此处的3不是下标，而是元素个数，里面的3个变量没有初始化
   
7.   unsigned char  y[3]={10,11,12}; //里面三个元素变量y[0],y[1],y[2]分别初始化为10,11,12
   
8. 
   
9.   unsigned char  i=0; //定义和初始化一个变量。用来做x数组的下标。
   
10. 
    
11.   x[i]=25;  //此时下标i为0.相当于把25赋值给x[0]
    
12.   i=i+1;    //i由0变成1.
    
13.   x[i]=26;  //此时下标i为1.相当于把26赋值给x[1]
    
14.   i=i+1;    //i由1变成2.
    
15.   x[i]=27;  //此时下标i为2.相当于把27赋值给x[2]
    
16.   x[i]=x[i]+1; //此时x[2]自加1变成了28
    
17. 
    
18. 
    
19.         
    
20.   GuiWdData0=x[0];   //把x[0]这个元素变量放到窗口变量0里面显示
    
21.   GuiWdData1=x[1];   //把x[1]这个元素变量放到窗口变量1里面显示
    
22.   GuiWdData2=x[2];   //把x[2]这个元素变量放到窗口变量2里面显示
    
23. 
    
24. 
    
25.   GuiWdData3=y[0];   //把y[0]这个元素变量放到窗口变量3里面显示
    
26.   GuiWdData4=y[1];   //把y[1]这个元素变量放到窗口变量4里面显示
    
27.   GuiWdData5=y[2];   //把y[2]这个元素变量放到窗口变量5里面显示
    
28. 
    
29.         
    
30. /*---C语言学习区域的结束---------------------------------------------------------------------------*/
    
31.    while(1)  
    
32.    {
    
33.                   initial();
    
34.       key_service();
    
35.       display_service();
    
36.    }
    
37. 
    
38. }
    

复制代码

       查看运算结果的方法。如何在坚鸿51学习板上观察变量？按下S1或者S5按键即可切换显示不同的窗口，从而显示不同的变量。按下S9按键不松手就可以切换到十六进制的显示界面，松开手后会自动切换到十进制的界面。16个LED灯显示的就是当前变量的二进制数，亮代表1，灭代表0。上坚鸿51学习板观察程序执行的结果如下：

        变量元素x[0]为25。

        变量元素x[1]为26。

        变量元素x[2]为28。

        变量元素y[0]为10。

       变量元素y[1]为11。

       变量元素y[2]为12。

       下节预告：二维数组能批量定义变量的特点。

（未完待续）