21ic电子技术开发论坛 › 单片机与嵌入式系统 › 侃单片机论坛 › 从单片机基础到程序框架（连载）
1 ...67891011121314... 34下一页
返回列表 发新帖我要提问本帖赏金: 82.00元(功能说明)

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

[复制链接]
363005|721
李小川希比 发表于 2016-10-9 11:44 | 显示全部楼层
果断留名。期待楼主大作
回复

收藏269 举报

Vin2721 发表于 2016-10-11 14:08 | 显示全部楼层
今天第一次上21ic论坛，就搜到了本帖，真心不错。刚接触单片机，希望有所帮助。
回复

收藏269 举报

happysj 发表于 2016-10-11 16:12 | 显示全部楼层
敬佩你的无私奉献！
回复

收藏269 举报

Uog 发表于 2016-10-12 13:01 | 显示全部楼层
学习楼主
回复

收藏269 举报

 楼主| jianhong_wu 发表于 2016-10-16 08:37 | 显示全部楼层
第四十节：关系符的等于“==”和不等于“!=”。

【40.1   关系符的等于“==”和不等于“!=”。】

       C语言的“=”并不是等于号，而是赋值的意思，这点前面已讲过。为了跟赋值区分开来，C语言用“==”来表示等于号的关系符，用“!=”表示不等于的关系符，之所以用“!=”表示不等于的关系，是因为C语言中的“!”就是“取非”的运算符，有否定之意。

       等于关系符“==”语句的常见格式如下：
复制
  1. if(常量或变量==常量或变量)
    

  2. {
    

  3.     语句1;
    

  4.     语句2;
    

  5. }
    

  6. 语句3;
    

  7. 语句4;


       不等于关系符“!=”语句的常见格式如下：
复制
  1. if(常量或变量!=常量或变量)
    

  2. {
    

  3.     语句1;
    

  4.     语句2;
    

  5. }
    

  6. 语句3;
    

  7. 语句4;


       上一节讲到，常量或变量在if语句中的真假判断，不等于0就是真，等于0就是假。而本节关系运算符的真假判断也很简单清晰，满足条件就是真，不满足条件就是假。例如：
复制
  1. if(2==1)   //2肯定不等于1，所以不满足条件“等于的关系”，因此为假，不会执行大括号内的语句。
    

  2. {
    

  3.     语句1;
    

  4.     语句2;
    

  5. }


       相反，请继续看下面不等于号“!=”这个例子：

复制
  1. if(2!=1)   //2肯定不等于1，所以满足条件“不等于的关系”，因此为真，会执行大括号内的语句。
    

  2. {
    

  3.     语句1;
    

  4.     语句2;
    

  5. }

【40.2   建议把常量放在“==”或“!=”关系符的左边】

       “if(a==1)”和“if(1==a)”在实现的功能上是相同的。但是，在实际做项目的时候，还是建议大家采用后面这种写法“if(1==a)”，把常量放在左边，这样写有什么好处？好处是，如果我们不小心把等于号“==”或者“!=”误写成赋值符号“=”时，C编译器在编译时，它能及时发现错误并且报错告知我们，因为常量在左边是无法赋值的，编译器能及时发现错误。但是如果常量在右边而变量在左边，因为变量是允许赋值的，所以有一些C语言编译器未必会报错，就会留下不易察觉的程序隐患。比如：
复制
  1. if(a==5)
    

  2. {
    

  3.     语句1;
    

  4. }
    


  5. 

  6. if(b!=2)
    

  7. {
    

  8.     语句2;
    

  9. }


         建议改成:

复制
  1. if(5==a)
    

  2. {
    

  3.     语句1;
    

  4. }
    


  5. 

  6. if(2!=b)
    

  7. {
    

  8.     语句2;
    

  9. }


【40.3   例程练习和分析。】

        现在编写一个实验程序，一共有8个给定的数，要统计其中数值“等于85”的数有几个，统计其中数值“不等于75”的数有几个。
        程序代码如下：

复制
  1. /*---C语言学习区域的开始。-----------------------------------------------*/
    


  2. 

  3.   unsigned char x1=90; //给定的第1个数     
    

  4.   unsigned char x2=65; //给定的第2个数    
    

  5.   unsigned char x3=85; //给定的第3个数    
    

  6.   unsigned char x4=79; //给定的第4个数    
    

  7.   unsigned char x5=95; //给定的第5个数    
    

  8.   unsigned char x6=65; //给定的第6个数    
    

  9.   unsigned char x7=75; //给定的第7个数    
    

  10.   unsigned char x8=85; //给定的第8个数  
    


  11. 

  12.   unsigned char a=0; //统计等于85的变量总数
    

  13.   unsigned char b=0; //统计不等于75的变量总数
    


  14. 

  15. void main() //主函数
    

  16. {
    

  17.       //第一部分:统计“等于85”的总数有多少个。
    

  18.   if(85==x1)  //把常量85放在等于号的左边
    

  19.   {
    

  20.      a++;   //相当于a=a+1，用来统计等于85的总数
    

  21.   }
    


  22. 

  23.   if(85==x2)  //把常量85放在等于号的左边
    

  24.   {
    

  25.      a++;   //相当于a=a+1，用来统计等于85的总数
    

  26.   }
    


  27. 

  28.   if(85==x3)  //把常量85放在等于号的左边
    

  29.   {
    

  30.      a++;   //相当于a=a+1，用来统计等于85的总数
    

  31.   }
    


  32. 

  33.   if(85==x4)  //把常量85放在等于号的左边
    

  34.   {
    

  35.      a++;   //相当于a=a+1，用来统计等于85的总数
    

  36.   }
    


  37. 

  38.   if(85==x5)  //把常量85放在等于号的左边
    

  39.   {
    

  40.      a++;   //相当于a=a+1，用来统计等于85的总数
    

  41.   }
    


  42. 

  43.   if(85==x6)  //把常量85放在等于号的左边
    

  44.   {
    

  45.      a++;   //相当于a=a+1，用来统计等于85的总数
    

  46.   }
    


  47. 

  48.   if(85==x7)  //把常量85放在等于号的左边
    

  49.   {
    

  50.      a++;   //相当于a=a+1，用来统计等于85的总数
    

  51.   }
    


  52. 

  53.   if(85==x8)  //把常量85放在等于号的左边
    

  54.   {
    

  55.      a++;   //相当于a=a+1，用来统计等于85的总数
    

  56.   }
    


  57. 

  58.       //第二部分:统计“不等于75”的总数有多少个。
    

  59.   if(75!=x1)  //把常量75放在不等于号的左边
    

  60.   {
    

  61.      b++;   //相当于b=b+1，用来统计不等于75的总数
    

  62.   }
    


  63. 

  64.   if(75!=x2)  //把常量75放在不等于号的左边
    

  65.   {
    

  66.      b++;   //相当于b=b+1，用来统计不等于75的总数
    

  67.   }
    


  68. 

  69.   if(75!=x3)  //把常量75放在不等于号的左边
    

  70.   {
    

  71.      b++;   //相当于b=b+1，用来统计不等于75的总数
    

  72.   }
    


  73. 

  74.   if(75!=x4)  //把常量75放在不等于号的左边
    

  75.   {
    

  76.      b++;   //相当于b=b+1，用来统计不等于75的总数
    

  77.   }
    


  78. 

  79.   if(75!=x5)  //把常量75放在不等于号的左边
    

  80.   {
    

  81.      b++;   //相当于b=b+1，用来统计不等于75的总数
    

  82.   }
    


  83. 

  84.   if(75!=x6)  //把常量75放在不等于号的左边
    

  85.   {
    

  86.      b++;   //相当于b=b+1，用来统计不等于75的总数
    

  87.   }
    


  88. 

  89.   if(75!=x7)  //把常量75放在不等于号的左边
    

  90.   {
    

  91.      b++;   //相当于b=b+1，用来统计不等于75的总数
    

  92.   }
    


  93. 

  94.   if(75!=x8)  //把常量75放在不等于号的左边
    

  95.   {
    

  96.      b++;   //相当于b=b+1，用来统计不等于75的总数
    

  97.   }
    


  98. 

  99.      View(a);  //把第1个数a发送到电脑端的串口助手软件上观察。
    

  100.      View(b);  //把第2个数b发送到电脑端的串口助手软件上观察。
    


  101. 

  102.      while(1)  
    

  103.      { 
    

  104.      }
    

  105. }
    


  106. 

  107. /*---C语言学习区域的结束。-----------------------------------------------*/


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

复制
  1. 开始...
    


  2. 

  3. 第1个数
    

  4. 十进制:2
    

  5. 十六进制:2
    

  6. 二进制:10
    


  7. 

  8. 第2个数
    

  9. 十进制:7
    

  10. 十六进制:7
    

  11. 二进制:111


分析：        
        变量a为2。（等于85的有x3,x8这2个）
        变量b为7。（不等于75的有x1,x2,x3,x4,x5,x6,x8这7个）
        通过实验结果，发现在单片机上的实验结果和我们的分析是一致的。

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

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

本帖子中包含更多资源

您需要 登录 才可以下载或查看，没有账号？注册

×
回复

收藏269 举报

西街耳呦 发表于 2016-10-20 17:30 | 显示全部楼层
好好学习
回复

收藏269 举报

416356084 发表于 2016-10-21 10:25 | 显示全部楼层
回复

收藏269 举报

arima 发表于 2016-10-21 20:13 | 显示全部楼层
都是C语言基础，楼主继续加油。。。。
**就是胜利。。。。
回复

收藏269 举报

 楼主| jianhong_wu 发表于 2016-10-23 08:58 | 显示全部楼层
第四十一节：关系符的大于“>”和大于等于“>=”。

【41.1   大于“>”。】

       大于关系符“>”语句的常见格式如下：
复制
  1. if(常量或变量>常量或变量)
    

  2. {
    

  3.     语句1;
    

  4.     语句2;
    

  5. }
    

  6. 语句3;
    

  7. 语句4;

       上述if条件的真假判断规则是：如果左边的数大于右边的数，此条件为真（条件满足）。否则，为假（条件不满足）。例如：
复制
  1. if(2>1)   //2肯定大于1，所以满足条件“大于的关系”，因此为真，会执行大括号内的语句。
    

  2. {
    

  3.     语句1;
    

  4.     语句2;
    

  5. }


【41.2   大于等于“>=”。】

       大于关系符“>=”语句的常见格式如下：
复制
  1. if(常量或变量>=常量或变量)
    

  2. {
    

  3.     语句1;
    

  4.     语句2;
    

  5. }
    

  6. 语句3;
    

  7. 语句4;

       上述if条件的真假判断规则是：如果左边的数大于或者等于右边的数，此条件为真（条件满足）。否则，为假（条件不满足）。例如：
复制
  1. if(2>=2)   //左边的2虽然不大于右边的2，但是左边的2等于右边的2，因此为真，满足条件。
    

  2. {
    

  3.     语句1;
    

  4.     语句2;
    

  5. }


【41.3   例程练习和分析。】

        现在编写一个实验程序，一共有8个给定的数，要统计其中数值大于79的数有几个，同时，也统计其中数值大于等于79的数又有几个。
        程序代码如下：

复制
  1. /*---C语言学习区域的开始。-----------------------------------------------*/
    

  2.       unsigned char x1=90; //给定的第1个数     
    

  3.       unsigned char x2=65; //给定的第2个数    
    

  4.       unsigned char x3=85; //给定的第3个数    
    

  5.       unsigned char x4=79; //给定的第4个数    
    

  6.       unsigned char x5=95; //给定的第5个数    
    

  7.       unsigned char x6=65; //给定的第6个数    
    

  8.       unsigned char x7=75; //给定的第7个数    
    

  9.       unsigned char x8=85; //给定的第8个数  
    


  10. 

  11.       unsigned char a=0; //统计大于79的变量总数
    

  12.       unsigned char b=0; //统计大于等于79的变量总数
    


  13. 

  14. void main() //主函数
    

  15. {
    

  16.       //第一部分:统计“大于79”的总数有多少个。
    


  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.       //第二部分:统计“大于等于79”的总数有多少个。
    


  59. 

  60.   if(x1>=79)  //如果条件为真，则执行下面大括号里面的语句。
    

  61.   {
    

  62.      b++;   //相当于b=b+1，用来统计大于等于79的总数
    

  63.   }
    


  64. 

  65.   if(x2>=79)  //如果条件为真，则执行下面大括号里面的语句。
    

  66.   {
    

  67.      b++;   //相当于b=b+1，用来统计大于等于79的总数
    

  68.   }
    


  69. 

  70.   if(x3>=79)  //如果条件为真，则执行下面大括号里面的语句。
    

  71.   {
    

  72.      b++;   //相当于b=b+1，用来统计大于等于79的总数
    

  73.   }
    


  74. 

  75.   if(x4>=79)  //如果条件为真，则执行下面大括号里面的语句。
    

  76.   {
    

  77.      b++;   //相当于b=b+1，用来统计大于等于79的总数
    

  78.   }
    


  79. 

  80.   if(x5>=79)  //如果条件为真，则执行下面大括号里面的语句。
    

  81.   {
    

  82.      b++;   //相当于b=b+1，用来统计大于等于79的总数
    

  83.   }
    


  84. 

  85.   if(x6>=79)  //如果条件为真，则执行下面大括号里面的语句。
    

  86.   {
    

  87.      b++;   //相当于b=b+1，用来统计大于等于79的总数
    

  88.   }
    


  89. 


  90. 

  91.   if(x7>=79)  //如果条件为真，则执行下面大括号里面的语句。
    

  92.   {
    

  93.      b++;   //相当于b=b+1，用来统计大于等于79的总数
    

  94.   }
    


  95. 

  96.   if(x8>=79)  //如果条件为真，则执行下面大括号里面的语句。
    

  97.   {
    

  98.      b++;   //相当于b=b+1，用来统计大于等于79的总数
    

  99.   }
    


  100. 

  101.      View(a);  //把第1个数a发送到电脑端的串口助手软件上观察。
    

  102.      View(b);  //把第2个数b发送到电脑端的串口助手软件上观察。
    


  103. 

  104.      while(1)  
    

  105.      { 
    

  106.      }
    

  107. }
    


  108. 

  109. /*---C语言学习区域的结束。-----------------------------------------------*/


        在电脑串口助手软件上观察到的程序执行现象如下：
复制
  1. 开始...
    


  2. 

  3. 第1个数
    

  4. 十进制:4
    

  5. 十六进制:4
    

  6. 二进制:100
    


  7. 

  8. 第2个数
    

  9. 十进制:5
    

  10. 十六进制:5
    

  11. 二进制:101

分析：        
        变量a为4。（大于79的有x1,x3, x5,x8这4个）
        变量b为5。（大于等于79的有x1,x3, x4, x5,x8这5个）
        通过实验结果，发现在单片机上的实验结果和我们的分析是一致的。

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

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

本帖子中包含更多资源

您需要 登录 才可以下载或查看，没有账号？注册

×
回复

收藏269 举报

 楼主| jianhong_wu 发表于 2016-10-30 09:26 | 显示全部楼层
第四十二节：关系符的小于“<”和小于等于“<=”。

【42.1   小于“<”。】

      小于关系符“<”语句的常见格式如下：
复制
  1. if(常量或变量<常量或变量)
    

  2. {
    

  3.     语句1;
    

  4.     语句2;
    

  5. }
    

  6. 语句3;
    

  7. 语句4;

       上述if条件的真假判断规则是：如果左边的数小于右边的数，此条件为真（条件满足）。否则，为假（条件不满足）。例如：
复制
  1. if(2<1)   //2肯定不小于1，所以不满足条件“小于的关系”，因此为假，不会执行大括号内的语句。
    

  2. {
    

  3.     语句1;
    

  4.     语句2;
    

  5. }


【42.2   小于等于“<=”。】

       小于关系符“<=”语句的常见格式如下：
复制
  1. if(常量或变量<=常量或变量)
    

  2. {
    

  3.     语句1;
    

  4.     语句2;
    

  5. }
    

  6. 语句3;
    

  7. 语句4;

       上述if条件的真假判断规则是：如果左边的数小于或者等于右边的数，此条件为真（条件满足）。否则，为假（条件不满足）。例如：
复制
  1. if(2<=2)   //左边的2虽然不小于右边的2，但是左边的2等于右边的2，因此为真，满足条件。
    

  2. {
    

  3.     语句1;
    

  4.     语句2;
    

  5. }

【42.3   例程练习和分析。】

       现在编写一个实验程序，一共有8个给定的数，要统计其中数值小于79的数有几个，统计其中数值小于等于79的数有几个。
       程序代码如下：

复制
  1. /*---C语言学习区域的开始。-----------------------------------------------*/
    

  2.       unsigned char x1=90; //给定的第1个数     
    

  3.       unsigned char x2=65; //给定的第2个数    
    

  4.       unsigned char x3=85; //给定的第3个数    
    

  5.       unsigned char x4=79; //给定的第4个数    
    

  6.       unsigned char x5=95; //给定的第5个数    
    

  7.       unsigned char x6=65; //给定的第6个数    
    

  8.       unsigned char x7=75; //给定的第7个数    
    

  9.       unsigned char x8=85; //给定的第8个数  
    


  10. 

  11.       unsigned char a=0; //统计小于79的变量总数
    

  12.       unsigned char b=0; //统计小于等于79的变量总数
    


  13. 

  14. void main() //主函数
    

  15. {
    

  16.       //第一部分:统计“小于79”的总数有多少个。
    


  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.        //第二部分:统计“小于等于79”的总数有多少个。
    


  59. 

  60.   if(x1<=79)  //如果条件为真，则执行下面大括号里面的语句。
    

  61.   {
    

  62.      b++;   //相当于b=b+1，用来统计小于等于79的总数
    

  63.   }
    


  64. 


  65. 

  66.   if(x2<=79)  //如果条件为真，则执行下面大括号里面的语句。
    

  67.   {
    

  68.      b++;   //相当于b=b+1，用来统计小于等于79的总数
    

  69.   }
    


  70. 


  71. 

  72.   if(x3<=79)  //如果条件为真，则执行下面大括号里面的语句。
    

  73.   {
    

  74.      b++;   //相当于b=b+1，用来统计小于等于79的总数
    

  75.   }
    


  76. 


  77. 

  78.   if(x4<=79)  //如果条件为真，则执行下面大括号里面的语句。
    

  79.   {
    

  80.      b++;   //相当于b=b+1，用来统计小于等于79的总数
    

  81.   }
    


  82. 

  83.   if(x5<=79)  //如果条件为真，则执行下面大括号里面的语句。
    

  84.   {
    

  85.      b++;   //相当于b=b+1，用来统计小于等于79的总数
    

  86.   }
    


  87. 


  88. 

  89.   if(x6<=79)  //如果条件为真，则执行下面大括号里面的语句。
    

  90.   {
    

  91.      b++;   //相当于b=b+1，用来统计小于等于79的总数
    

  92.   }
    


  93. 


  94. 

  95.   if(x7<=79)  //如果条件为真，则执行下面大括号里面的语句。
    

  96.   {
    

  97.      b++;   //相当于b=b+1，用来统计小于等于79的总数
    

  98.   }
    


  99. 


  100. 

  101.   if(x8<=79)  //如果条件为真，则执行下面大括号里面的语句。
    

  102.   {
    

  103.      b++;   //相当于b=b+1，用来统计小于等于79的总数
    

  104.   }  
    


  105. 

  106.      View(a);  //把第1个数a发送到电脑端的串口助手软件上观察。
    

  107.      View(b);  //把第2个数b发送到电脑端的串口助手软件上观察。
    


  108. 

  109.      while(1)  
    

  110.      { 
    

  111.      }
    

  112. }
    


  113. 

  114. /*---C语言学习区域的结束。-----------------------------------------------*/


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

  1. 

  2. 开始...
    


  3. 

  4. 第1个数
    

  5. 十进制:3
    

  6. 十六进制:3
    

  7. 二进制:11
    


  8. 

  9. 第2个数
    

  10. 十进制:4
    

  11. 十六进制:4
    

  12. 二进制:100


分析：        
       变量a为3。（小于79的有x2,x6, x7这3个）
       变量b为4。（小于等于79的有x2, x4,x6, x7这4个）
       通过实验结果，发现在单片机上的实验结果和我们的分析是一致的。

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

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

本帖子中包含更多资源

您需要 登录 才可以下载或查看，没有账号？注册

×
回复

收藏269 举报

jjdongni 发表于 2016-10-30 14:29 | 显示全部楼层
必须顶顶
回复

收藏269 举报

长不大的小孩 发表于 2016-10-31 21:51 | 显示全部楼层
收藏了
回复

收藏269 举报

zxmxx 发表于 2016-11-5 20:37 | 显示全部楼层
支持楼主
回复

收藏269 举报

zxmxx 发表于 2016-11-5 21:15 | 显示全部楼层
学习中，谢谢楼主的分享
回复

收藏269 举报

zxmxx 发表于 2016-11-5 21:17 | 显示全部楼层
学习中，支持楼主~~~
回复

收藏269 举报

xydzx 发表于 2016-11-6 08:56 | 显示全部楼层
支持一下，对嵌入式学习很重要啊，单片机重点，，，
回复

收藏269 举报

 楼主| jianhong_wu 发表于 2016-11-6 10:56 | 显示全部楼层
第四十三节：关系符中的关系符:与“&&”，或“||”。

【43.1   关系符中的与“&&”。】

       前面在讲关系符的时候，讲了只存在1个（判断条件）的情况下，根据这个判断为真还是为假再执行对应的操作，那么，当同时存在2个（判断条件）以上的情况下，该如何描述（判断条件）与（判断条件）之间的关系，这就涉及本节所讲的“关系符中的关系符”：与“&&”，或“||”。
       先讲“&&”语句，符号“&&”称为“与”，它的含义是：假如有两个以上的（条件判断），当所有的（条件判断）都满足的时候，才认为这个整体判断是真，否则，只要有1个（条件判断）不满足，那么整体判断就是假。这个规律，有点像很多开关在电路回路中的串联关系，只有所有串联在回路中的开关都是闭合的状态，这个回路才是畅通的，否则，只要有一个开关是断开的，整个回路就是断开的。
       与语句“&&”的常见格式如下：
复制
  1. if(第1个条件判断&&第2个条件判断…&&第N个条件判断)
    

  2. {
    

  3.     语句1;
    

  4.     语句2;
    

  5. }
    

  6. 语句3;
    

  7. 语句4;

       在上述格式中，只有if语句后面小括号内所有的(条件判断)都满足的时候，整体判断才为真，才会执行到大括号内的“语句1”和“语句2”，否则，只要有1个不满足，就直接跳到“语句3”处往下执行。

       再举一个具体的例子，比如要取从70到80之间的所有数据，也就是说，既要大于等于70，同时又要小于等于80，程序代码可以这样书写：
复制
  1. if(a>=70&&a<=80)  //在70到80的区间范围（包括边界70和80）
    

  2. {
    

  3.    语句1;
    

  4.    语句2;
    

  5.    ……
    

  6.    语句N;
    

  7. }


【43.2   关系符中的或“||”。】

       符号“||”称为“或”，它的含义是：假如有两个以上的（条件判断），只要有1个条件判断为真，则此整体判断裁定为真，否则，必须所有的（条件判断）都不满足，此整体判断才会裁定为假。这个规律，有点像很多开关在电路回路中的并联关系，并联在回路的多个开关，只要有1个开关是闭合的状态，那么这个回路肯定是畅通的，否则，必须全部开关都是断开的，整个回路才会是断开的。
       或语句“||”的常见格式如下：
复制
  1. if(第1个条件判断||第2个条件判断…||第N个条件判断)
    

  2. {
    

  3.     语句1;
    

  4.     语句2;
    

  5. }
    

  6. 语句3;
    

  7. 语句4;

      在上述格式中，只要if语句后面小括号内有1个(条件判断)是满足的时候，整体判断马上裁定为真，这时就会执行到大括号内的“语句1”和“语句2”，否则，必须全部的(条件判断)都不满足，整体判断才会裁定为假，这时就会直接跳到“语句3”处往下执行。

      再举一个具体的例子，比如要取除了70到80之间以外的所有数据，也就是说，要么小于70，或者要么大于80，可以这样写：
复制
  1. if(a<70||a>80) //在70到80的区间范围以外的数据（不包括边界70和80）
    

  2. {
    

  3.    语句1;
    

  4.    语句2;
    

  5.    ……
    

  6.    语句N;
    

  7. }




【43.3   “&”和“&&”，“|”和“||”的区别。】

       前面章节讲过运算符的“&”和“|”，它们发音也是“与”和“或”，跟本节讲的关系符“&&”和“||”的发音是同音，因此很容易让初学者混淆。区别如下：
       运算符的“&”和“|”，是属于运算符，是强调数与数，变量与变量，个体与个体之间的运算，而不是关系。它们之间的运算，是把一个数或一个变量转化成二进制后，进行二进制的0和1之间的“与”“或”运算。
       关系符的“&&”和“||”，是属于关系符，是强调（条件判断）与（条件判断），关系与关系，整体与整体之间的关系判断，而不是运算。它们之间的关系，关键词是判断。

【43.4   “&&”和“||”的“短路”问题。】

       关系符“&&”和“||”居然也有“短路”问题？大家不要惊异，这里所说的“短路”只是强调关系符内部判断的顺序和取舍。“短路”这个词在这里只是业内已经习惯了的一种称谓，虽然我个人感觉有一点怪怪的不自然，但是我自己也想不出其它更好的词来描述这种关系，因此就跟业内已习惯的称谓保持一致。
       “&&”的“短路”，它内部判断的顺序和取舍是这个样子的：在两个以上的判断中，从左边到右边，依次逐个判断，先判断第1个（条件判断），再第2个（条件判断）...再第N个（条件判断），但是，在此期间，只要发现有1个条件是不满足，就马上退出判断，不再继续判断后面的（条件判断），因为，对于“与”的关系符，只要有1个条件判断是不满足（假），就可以马上裁定整体判断为假了，没必要继续判断后面的（条件判断）。
       “||”的“短路”，它内部判断的顺序和取舍是这个样子的：在两个以上的判断中，从左边到右边，依次逐个判断，先判断第1个（条件判断），再第2个（条件判断）...再第N个（条件判断），但是，在此期间，只要发现有1个条件是满足，就马上退出判断，不再继续判断后面的（条件判断），因为，对于“或”的关系符，只要有1个条件判断是满足（真），就可以马上裁定整体判断为真了，没必要继续判断后面的（条件判断）。
       上述文字中的“从左到右”就是“顺序”，“马上退出”就是“取舍”。这种关系之所以称谓为“短路”，我猜测可能是把“&&”和“||”比喻成在电路的回路中，只要有个1个地方短路了，就可以马上裁定这个回路是短路的，就不用再判断其它地方了。

【43.5   例程练习和分析。】

       现在编写一个实验程序，一共有8个给定的数，要统计其中数值从70到80之间的数有几个，统计其中取除了70到80之间以外的数有几个。
       程序代码如下：
复制

  1. 

  2. /*---C语言学习区域的开始。-----------------------------------------------*/
    

  3.       unsigned char x1=90; //给定的第1个数     
    

  4.       unsigned char x2=65; //给定的第2个数    
    

  5.       unsigned char x3=85; //给定的第3个数    
    

  6.       unsigned char x4=79; //给定的第4个数    
    

  7.       unsigned char x5=95; //给定的第5个数    
    

  8.       unsigned char x6=65; //给定的第6个数    
    

  9.       unsigned char x7=75; //给定的第7个数    
    

  10.       unsigned char x8=85; //给定的第8个数  
    


  11. 

  12.       unsigned char a=0; //统计从70到80的变量总数
    

  13.       unsigned char b=0; //统计除了70到80以外的变量总数
    


  14. 

  15. void main() //主函数
    

  16. {
    

  17.       //第一部分:统计“从70到80之间的数有多少个。
    


  18. 

  19.   if(x1>=70&&x1<=80)  //如果条件为真，则执行下面大括号里面的语句。
    

  20.   {
    

  21.      a++;   //相当于a=a+1，用来统计从70到80的总数
    

  22.   }
    


  23. 

  24.   if(x2>=70&&x2<=80)  //如果条件为真，则执行下面大括号里面的语句。
    

  25.   {
    

  26.      a++;   //相当于a=a+1，用来统计从70到80的总数
    

  27.   }
    


  28. 

  29.   if(x3>=70&&x3<=80)  //如果条件为真，则执行下面大括号里面的语句。
    

  30.   {
    

  31.      a++;   //相当于a=a+1，用来统计从70到80的总数
    

  32.   }
    


  33. 

  34.   if(x4>=70&&x4<=80)  //如果条件为真，则执行下面大括号里面的语句。
    

  35.   {
    

  36.      a++;   //相当于a=a+1，用来统计从70到80的总数
    

  37.   }
    


  38. 

  39.   if(x5>=70&&x5<=80)  //如果条件为真，则执行下面大括号里面的语句。
    

  40.   {
    

  41.      a++;   //相当于a=a+1，用来统计从70到80的总数
    

  42.   }
    


  43. 

  44.   if(x6>=70&&x6<=80)  //如果条件为真，则执行下面大括号里面的语句。
    

  45.   {
    

  46.      a++;   //相当于a=a+1，用来统计从70到80的总数
    

  47.   }
    


  48. 

  49.   if(x7>=70&&x7<=80)  //如果条件为真，则执行下面大括号里面的语句。
    

  50.   {
    

  51.      a++;   //相当于a=a+1，用来统计从70到80的总数
    

  52.   }
    


  53. 

  54.   if(x8>=70&&x8<=80)  //如果条件为真，则执行下面大括号里面的语句。
    

  55.   {
    

  56.      a++;   //相当于a=a+1，用来统计从70到80的总数
    

  57.   }
    


  58. 

  59.        //第二部分:统计除了70到80之间以外的数有多少个。
    


  60. 

  61.   if(x1<70||x1>80)  //如果条件为真，则执行下面大括号里面的语句。
    

  62.   {
    

  63.      b++;   //相当于b=b+1，用来统计除了70到80以外的总数
    

  64.   }
    


  65. 

  66.   if(x2<70||x2>80)  //如果条件为真，则执行下面大括号里面的语句。
    

  67.   {
    

  68.      b++;   //相当于b=b+1，用来统计除了70到80以外的总数
    

  69.   }
    


  70. 

  71.   if(x3<70||x3>80)  //如果条件为真，则执行下面大括号里面的语句。
    

  72.   {
    

  73.      b++;   //相当于b=b+1，用来统计除了70到80以外的总数
    

  74.   }
    


  75. 

  76.   if(x4<70||x4>80)  //如果条件为真，则执行下面大括号里面的语句。
    

  77.   {
    

  78.      b++;   //相当于b=b+1，用来统计除了70到80以外的总数
    

  79.   }
    


  80. 

  81.   if(x5<70||x5>80)  //如果条件为真，则执行下面大括号里面的语句。
    

  82.   {
    

  83.      b++;   //相当于b=b+1，用来统计除了70到80以外的总数
    

  84.   }
    


  85. 

  86.   if(x6<70||x6>80)  //如果条件为真，则执行下面大括号里面的语句。
    

  87.   {
    

  88.      b++;   //相当于b=b+1，用来统计除了70到80以外的总数
    

  89.   }
    


  90. 

  91.   if(x7<70||x7>80)  //如果条件为真，则执行下面大括号里面的语句。
    

  92.   {
    

  93.      b++;   //相当于b=b+1，用来统计除了70到80以外的总数
    

  94.   }
    


  95. 

  96.   if(x8<70||x8>80)  //如果条件为真，则执行下面大括号里面的语句。
    

  97.   {
    

  98.      b++;   //相当于b=b+1，用来统计除了70到80以外的总数
    

  99.   }
    


  100. 

  101.      View(a);  //把第1个数a发送到电脑端的串口助手软件上观察。
    

  102.      View(b);  //把第2个数b发送到电脑端的串口助手软件上观察。
    


  103. 

  104.      while(1)  
    

  105.      { 
    

  106.      }
    

  107. }
    


  108. 

  109. /*---C语言学习区域的结束。-----------------------------------------------*/


       在电脑串口助手软件上观察到的程序执行现象如下：
复制
  1. 开始...
    


  2. 

  3. 第1个数
    

  4. 十进制:2
    

  5. 十六进制:2
    

  6. 二进制:10
    


  7. 

  8. 第2个数
    

  9. 十进制:6
    

  10. 十六进制:6
    

  11. 二进制:110



分析：        
       变量a为2。（数值从70到80之间的有x4, x7这2个）
       变量b为6。（除了70到80之间以外的有x1, x2,x3,x5, x6, x8这6个）
       通过实验结果，发现在单片机上的实验结果和我们的分析是一致的。

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

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

本帖子中包含更多资源

您需要 登录 才可以下载或查看，没有账号？注册

×
回复

收藏269 举报

 楼主| jianhong_wu 发表于 2016-11-13 09:35 | 显示全部楼层
第四十四节：小括号改变判断优先级。

【44.1   小括号的概述。】

       小括号在C语言里一直有“强制、改变优先级、明确顺序”这层含义。C语言中，凡是在判断语句里插入了小括号，程序就会优先执行最里面小括号的判断语句，之后才会根据判断符的优先级执行其它相关语句。
       此功能很实用，因为C语言的判断符号众多，非常不利于程序员**各种不同符号的优先级顺序，而小括号却解决了这个问题。只要在合适的地方插入恰当的小括号，就可以强制改变判断的优先级，有了此项功能就不用程序员再刻意去**繁杂的优先级，同时，也为实际项目带来两个好处，一个是明确判断顺序，另一个是改变判断顺序。多说一句，哪怕添加的小括号是多余的重复的啰嗦的，也不会对程序带来副作用，反而，只会给程序员内心带来更大的确定和安全感。比如：
       两个if条件判断语句：
复制
  1.        if(a>=70&&a<=80)和if(a<70||a>80)


       有一些朋友喜欢插入两个小括号变成：
复制
  1.        if((a>=70)&&(a<=80))和if((a<70)||(a>80))


       在这里插入的小括号是多余的重复的啰嗦的，但是还好，不会对程序有副作用。上述的修改，在不知道 “>、>=、<、<=” 这类语句跟 “&&,||” 这类语句哪个优先级更高的前提下，插入了小括号，可以更加明确判断的顺序，这种做法也值得肯定。

【44.2   小括号的具体应用。】

       我个人平时在面对同时存在“>、>=、<、<=”和 “&&、||” 这些语句时，由于我很清楚“>,>=,<,<=”比“&&,||” 这类语句的优先级更高，所以我不需要在此插入小括号来明确判断的顺序。但是遇到下面这种情况，我是一定会通过插入小括号的方式来明确判断的顺序。什么情况呢？如下：

复制
  1.        if(“判断条件1”||“判断条件2 ”&&“判断条件3”)

       这种情况下，就会很容易让我出现一个疑问，到底是先“判断条件1” 跟“判断条件2”相“或”，最后再跟“判断条件3”相“与”？还是先“判断条件2” 跟“判断条件3”相“与”，最后再跟“判断条件1”相“或”？如果此时果断插入小括号，就可以很容易明确它们的先后顺序，减少内心不必要的纠结。

       插入小括号的第1种情况：
复制
  1.         if(（“判断条件1”||“判断条件2 ”）&&“判断条件3”)


       插入小括号的第2种情况：
复制
  1.        if(“判断条件1”||（“判断条件2 ”&&“判断条件3”）)


      上述两种情况，具体选择哪一种判断顺序要根据项目的需要来决定。同样的3个“判断条件”，如果插入的小括号的位置不一样，判断的顺序就不一样，那么结果也可能出现不一样，比如，上述判断条件：
       假设“判断条件1”为“真”，
       假设“判断条件2”为“真”，
       假设“判断条件3”为“假”，
       等效成如下：

       插入小括号的第1种情况：
复制
  1. if(（真||真）&&假)
    

  2. {
    

  3.    语句1;
    

  4. }

       这种情况下，先判断最里面小括号的真假，（真||真）的结果是“真”，然后再把结果“真”和外面的“假”进行“与”判断，(真&&假)的结果是“假”，所以上述的最终判断是“假”，不能执行“语句1”。

       插入小括号的第2种情况：
复制
  1. if(真||（真&&假）)
    

  2. {
    

  3.    语句1;
    

  4. }

       这种情况下，先判断最里面小括号的真假，（真&&假）的结果是“假”，然后再把结果“假”和外面的“真”进行“或”判断，(真||假)的结果是“真”，所以上述的最终判断是“真”，能执行“语句1”。

       综合上述两种情况，对比之后，得出这样的结论：在同样的条件和关系下，如果插入不同位置的小括号，就可以得出不同的结果。也就是说，小括号可以让关系判断变得丰富起来，可以实现各种复杂的逻辑判断功能。

【44.3   例程练习和分析。】

       现在编写一个实验程序验证上述两种判断顺序。
       程序代码如下：

复制
  1. /*---C语言学习区域的开始。-----------------------------------------------*/
    


  2. 

  3.       //x,y这三个变量作为条件判断的变量
    

  4.       unsigned char x=5; 
    

  5.       unsigned char y=6;
    


  6. 

  7.      //a,b这两个变量作为输出判断结果的真假，0代表假，1代表真。
    

  8.       unsigned char a=0;  //默认为0，也就是默认为假
    

  9.       unsigned char b=0;  //默认为0，也就是默认为假
    


  10. 

  11. void main() //主函数
    

  12. {
    

  13.   if((x<y||y>x)&&x==y) //里面的条件是((真||真)&&假)，最终结果判断是假
    

  14.   {
    

  15.      a=1;
    

  16.   } 
    


  17. 

  18.   if(x<y||(y>x&&x==y)) //里面的条件是(真||(真&&假))，最终结果判断是真
    

  19.   {
    

  20.      b=1;
    

  21.   } 
    


  22. 

  23.      View(a);  //把第1个数a发送到电脑端的串口助手软件上观察。
    

  24.      View(b);  //把第2个数b发送到电脑端的串口助手软件上观察。
    


  25. 

  26.      while(1)  
    

  27.      { 
    

  28.      }
    

  29. }
    


  30. 

  31. /*---C语言学习区域的结束。-----------------------------------------------*/


       在电脑串口助手软件上观察到的程序执行现象如下：
复制
  1. 开始...
    


  2. 

  3. 第1个数
    

  4. 十进制:0
    

  5. 十六进制:0
    

  6. 二进制:0
    


  7. 

  8. 第2个数
    

  9. 十进制:1
    

  10. 十六进制:1
    

  11. 二进制:1


分析：        
       变量a为0。（0代表此条件判断结果为假）
       变量b为1。（1代表此条件判断结果为真）
       通过实验结果，发现在单片机上的实验结果和我们的分析是一致的。

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

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

本帖子中包含更多资源

您需要 登录 才可以下载或查看，没有账号？注册

×
回复

收藏269 举报

xxbtop 发表于 2016-11-17 12:35 | 显示全部楼层
非常佩服楼主的毅力，不管怎么样。为很多人带来了帮助。可敬！！！！
回复

收藏269 举报

我爱你的吻123 发表于 2016-11-17 22:56 | 显示全部楼层
楼主在开帖之前我就来坐过板凳，现在一如继往的支持你。希望越来越好。。。。。。
回复

收藏269 举报

下一页 »
1 ...67891011121314... 34下一页
返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 注册

本版积分规则

快速回复 在线客服 返回列表 返回顶部