精华内容
下载资源
问答
  • shell编程之流程控制-循环语句循环语句介绍循环语句 - forfor C格式语法for 嵌套 iffor 嵌套 forfor 与数组遍历循环控制循环控制 - sleep(控制)循环控制 - break(打断)循环控制 - continue(跳过某次循环)脚本...

    循环语句介绍

    循环语句介绍:

    工作中总有一些重复性的工作,比如每天都需要执行的备份、每天分析一次业务的日志、每分钟需要检测一次主机状态等等。这些重复性的工作一般使用脚本来完成

    对于不需要太频繁执行的任务,可以使用计划任务 + 脚本来完成;但是计划任务时间只能精确到分钟,不能满足更频繁的重复工作。这时候就需要在脚本中使用循环语句

    脚本在执行任务,总会遇到需要循环执行的时候。比如说我们需要每个五分钟执行一次ping的操作。除了计划任务,我们还可以使用脚本来完成,这时候就用到循环语句了

    循环语句的优点:

    • 节省内存的调用,使用循环语句减少代码量
    • 结构更清晰
    • 节省开发时间成本

    串行变成并行的执行方法: &

    • 在执行语句后面加上 & 符就代表放入后台执行,前台执行下一个循环语句,这样就不用等待上一条循环语句执行完成再执行下一次循环。

    循环语句 - for

    特点: 满足条件就执行循环,已知条件循环次数

    for 的应用场景: 通过条件明确循环次数

    for 语法: 循环主体是 do~done 之间的内容,赋值 和 变量 可以有意义也可以没有意义(只是用于循环的次数而已)

    for 循环赋值:

    • 直接赋值:for i in 1 2 3
    • 来自一个范围:for i in {1..10}
    • 来自一个命令:for i in $(seq 10)
      注意: for 条件中无法使用shell运算

    for 循环语法格式:

    命令格式:
    #	 for var in {list}
    #		do
    #			command
    #			command
    #			..
    #		done
    
    		参数说明:
    			var:变量名,容器
    			{list}:往变量里边存入的值,{list}值可以有意义也可以没有意义
    	
    	语法说明:
    		{list} 中的值每存入一次 var 中,就会执行一遍do和done之间的代码。即有几个值就循环多少次
    
    
    演示:
    	for i in 1 q w e 3 4 s s s e
    		do
    			echo "hello word"
    		done
    
    	=>	演示代码表示输出10"hello word";代码中可以不调用var变量
    
    
    
    
    赋值方法:
    	赋值来自一个范围:
    		# for i in {1..10}
    
    	赋值来自一个命令:
    		# for i in `seq 10`# for i in $(seq 10)
    
    	直接赋值:
    		# for i in 1 2 3 4 5 6 7 8 9 10
    

    for C格式语法

    • 仿C语言的for风格,双小圆
    • 表达式可以与两边括号有空格也可以无空格
    • ((初始值;条件;自增或自减运算))
    • 注意:for 条件不能和shell的运算混合使用

    for C格式语法说明:

    • for ((;;)):代表永远为真,死循环
    命令格式:
    #	for (( expr1;expr2;expr3 ))
    #	 	do
    #	 		command
    #	 		command
    #	 		...
    #	 	done
    			选项说明:
    				expr1:变量的初始值
    				expr2:变量的条件。绝对是否进行循环的依据
    				expr3:自增或自减运算(绝对循环什么时候退出)
    
    #l	多变量用法:
    #		for (( a=1,b=10;a<10,b>5;a++,b-- ))		=>	注意同一个表达式用,隔开
    				=>	其中某一个不满足就会结束循环体
    
    
    演示:	
    	for (( i=1;i<=5;i++ ))		=>for i in {1..5} 类似
    		do
    			echo $i
    		done
    

    for 嵌套 if

    通过有一个打印1-100的奇数和小脚本演示for 嵌套 if

    for 嵌套 if 说明:

    编写脚本:
    	# vim for_if.sh
    		[root@server ~]# vim for_if.sh
    			#!/bin/bash
    			# 将1-100通过for赋值给变量
    			num=0
    			for i in $(seq 1 100)
    			  do
    			# 判断变量赋值i是否为奇数,是为真
    			     if (( $i%2 != 0 ))
    			        then
    			# 将奇数取出,用let命令将奇数相加
    			# 注意:num不需要加$符号
    			             let num+=$i
    			     fi
    			  done
    			
    			# 打印1-100奇数和
    			echo $num
    
    运行脚本:
    	# sh for_if.sh		
    		[root@server ~]# sh for_if.sh
    			2500	
    

    for 嵌套 for

    通过编写一个9*9乘法表来理解 for 嵌套 for 循环

    注意:

    • 计算机是按行打印的
    • 外循环执行结束后就打印一行
    • 内循环就是打印列

    for 嵌套 for 循环编写9*9乘法表说明:

    编写9*9乘法表脚本:
    	# vim Mt_99.sh
    		[root@server ~]# vim Mt_99.sh
    			#!/bin/bash
    			# 外循环,9*9乘法表有九行,所以取值是1-9
    			for ((A=1;A<10;A++))
    			  do
    			
    			# 内循环,明确只有内循环执行完毕才返回外循环执行
    			# 根据9*9乘法表,明确内循环的取值也是1-9
    			# 但是内循环的取值是与外循环有关,一列一行,两列两行..九列九行
    			      for ((B=1;B<=A;B++))
    			       do
    			# 打印输出
    			          echo -n -e "$B*$A=$((A*B))\t"
    			       done
    			      echo
    
    
    运行脚本:
    	# sh Mt_99.sh
    		[root@server ~]# sh Mt_99.sh
    			1*1=1
    			1*2=2   2*2=4
    			1*3=3   2*3=6   3*3=9
    			1*4=4   2*4=8   3*4=12  4*4=16
    			1*5=5   2*5=10  3*5=15  4*5=20  5*5=25
    			1*6=6   2*6=12  3*6=18  4*6=24  5*6=30  6*6=36
    			1*7=7   2*7=14  3*7=21  4*7=28  5*7=35  6*7=42  7*7=49
    			1*8=8   2*8=16  3*8=24  4*8=32  5*8=40  6*8=48  7*8=56  8*8=64
    			1*9=9   2*9=18  3*9=27  4*9=36  5*9=45  6*9=54  7*9=63  8*9=72  9*9=81
    

    for 与数组遍历

    • 需要注意数组的索引号

    for 与数组遍历存取说明:

    通过for 编写存取数组脚本:
    	# vim for_array.sh
    			[root@server ~]# vim for_array.sh
    				#!/bin/bash
    				# 通过for循环对数组进行存值
    				# 存入3人的成绩,并放入数组,需要注意数组的索引号
    				for i in `seq 0 2`
    				   do
    				        read -p "ID:" ID[$i]
    				        read -p "姓名:" name[$i]
    				        read -p "性别:"  gender[$i]
    				        read -p "成绩:" grades[$i]
    				   done
    				echo -e "ID\t姓名\t性别\t成绩"
    				# 打印数组的值
    				for i in `seq 0 2`
    				   do
    				        echo -e "${ID[$i]}\t${name[$i]}\t${gender[$i]}\t${grades[$i]}"
    				   done
    
    
    运行效果:
    	# sh for_array.sh
    			[root@server ~]# sh for_array.sh
    			ID:1
    			姓名:李白
    			性别:男
    			成绩:98
    			ID:2
    			姓名:杜甫
    			性别:男
    			成绩:95
    			ID:3
    			姓名:苏轼
    			性别:男
    			成绩:99
    			ID      姓名    性别    成绩
    			1       李白    男      98
    			2       杜甫    男      95
    			3       苏轼    男      99	
    

    循环控制

    循环控制 - sleep(控制)

    • 控制循环的节奏,即控制循环的频率

    通过一个死循环查看sleep的作用:

    编写sleep控制语句脚本:
    	# vim End_loop.sh
    		[root@server ~]# vim End_loop.sh
    			#!/bin/bash
    			# 条件里面写;;永远为真
    			for ((;;))
    			 do
    			    echo "ok"
    			# 使用sleep控制循环,避免狂吃资源,sleep单位是秒
    			    sleep 0.001
    			 done	
    

    加入sleep语句控制循环的效果:
    在这里插入图片描述

    循环控制 - break(打断)

    • 跳出循环,执行这个循环后面的代码

    break 打断循环说明:

    编写打印1-7的脚本:
    	break 打断效果:	
    		# vim break.sh	
    			[root@server ~]# vim break.sh	
    				#!/bin/bash
    				# 打印1-5的信息
    				for i in `seq 1 7`
    				 do
    				    echo $i				
    				# 当i=3就结束循环,执行循环后面的代码
    				    if [ $i -eq 3 ]
    				      then
    				           break
    				    fi
    				 done
    				# break 打断后执行循环后面的代码				
    				echo "执行完毕"
    
    
    运行效果:
    	# sh break.sh		
    		[root@server ~]# sh break.sh
    			1
    			2
    			3
    			执行完毕
    

    循环控制 - continue(跳过某次循环)

    • 当代码运行到 break 后,跳过当次循环。循环体内break 后面的代码不执行,重新开始下一次循环

    break 跳过某次循环说明:

    编写打印1-5的脚本:
    	continue 跳过某次循环效果:
    		# vim continue.sh
    			[root@server ~]# vim continue.sh	
    				#!/bin/bash
    				# 打印1-5的信息
    				for i in $(seq 5)
    				  do
    				# 当i=3的时候跳过这次循环,重新开始循环
    				      if [ $i -eq 3 ]
    				         then
    				              continue
    				      fi
    				# 打印信息
    				       echo $i
    				  done
    				echo "打印完毕"
    
    
    运行效果:
    	# sh continue.sh
    		[root@server ~]# sh continue.sh
    			1
    			2
    			4
    			5
    			打印完毕
    

    脚本退出命令 - exit

    • 代码运行到exit命令,直接退出脚本程序,不再执行。

    • 退出程序,释放所有该执行该脚本时所申请的资源

    exit 退出程序说明:
    	exit 退出程序效果:
    		# vim exit.sh
    			[root@server ~]# vim exit.sh
    				#!/bin/bash
    				# 打印1-5的信息
    				for i in $(seq 5)
    				  do
    				# 当i=3的时候直接退出程序
    				      if [ $i -eq 3 ]
    				         then
    				              exit
    				      fi
    				# 打印信息
    				       echo $i
    				  done
    				echo "打印完毕"
    
    
    运行效果:
    	# sh exit.sh			=>	直接退出程序了,循环体外下面的代码也不执行
    		[root@server ~]# sh exit.sh
    			1
    			2
    

    参数控制命令 - shift

    • 使位置参数向左移动,默认每次移动一位
    • shift 2 向左移动两位

    shift 参数控制说明:

    通过外部传参理解shift:
    	编写脚本:
    		# vim shift.sh
    			[root@server ~]# vim shift.sh
    				#!/bin/bash
    				for i in `seq 1 $#`
    				  do
    				     echo "当前参数数量:$#"
    				     echo "脚本后面的参数:$@"
    				     echo "第一个参数:$1"
    				# 通过shift让循环每执行一次参数向左移动一位
    				# shift 使参数默认向左移动一位
    				#     shift
    				# shift 2 使参数向左
    				#     shift 2
    				  done
    
    
    
    运行脚本:
    #l	不加 shift 时:
    		[root@server ~]# sh shift.sh 1 2 3
    			当前参数数量:3
    			脚本后面的参数:1 2 3
    			第一个参数:1
    			当前参数数量:3
    			脚本后面的参数:1 2 3
    			第一个参数:1
    			当前参数数量:3
    			脚本后面的参数:1 2 3
    			第一个参数:1
    
    #l	使用 shift 时:
    		[root@server ~]# sh shift.sh 1 2 3
    			当前参数数量:3
    			脚本后面的参数:1 2 3
    			第一个参数:1
    			当前参数数量:2
    			脚本后面的参数:2 3
    			第一个参数:2
    			当前参数数量:1
    			脚本后面的参数:3
    			第一个参数:3
    
    #l	使用 shift 2 时:
    		[root@server ~]# sh shift.sh 1 2 3
    			当前参数数量:3
    			脚本后面的参数:1 2 3
    			第一个参数:1
    			当前参数数量:1
    			脚本后面的参数:3
    			第一个参数:3
    			当前参数数量:1
    			脚本后面的参数:3
    			第一个参数:3
    

    循环语句 - while

    特点: 条件为真时就进入循环,条件为假就退出循环

    while的应用场景: 一般应用在未知循环次数的环境

    • while 语法表达式需要注意空格

    while 循环语法格式:

    命令格式:
    #	while [ 表达式 ]		=>	[ 1 -eq 1 ] 可以变成 (( 1=1 ))
    #		do
    #			command
    #			...
    #		done
    		
    

    while 与 shell 运算(比较运算)

    • while 可以和整数浮点数字符串文件类型进行比较运算

    while 与 整数的比较运算

    while 与 整数的比较运算说明:

    编写脚本:
    	# vim while_integer.sh	
    		[root@server ~]# vim while_integer.sh
    			#!/bin/bash
    			# 给定一个变量,当变量满足打印信息
    			a=0
    			# 当a小于4就执行循环
    			while [ $a -le 4 ];do
    			    echo "$a"
    			   let a++
    			done
    
    运行脚本:
    	# sh while_integer.sh
    		[root@server ~]# sh while_integer.sh
    			0
    			1
    			2
    			3
    			4
    

    while 与 浮点数的比较运算

    while 与 浮点数的比较运算说明:

    编写代码:通过外传参对两个浮点数进行比较
    	# vim while_float.sh	
    		[root@server ~]# vim while_float.sh
    			#!/bin/bash
    			# 通过外部传参对两个浮点数进行整数转换
    			num1=`echo -e "scale=2;$1*100"|bc|cut -d "." -f1`
    			num2=`echo -e "scale=2;$2*100"|bc|cut -d "." -f1`
    			
    			# 对整数进行比较,小于
    			while [ $num1 -lt $num2 ];do
    			      echo -e "$1 < $2"
    			      exit
    			done
    			
    			# 对整数进行比较,大于
    			while [ $num1 -gt $num2 ];do
    			      echo -e "$1 > $2"
    			      exit
    			done
    			
    			# 对整数进行比较,等于
    			while [ $num1 -eq $num2 ];do
    			      echo -e "$1 = $2"
    			      exit
    			done
    
    
    运行脚本:
    	[root@server ~]# sh while_float.sh 1.1 2.3
    		1.1 < 2.3
    	[root@server ~]# sh while_float.sh 34.21 23.87
    		34.21 > 23.87
    	[root@server ~]# sh while_float.sh 34.23 34.23
    		34.23 = 34.23
    
    

    while 与 字符串的比较运算

    while 与 字符串比较说明:

    编写脚本:
    	# vim while_string.sh
    		[root@server ~]# vim while_string.sh
    			#!/bin/bassh
    			# 模拟用户账号登录,只有账号正确才能跳出循环,否则不断循环
    			read -p "$HOSTNAME login:" account
    			while [ "$account" != "root" ];do
    			
    			       echo "请重新输入"
    			       read -p "$HOSTNAME login:" account
    			done
    			
    			# 账号输入正确打印信息
    			while [ "$account" = "root" ];do
    			
    			       echo "账号正确"
    			       break
    			done
    
    
    
    
    运行脚本:
    	# sh while_string.sh
    		root@server ~]# sh while_string.sh
    			server login:sfd
    			请重新输入
    			server login:riit
    			请重新输入
    			server login:root
    	
    

    while 与 逻辑运算的比较运算

    逻辑运算符:与(&&)或(||)非(!)

    • 逻辑与:必须全部条件满足,表达式才判断为真

    • 逻辑或:至少有一个条件满足,表达式才判断为真

    • 逻辑非:条件为真时,表达式判断为假;条件为假时,表达式判断为真

    while 与 逻辑运算说明:

    编写一个丈母娘根据要求招女婿的小脚本:
    	# vim mom_in_son.sh
    		[root@server ~]# vim mom_in_son.sh
    			#!/bin/bash
    			# 面试相亲人的条件
    			read -p "几套房子?:" house
    			read -p "几辆车子?:" car
    			read -p "存款有多少?:" money
    			
    			# 相亲条件是房子必须有两套,车子两辆,存款必须一百万以上。
    			# 不符合条件的,用while循环重新面试下一位
    			while [ $house -lt 1 ] || [ $car -lt 1 ] || [ $money -lt 1000000 ];do
    			
    			        echo "下一位"
    			        read -p "几套房子?:" house
    			        read -p "几辆车子?:" car
    			        read -p "存款有多少?:" money
    			done
    						
    			echo "你通过初步面试了,下一步面试你人品,等消息"
    
    
    
    运行脚本:
    	# sh mom_in_son.sh		
    		[root@server ~]# sh mom_in_son.sh
    			几套房子?:2
    			几辆车子?:2
    			存款有多少?:100000
    			下一位
    			几套房子?:3
    			几辆车子?:3
    			存款有多少?:1000001
    			你通过初步面试了,下一步面试你人品,等消息
    

    while 的特殊条件:永真或永假

    ::条件是冒号,永远为真
    ture条件是ture,永远为真
    false条件是salse,永远为假

    适用于无尽循环环境使用

    while 特殊条件说明:

    命令格式:
    	# while =>	永远为真
    		do
    			command
    			..
    		done
    	
    
    	# while true		=>	永远为真
    			do
    			command
    			..
    		done
    
    
    	# while false		=>	永远为假
    			do
    			command
    			..
    		done
    

    while 嵌套

    while 嵌套 if

    应用场景: while 循环需要判断条件的时候

    条件不要写冲突了

    while 嵌套 if说明:

    命令格式:
    #	while [ condition1 ]
    #		do
    #			command
    #			...
    #			if [ condition2 ]
    #				then
    #					command
    #					...
    #			fi
    #		done
    
    
    编写一个while 嵌套 if 的脚本:
    	# vim while_if.sh
    		[root@server ~]# vim while_if.sh
    			/bin/bash
    			# 打印1-5的信息,跳过3
    			i=0
    			while [ $i -lt 5 ];do
    			    let i++
    			       if [ $i -eq 3 ];then
    			         continue
    			       fi
    			
    			    echo "$i"
    			done
    
    
    
    运行脚本:
    	# sh while_if.sh
    		[root@server ~]# sh while_if.sh
    			1
    			2
    			4
    			5
    

    while 嵌套 for

    应用场景: 多次循环场景中,内循环需要依赖内循环

    while 嵌套 for 打印九九乘法表:

    编写脚本:
    	# cat while_for.sh
    		[root@server ~]# cat while_for.sh
    			#!/bin/bash
    			A=1
    			# 外循环
    			while [ $A -le 9 ];do
    			# 内循环
    			     for ((B=1;B<=A;B++));do
    			        echo -n -e  "$B*$A=`expr $A\*$B`\t"
    			        done
    			      let A++
    			# 换行
    			      echo
    			done
    
    
    运行脚本:
    	
    

    while 嵌套 while

    应用场景: 多次循环场景中,内循环需要依赖内循环

    while 嵌套 while 打印九九乘法表:

    编写脚本:
    	# vim while_while.sh
    		[root@server ~]# vim while_while.sh
    			#!/bin/bash
    			A=1
    			# 外循环
    			while [ $A -lt 10 ];do
    			     B=1
    			# 内循环
    			    while [ $B -le $A ];do
    			      echo -n -e "$B*$A=$((A*B))\t"
    			      let B++
    			     done
    			     let A++
    			# 换行,显示
    			     echo
    			done
    
    
    运行脚本:
    	# sh while_while.sh
    		[root@server ~]# sh while_while.sh
    			1*1=1
    			1*2=2   2*2=4
    			1*3=3   2*3=6   3*3=9
    			1*4=4   2*4=8   3*4=12  4*4=16
    			1*5=5   2*5=10  3*5=15  4*5=20  5*5=25
    			1*6=6   2*6=12  3*6=18  4*6=24  5*6=30  6*6=36
    			1*7=7   2*7=14  3*7=21  4*7=28  5*7=35  6*7=42  7*7=49
    			1*8=8   2*8=16  3*8=24  4*8=32  5*8=40  6*8=48  7*8=56  8*8=64
    			1*9=9   2*9=18  3*9=27  4*9=36  5*9=45  6*9=54  7*9=63  8*9=72  9*9=81
    

    循环语句 - until(条件为假执行循环)

    类似while循环,区别是while循环条件为真执行循环,until循环条件为假执行循环

    特点:条件为假执行循环

    until 语法格式:

    命令格式:
    #	until [ condition]
    #		do
    #			command
    #			...
    #		done
    
    演示:
    	编写脚本:
    	# vim until.sh
    		[root@server ~]# vim until.sh
    			#!/bbin/bash
    			# 当条件为假的时候执行until循环
    			a=1
    			until [ $a != 1 ];do
    			  echo "我是假的也打印"
    			  break
    			done
    	
    
    	运行脚本:
    		# sh until.sh
    			[root@server ~]# sh until.sh
    				我是假的也打印	
    
    展开全文
  • 《单片机C语言常用语句详解》由会员分享,可在线阅读,更多相关《单片机C语言常用语句详解(22页珍藏版)》请在人人文库网上搜索。1、C51编程中常见语句的总结。首先,C51定义了sfr定义方法:两个关键字:sfr和sbit 1...

    《单片机C语言常用语句详解》由会员分享,可在线阅读,更多相关《单片机C语言常用语句详解(22页珍藏版)》请在人人文库网上搜索。

    1、C51编程中常见语句的总结。首先,C51定义了sfr定义方法:两个关键字:sfr和sbit 1。为特殊功能寄存器定义SFR,例如:sfr PSW=0 xD0;/*将程序状态字PSW的地址定义为d0h */sfrtmod=0x89。/*将定时器/计数器模式控制寄存器TMOD的地址定义为89H */sfr P1=0 x90;/*将P1港的地址定义为90H*/2。定义特殊功能寄存器的位,这些位可以通过位来寻址。例如:sbit CY=0 xD7;/*将进位标志CY的地址定义为D7H */sbit AC=0 xD06;/*将辅助进位标志AC的地址定义为D6H */sbit RS0=0 xD03;/* R。

    2、S0的地址被定义为D3H*/,并且在头文件中定义了标准的SFR,例如reg51.h和reg52.h,只要通过文件包含声明,就可以使用它们。示例:# include sbit P10=P10sbit P12=P12main()P10=1;P12=0。PSW=0x 08;第二,C51使用关键字定义位变量,如位锁;/*将锁定义为位变量*/bit direction;/*将方向定义为位变量*/注意:无法定义位变量指针;您不能定义位变量数组。C51编程中常见语句的总结,C51流量控制语句,1。选择语句1.if语句有以下三种形式:if(表达式)语句;If(表达式)语句1;Else语句2;If(表达式1)语。

    3、句1;否则,如果(表达式2)语句2;否则,如果(表达式3)语句3;否则if(表达式n)语句n;Else语句n1;C51过程控制语句,示例1: if (P1!=0)c=20;例2:如果(P1!=0)c=20;否则c=0;例3:如果(a=1)c=10;否则,如果(a=2)c=20;否则,如果(a=3)c=30;否则,如果(a=4)c=40;否则c=0;switch/case语句的一般形式如下:switch(表达式)case常量表达式1:语句1;休息;案例常量表达式2:语句2;休息;大小写常量表达式n:语句n;休息;默认:语句n1;C51流量控制语句,例如:单片机P1端口的P1.0和P1.1分别与开。

    4、关K1和K2连接,P1.4、P1.5、P1.6和P1.7分别与发光二极管连接。K1和K2有不同的状态来确定哪个发光二极管点亮。C51流控制语句,方法1:用if语句实现# include void main()char a;a=P1;A=a/*屏蔽高位6位*/if(a=3)P1=0x 83;否则,如果(a=2)P1=0x 43;否则如果(a=1)P1=0 x23;否则P1=0 x13;C51流控制语句,方法2:用switch/case语句实现# include void main()char a;a=P1;A=a/*掩码高位6位*/开关(a)情况3:P1=0x 83;休息;案例2:P1=0x 4。

    5、3;休息;案例1:P1=0 x23;休息;案例0:P1=0x 13;C51流控制语句、循环语句、if语句和goto语句、goto语句只能构成一个简单的循环,并且与if语句一起,既可以实现when-type循环,也可以实现直到-type循环。形成等价的循环:if(表达式)语句gotoloop形成一个直到型循环:语句if(表达式)gotoloop,C51流控制语句,while语句while语句通用格式:while语句do-while语句do-while语句通用格式:do语句while(表达式);for语句的一般形式:for(表达式1;表达式2;表达式3)语句,例如:按键程序只能执行一次,循环程序用。

    6、于使其循环往复。用goto语句实现#include void main()字符a;循环:a=P1;A=a/*掩码高位6位*/开关(a)情况3:P1=0x 83;休息;案例2:P1=0x 43;休息;案例1:P1=0 x23;休息;案例0:P1=0x 13;goto循环;使用while语句实现# include void main()char a;而(1)a=P1;A=a/*掩码高位6位*/开关(a)情况3:P1=0x 83;休息;案例2:P1=0x 43;休息;案例1:P1=0 x23;休息;案例0:P1=0x 13;而条件总是1,表示无限循环。用do-while语句实现#include vo。

    7、id main()字符a;P1;条件总是1,这意味着一个无限循环。使用for语句实现# include void main()char a;用于(;)a=P1;A=a/*掩码高位6位*/开关(a)情况3:P1=0x 83;休息;案例2:P1=0x 43;休息;案例1:P1=0 x23;休息;案例0:P1=0x 13;for中的条件始终为真,表示无限循环。C51构造数据类型1。数组一维数组的定义类型描述符的数组名称元素的数量;例如,inta50一维数组int a5的初始化=1,2,3,4,5;/*为所有元素赋值*/int b6=1,2,6;/*为某些元素赋值*/intd10。d0=4;D1=6;。

    8、/*定义后,赋值*/,定义2D数组2D数组的类型描述符,数组名称的行数和列数;例如浮子a34;Int a34=1,2,3,4,5,6,7,8,9,10,11,12;/*初始化all */int a34=1,2,3,4,5,6,7,8;/*部分初始化,a20=a21=a22=a23=0*/C51也可以定义多维数组或字符数组。数组是一种非常有用的数据类型,可以用来形成一个易于查找的数据表。函数定义和分类标准库函数自定义函数自定义函数是用户根据自己的需要编写的函数。从函数定义的形式来看:非参数函数、参数函数和零函数。函数定义返回值类型函数名(形参表)函数体,例如:int max(int x,int 。

    9、y,int z)返回值的数据类型为整数,函数名为max,x,y,z为整数输入参数。C51编译器提供了丰富的库函数,大大提高了编程效率,用户可以根据需要随时调用。每个库函数的原型在相应的头文件中给出。使用它时,您只需要在源程序的开头用编译预处理命令#include包含相关的头文件。例如,要使用数学公式,只需使用#include文件将其包含在程序的开头。要访问SFR和SFR位,只需在程序开始时使用#include或#include文件即可。C51应用编程示例,示例:外部中断0引脚(P3.2)连接到开关,而P1.0连接到发光二极管。当开关闭合一次时,发光二极管会改变一次状态。这个例子解决了如何应用外部中断。要求:实现该功能的程序。#包括sbit P10=P10int I;空总管()EA=1;EX0=1;而(1);void int_srv()中断0使用1,而(INT0=0)用于(i=0,i220;而(INT0=0) P10=!P10而(INT0=0);本章要求掌握C51的数据类型、数据存储类型和存储模式、SFR的定义和C51的对位变量,这几个方面与标准C语言有很大的不同,其他规则与标准C语言基本一致。了解C51的库函数;我们应该特别注意C51如何操作基本输入/输出端口,如何操作位和特殊功能寄存器,并掌握定时器/计数器的应用和C51下中断的使用。

    展开全文
  • 第六章 选择语句循环语句、Debug第六章 选择语句循环语句、Debug6.1 流程控制6.1.1 分类6.1.2 顺序结构6.1.3 分支结构之if语句if语句第一种格式: ifif语句第二种格式: if...elseif语句第三种格式: if...else ...

    第六章 选择语句、循环语句、Debug

    6.1 流程控制

    在一个程序执行的过程中,各条语句的执行顺序对程序的结果是有直接影响的。所以,我们必须清楚每条语句的执行流程。而且,很多时候我们要通过控制语句的执行顺序来实现我们要完成的功能。

    6.1.1 分类

    • 顺序结构
    • 分支结构(if, switch)
    • 循环结构(for, while, do…while)

    6.1.2 顺序结构

    public static void main(String[] args){ 
    //顺序执行,根据编写的顺序,从上到下运行 
    System.out.println(1); 
    System.out.println(2); 
    System.out.println(3); 
    }
    

    6.1.3 分支结构之if语句

    if语句第一种格式: if

    if(关系表达式)
    {
     语句体;//其它语句
    
    • 执行流程
      (1) 首先计算关系表达式的值
      (2) 如果关系表达式的值为true就执行语句体
      (3) 如果关系表达式的值为false就不执行语句体
      (4) 继续执行后面的其他语句
      在这里插入图片描述
    public static void main(String[] args)
    { 
    System.out.println("开始"); 
    // 定义两个变量 
    int a = 10; 
    int b = 20; 
    //变量使用if判断 
    if (a == b)
    { 
    System.out.println("a等于b"); 
    }
    int c = 10; 
    if(a == c)
    { 
    System.out.println("a等于c"); 
    }
    System.out.println("结束");

    if语句第二种格式: if…else

    if(关系表达式) 
    { 
    语句体1; 
    } 
    else { 
    语句体2; 
    }//其它语句
    
    • 执行流程
      (1) 首先计算关系表达式的值
      (2) 如果关系表达式的值为true就执行语句体1
      (3) 如果关系表达式的值为false就执行语句体2
      (4) 继续执行后面的其他语句
      在这里插入图片描述
    public static void main(String[] args) {
    System.out.println("开始"); //定义两个变量 
    	int a = 10; 
    	int b = 20;
     	b = 5; //需求:判断a是否大于b,如果是,在控制台输出:a的值大于b,否则,在控制台输出:a的值不大于b 
     	if(a > b) { 
     System.out.println("a的值大于b");
      } else { 
      System.out.println("a的值不大于b"); 
      }
      System.out.println("结束");
       }
    
    
    • if-else案例
      • 需求:任意给出一个整数,请用程序实现判断该整数是奇数还是偶数,并在控制台输出该整数是奇数还是偶数。
      • 分析:
        ①为了体现任意给出一个整数,采用键盘录入一个数据
        ②判断整数是偶数还是奇数要分两种情况进行判断,使用if…else结构
        ③判断是否偶数需要使用取余运算符实现该功能 number % 2 == 0
        ④根据判定情况,在控制台输出对应的内容
      • 代码实现
    public static void main(String[] args) 
    { 
    //为了体现任意给出一个整数,采用键盘录入一个数据。(导包,创建对象,接收数据) 
    	Scanner sc = new Scanner(System.in); 
    	System.out.println("请输入一个整数:"); 
    	int number = sc.nextInt(); 
    	//判断整数是偶数还是奇数要分两种情况进行判断,使用if..else结构 
    	//判断是否偶数需要使用取余运算符实现该功能 number % 2 == 0 
    	//根据判定情况,在控制台输出对应的内容 
    	if(number%2 == 0) 
    	{ 
    	System.out.println(number + "是偶数");
    	 }
    	 else { System.out.println(number + "是奇数");
    	  } 
    	 }
    	 
    

    if语句第三种格式: if…else if …else

    if (关系表达式1) 
    { 
    语句体1; 
    } 
    else if (关系表达式2) 
    { 
    语句体2;
     }... 
     }else if (关系表达式n)
      { 语句体n; 
      } 
      else {
       语句体n+1; 
       }//其它语句
    
    • 执行流程
      (1) 首先计算关系表达式1的值,判断其结果是true还是false
      (2) 如果是true就执行语句体1
      (3) 如果是false就继续计算关系表达式2,判断其结果是true还是false
      (4) 如果是true就执行语句体2
      (5) 如果是false就继续计算关系表达式…,判断其结果是true还是false
      (6) …
      (7) 如果没有任何关系表达式为true,就执行语句体n+1
      在这里插入图片描述
    • 案例练习:
      • 需求:判断两个整数的大小关系
      • 分析:两个数字的关系有三种:大于 等于 小于
    public static void main(String[] args) 
    { 
    	//比较两个数字的大小 
    	int x = 3; 
    	int y = 4; 
    	if (x > y) 
    	{ 
    	System.out.println(x + "大于" + y); 
    	} else if (x < y) 
    	{ 
    	System.out.println(x + "小于" + y); 
    	} else { 
    	System.out.println(x + "等于" + y);
    	 } 
    	 }
    
    
    • 案例练习:
      • 需求:键盘录入一个星期数(1,2,…7),输出对应的星期一,星期二,…星期日
      • 规则:
        • 输入 1 输出 星期一
          输入 2 输出 星期二
          输入 3 输出 星期三
          输入 4 输出 星期四
          输入 5 输出 星期五
          输入 6 输出 星期六
          输入 7 输出 星期日
        • 输入 其它数字 输出 数字有误
    
    public static void main(String[] args) { 
    	System.out.println("开始");
     	// 需求:键盘录入一个星期数(1,2,...7),输出对应的星期一,星期二,...星期日 
     	System.out.println("请输入一个星期数(1~7):"); 
     	int week = 7; //这里目前没采用键盘录入方式赋值 
     	if(week == 1) { System.out.println("星期一"); } 
     	else if(week == 2) { System.out.println("星期二"); } 
     	else if(week == 3) { System.out.println("星期三"); }
     	 else if(week == 4) { System.out.println("星期四"); } 
     	 else if(week == 5) { System.out.println("星期五"); } 
     	 else if(week == 6) { System.out.println("星期六"); } 
     	 else if(week == 7) { System.out.println("星期六"); }
     	 else { System.out.println(" 数字有误"); }
     	 System.out.println("结束"); 
     	 }
    

    6.1.4 分支结构之switch

    switch语句结构

    switch(表达式)
    {
    case 取值 1: 语句块 1;break;
    case 取值 n: 语句块 n;break;
    default: 语句块 n+1;break;
    }

    switch 语句有关规则

    表达式的返回值必须是下述几种类型之一:int, byte, char, short,String;

    case 子句中的取值必须是常量,且所有 case 子句中的取值应是不同的;

    default 子句是可选的;

    break 语句用来在执行完一个 case 分支后使程序跳出 switch 语句块;如果 case 后面没有写
    break 则直接往下面执行!

    Case 后面的执行体可写{ }也可以不写{ }

    案例:根据用户输入的月份计算季节

    public class Demo05 {
        public static void main(String[] args) {
            Scanner scanner = new Scanner(System.in);
            System.out.println("请输入一个月份(1-12)" );
            int i = scanner.nextInt();
            switch (i){
                case 1:
                case 2:
                case 3:
                    System.out.println("春季");
                    break;
                case 4:
                case 5:
                case 6:
                    System.out.println("夏季");
                    break;
                case 7:
                case 8:
                case 9:
                    System.out.println("秋季");
                    break;
                case 10:
                case 11:
                case 12:
                    System.out.println("冬季");
                    break;
    
            }
        }
    }
    
    

    6.2 循环语句

    6.2.1 循环概述

    循环语句可以在满足循环条件的情况下,反复执行某一段代码,这段被重复执行的代码被称为循环体语句,当反复执行这个循环体时,需要在合适的时候把循环判断条件修改为false,从而结束循环,否则循环将一直执行下去,形成死循环。

    6.2.2 循环组成

    循环的组成(手写100遍HelloWorld案例):
    (1)【初始化表达式1】准备工作:笔墨伺候,最优先唯一执行一次的操作
    (2)【循环条件2】条件判断:每次书写前,判断一下,要不要写
    (3)【循环体3】循环所要进行的操作:手写一个HelloWorld案例
    (4)【步进表达式4】扫尾的工作:每写一次HelloWorld,计数(+1)

    6.2.3 循环语句–for

    • for循环语句格式:
    for(
    初始化表达式①; 
    布尔表达式②; 
    步进表达式④)
    { 
    循环体③ 
    }
    
    • 格式解释
      • 初始化语句: 用于表示循环开启时的起始状态,简单说就是循环开始的时候什么样
      • 条件判断语句:用于表示循环反复执行的条件,简单说就是判断循环是否能一直执行下去
      • 循环体语句: 用于表示循环反复执行的内容,简单说就是循环反复执行的事情
      • 条件控制语句:用于表示循环执行中每次变化的内容,简单说就是控制循环是否能执行下去
    • 执行流程
      • 执行顺序:①②③④>②③④>②③④…②不满足为止。
      • ①负责完成循环变量初始化
      • ②负责判断是否满足循环条件,不满足则跳出循环
      • ③具体执行的语句
      • ④循环后,循环条件所涉及变量的变化情况
        在这里插入图片描述
    public static void main(String[] args) { 
    	//控制台输出10次HelloWorld,不使用循环 
    	System.out.println("HelloWorld"); 
    	System.out.println("HelloWorld"); 
    	System.out.println("HelloWorld"); 
    	System.out.println("HelloWorld"); 
    	System.out.println("HelloWorld"); 
    	System.out.println("HelloWorld"); 
    	System.out.println("HelloWorld"); 
    	System.out.println("HelloWorld"); 
    	System.out.println("HelloWorld"); 
    	System.out.println("HelloWorld"); 
    	System.out.println("-------------------------"); 
    	//用循环改进,循环10次 //定义变量从0开始,循环条件为<10 
    	for(int x = 0; x < 10; x++) {
    	 System.out.println("HelloWorld"+x); 
    	 }
    	  }
    
    • for循环练习1:在控制台输出1-5和5-1的数据
    public static void main(String[] args) 
    { 
    	//需求:输出数据1-5 
    	for(int i=1; i<=5; i++)
    	 { System.out.println(i);
    	  }System.out.println("--------");
    	   //需求:输出数据5-1 
    	   for(int i=5; i>=1; i--) 
    	   { System.out.println(i); 
    	   }
    	    }
    
    • for循环练习2:求1-5之间的数据和,并把求和结果在控制台输出
    public static void main(String[] args) { 
    	//求和的最终结果必须保存起来,需要定义一个变量,用于保存求和的结果,初始值为0 
    	int sum = 0; 
    	//从1开始到5结束的数据,使用循环结构完成 
    	/* sum += i; //sum = sum + i; 
    	第一次:sum + i 是 0 + 1 ; sum结果为 1; 
    	第二次:sum + i 是 1 + 2 ; sum结果为 3; 
    	第三次:sum + i 是 3 + 3 ; sum结果为 6; 
    	第四次:sum + i 是 6 + 4 ; sum结果为 10; 
    	第五次:sum + i 是 10 + 5 ; sum结果为 15; */
    	for(int i=1; i<=5; i++) { 
    	//将反复进行的事情写入循环结构内部 
    	// 此处反复进行的事情是将数据 i 加到用于保存最终求和的变量 sum 中 
    	sum += i; 
    	} 
    	}
    
    • 本题要点
      • 今后遇到的需求中,如果带有求和二字,请立即联想到求和变量
      • 求和变量的定义位置,必须在循环外部,如果在循环内部则计算出的数据将是错误的
    • for循环练习3:求1-100之间的偶数和,并把求和结果在控制台输出
    public static void main(String[] args) 
    { 	//求和的最终结果必须保存起来,需要定义一个变量,用于保存求和的结果,初始值为0 			
    	int sum = 0; 
    	//对1-100的数据求和与1-5的数据求和几乎完全一样,仅仅是结束条件不同 
    	for(int i=1; i<=100; i++) { 
    	//对1-100的偶数求和,需要对求和操作添加限制条件,判断是否是偶数 
    	if(i%2 == 0) { sum += i; } 
    	}
    	//当循环执行完毕时,将最终数据打印出来 
    	System.out.println("1-100之间的偶数和是:" + sum);
    	 }
    
    • 本题要点:
      • 今后如果需求带有统计xxx,请先想到计数器变量
      • 计数器变量定义的位置,必须在循环外部

    6.3 循环扩展知识点

    6.3.1 死循环

    • 死循环:也就是循环中的条件永远为true,死循环的是永不结束的循环。例如:while(true){}。
      在后期的开发中,会出现使用死循环的场景,例如:我们需要读取用户输入的输入,但是用户输入多少数据我们并不清楚,也只能使用死循环,当用户不想输入数据了,就可以结束循环了,如何去结束一个死循环呢,就需要使用到跳出语句了。
    • 死循环(无限循环)的三种格式
      • for(; ; ){}
      • while(true){}
      • do {} while(true);

    6.3.2 嵌套循环

    • 所谓嵌套循环,是指一个循环的循环体是另一个循环。比如for循环里面还有一个for循环,就是嵌套循环。总共的循环次数=外循环次数*内循环次数
    • 嵌套循环格式:
    for(初始化表达式①; 循环条件②; 步进表达式⑦) 
    { 
    for(初始化表达式③; 循环条件④; 步进表达式⑥) 
    { 执行语句⑤; 
    } 
    }
    
    • 嵌套循环执行流程:
      • 执行顺序:①②③④⑤⑥>④⑤⑥>⑦②③④⑤⑥>④⑤⑥
      • 外循环一次,内循环多次(一圈)。
      • 例如:日历中 年与月的关系,时钟中 分与秒的关系
        • 如 2021年至2023年,一共3年,每年12个月。其中,年份看成外循环,月份看成内循环。
        • 看系统日历 时钟
    • 练习:使用嵌套循环,打印2021年至2023年月份,格式:xxxx年x月
    public static void main(String[] args) 
    { 
    //打印2021年至2023年月份 
    //年份是外循环,3年;月份是内循环,12月 
    for (int i = 2021; i <= 2023; i++) 
    { 
    for (int j = 1; j <= 12; j++) {
     //不换行打印星号 
     System.out.print(i + "年" + j + "月 "); 
     }//内循环打印12个月后,需要一次换行 System.out.println(); 
     } 
     }
    

    6.3.3 流程控制语句(continue, break, return)

    • continue, break, return三者的作用
      在这里插入图片描述
    public class Test { public static void main(String[] args) 
    { 
    	System.out.println("==========开始=========="); 
    	printDate(); 
    	System.out.println("==========结束=========="); 
    	}
    	//日期打印 
    public static void printDate() { 
    	//打印 2021年 - 2023年之间的 每一个月份 
    	//外层循环 代表的年份 
    	for (int i = 2021; i <= 2023; i++) 
    	{ 
    	System.out.println("年份i = " + i); 
    	//内层循环表示 月份 
    	for (int j = 1; j <= 12; j++) 
    	{ 
    	if(j == 5)
    	{ 
    	continue; //break; //return; 
    	}
    	System.out.println("---------- 年份 "+ i +"月份 j = " + j); 
    	}
    		} 
    	} 
    }
    

    6.4 Debug调试

    6.4.1 什么是Debug模式

    是供程序员使用的程序调试工具,它可以用于查看程序的执行流程,也可以用于追踪程序执行过程来调试程序。
    使用IDEA的断点调试功能,查看程序的运行过程 Debug调试窗口介绍
    在这里插入图片描述

    6.4.2 Debug模式操作流程

    • 如何加断点
      • 选择要设置断点的代码行,在行号的区域后面单击鼠标左键即可
    • 如何运行加了断点的程序
      • 在代码区域右键Debug执行
    • 看哪里
      • 看Debugger窗口
    • 看Console窗口
      • 点哪里
      • 点Step Into (F7)这个箭头,也可以直接按F7
    • 如何删除断点
      • 选择要删除的断点,单击鼠标左键即可
      • 如果是多个断点, 可以每一个再点击一次。也可以一次性全部删除

    6.5 编程题

    练习一 打印输出三角形

    练习二 答应输出等腰三角形

    练习三 打印输出菱形

    练习四 打印输出空心菱形

    代码如下:

    public class Demo {
        public static void main(String[] args) {
            System.out.println("三角形");
            //三角形
            for (int i = 0; i < 4; i++) {
                for (int j = 0; j < 2*i+1; j++) {
                    System.out.print("*");
                }
                System.out.println();
            }
            System.out.println("等腰三角形");
            //等腰三角形
            for (int i = 0; i < 4; i++) {
                for (int j = i; j <3; j++) {//控制空格
                    System.out.print(" ");
                }
                for (int j = 0; j < 2*i+1; j++) {//控制*
                    System.out.print("*");
                }
                System.out.println();
            }
            System.out.println("菱形");
            //菱形
            for (int i = 0; i < 7; i++) {
                if (i<=3)
                {
                    for (int j = i; j <3; j++) {//控制空格
                        System.out.print(" ");
                    }
                    for (int j = 0; j < 2*i+1; j++) {//控制*
                        System.out.print("*");
                    }
                }
                else {
                    for (int j = i-3; j > 0; j--) {
                        System.out.print(" ");
                    }
                    for (int j = (6-i)*2+1; j >0; j--) {
                        System.out.print("*");
                    }
                }
                System.out.println();
            }
            System.out.println("空心菱形");
            //空心菱形
            for (int i = 0; i < 7; i++) {
                if (i<=3)
                {
                    for (int j = i; j <3; j++) {//控制空格
                        System.out.print(" ");
                    }
                    for (int j = 0; j < 2*i+1; j++) {//控制*
                        if (i==0) System.out.print("*");
                        else if(j==0||j==2*i) System.out.print("*");
                        else System.out.print(" ");
                    }
                }
                else {
                    for (int j = i-3; j > 0; j--) {
                        System.out.print(" ");
                    }
                    for (int j = (6-i)*2+1; j >0; j--) {
                        if (i==6) System.out.print("*");
                        else if(j==(6-i)*2+1||j==1) System.out.print("*");
                        else System.out.print(" ");
                    }
                }
                System.out.println();
            }
        }
    }
    
    

    总结

    怎么样,大家看完这章有没有做出练习题呢

    展开全文
  • 本帖最后由 ming1006 于 2013-4-6 14:...C51三种循环语句即while,do-while和for,这三种循环都可以用来处理同一问题,基本上三者可以相互替换.但由于C51是针对51汇编语言的编译器,如果不注意51汇编指令的特点,不同的...

    本帖最后由 ming1006 于 2013-4-6 14:49 编辑

    最近在用51中因为对速度的需求很严重,于是研究了下51单片机C语言的优化问题,稍等会分享。这里先把刚才搜到的一篇不错的文章和大家分享分享。C51有三种循环语句即while,do-while和for,这三种循环都可以用来处理同一问题,基本上三者可以相互替换.但由于C51是针对51汇编语言的编译器,如果不注意51汇编指令的特点,不同的编程方式可能得到不同的程序性能(执行速度和代码长度).以计算1+2+3+...+9+10为例,下面做一对比.

    程序1:

    unsigned char i;

    unsigned char sum;

    for(i=1,sum=0;i<11;i++)

    {sum+=i;}

    汇编代码为:

    C:0x0003 7F01 MOV R7,#0x01

    C:0x0005 E4 CLR A

    C:0x0006 FE MOV R6,A

    C:0x0007 EF MOV A,R7

    C:0x0008 2E ADD A,R6

    C:0x0009 FE MOV R6,A

    C:0x000A 0F INC R7

    C:0x000B BF0BF9 CJNE R7,#0x0B,C:0007

    代码长度(字节):11,执行周期(机器周期):63

    程序2:

    unsigned char i;

    unsigned char sum;

    for(i=10,sum=0;i;i--)

    {sum+=i;}

    汇编代码为:

    C:0x000F 7F0A MOV R7,#0x0A

    C:0x0011 E4 CLR A

    C:0x0012 FE MOV R6,A

    C:0x0013 EF MOV A,R7

    C:0x0014 2E ADD A,R6

    C:0x0015 FE MOV R6,A

    C:0x0016 DFFB DJNZ R7,C:0013

    代码长度(字节):9,执行周期(机器周期):53

    程序3:

    unsigned char i=11;

    unsigned char sum=0;

    while(i--){sum+=i;}

    汇编代码为:

    C:0x0003 7F0A MOV R7,#0x0B

    C:0x0005 E4 CLR A

    C:0x0006 FE MOV R6,A

    C:0x0007 AD07 MOV R5,0x07

    C:0x0009 1F DEC R7

    C:0x000A ED MOV A,R5

    C:0x000B 6005 JZ C:0012

    C:0x000D EF MOV A,R7

    C:0x000E 2E ADD A,R6

    C:0x000F FE MOV R6,A

    C:0x0010 80F5 SJMP C:0007

    代码长度(字节):15,执行周期(机器周期):130从以上三个不同程序可以看出,其运算结果都是0x37(55),但最短代码为9,最长代码为15,最快速度为53,最慢速度为130,可见三个程序的性能差异较大.

    如何编出占用空间小运行效率高的循环代码呢?在C51编译环境下要写出优秀的循环代码必须熟悉51汇编语言的指令系统.观察程序2,循环控制指令使用了DJNZ循环转移指令,该指令同时完成计数和循环判断两种操作,而且只占用两个字节,是51指令系统中最为高效的循环指令,因此在设计循环程序时,应尽可能使C51将DJNZ用于循环程序中.当然DJNZ指令的循环次数是确定的,主要用在有确定循环次数的情况.

    DJNZ指令的一个最大特点是递减计数,因此循环程序必须采用递减方式才有可能编译出DJNZ指令,如以上程序2.DJNZ指令的另一个特点是先减后判断,因此设计循环程序也必须坚持先减后判断的原则,否则得不到DJNZ指令,如以上程序3.如果将程序3改写为:

    unsigned char i=10;

    unsigned char sum=0;

    while(i)

    {

    sum+=i;

    i--;

    }

    就可以得到与程序2相同的汇编代码.若i--后还有其它操作,比如改为:

    unsigned char i=10,j=0;

    unsigned char sum=0;

    while(i)

    {

    sum+=i;

    i--;

    j++;

    }

    也得不到DJNZ汇编指令,也就是说,循环语句在执行过程中,减1与判断必须是连续的,且减1在前,判断在后.对于while循环,当将减1与判断合成一步时,应当采用while(--i).按照以上所述,do-while循环同样可以汇编出DJNZ指令,不再一一列举.

    但是当循环变量不是通过常数赋值语句完成,而是来自于另一个变量时,for和while语句无论采用何种控制流程都不能产生DJNZ指令,因为这两种循环都是先判断后执行的控制逻辑,而DJNZ的执行过程是先执行循环体后进行循环判断.按照DJNZ的控制流程,只有do-while语句符合这个条件,因此当循环次数不是常量而是变量时,就必须使用do-while循环语句了.

    综上所述,若要使用DJNZ指令提高程序效率,在设计循环程序中应坚持以下三大原则:

    ① 采用递减计数;

    ② 先减后判断,减与判断连续进行;

    ③ 循环次数为变量时,采用do-while循环.

    8051单片机有两条循环指令,即DJNZ Rn,rel和DJNZ direct,rel.对于基本型单片机而言,两者的执行时间都是2个机器周期,但两者的指令长度不同,前者占用2个字节,后者占用3个字节.循环程序还涉及到循环变量初始化操作,对于前者使用MOV Rn,#XX,2字节1周期,对于后者使用MOV direct,#XX,3字节2周期.以单层循环为例,使用工作寄存器比直接地址节省2字节1周期.除此之外,两者相比,更重要的性能差异在于后者需要再分配一个内存单元.因为通常程序模块都使用工作寄存器作局部变量,将工作寄存器用作循环变量不会增加内存占用量.总之,使用工作寄存器作循环计数器是设计循环程序应坚持的一项重要原则.

    一般情况下,C51编译器将循环次数赋予工作寄存器,比如

    unsigned char i;

    for(i=100;i;i--)

    {

    dosomething();

    }

    但是存在下述情况之一时,C51编译的结果往往令人不满意:

    ① 函数dosomething是一个外部定义C语言函数;

    ② 函数dosomething是一个具有C语言接口,内部用汇编语言实现的,供C程序调用的外部函数.

    以上两种情况循环变量i都存放在内存单元中,即采用直接寻址方式.对于局部变量i,C51编译器采用了直接地址存储,其原因在于基于这种假设,即在无任何特殊处理的情况下,C51默认外部函数占用所有工作寄存器,因此在循环的外部,不能修改这些已被占用的寄存器,C51只能将循环控制变量分配在内存地址单元中.但如果循环体语句中仅使用少数几个或甚至根本不使用工作寄存器,编译器仍按这种假设处理,那么编译器就不能显现出它的高效性了.幸运的是,C51提供了弥补这一缺陷的伪指令REGUSE.REGUSE伪指令用于告知编译器某函数或子程序占用了哪些寄存器或特殊功能寄存器SFR,编译器根据函数提供的寄存器占用信息就可能将循环变量分配到循环体未占用的寄存器中,从而达到优化设计的目的.

    另外,一项开关必须打开,即Global Register Coloring,方法是勾选Project - Options for Target - C51 - Global Register Coloring.

    在情况①中,应在函数dosomething所在源程序文件中添加代码(假设函数占用A和B):

    #pragma asm

    $REGUSE dosomething(A,B)

    #pragma endasm

    重新编译项目后,在汇编窗口中可以看到,循环变量已使用了工作寄存器.

    在情况②中,由于是汇编程序,只需增添一行代码(也假设子程序占用A和B):

    $REGUSE dosomething(A,B)

    同样可以观察到循环变量改成了工作寄存器实现.

    需要注意的是,这里所说的寄存器占用是指在函数或子程序执行过程中可能或肯定对这些寄存器造成破坏,即执行写操作,对于只读寄存器不应按占用处理.另外,参数传递使用的工作寄存器不必指明.

    展开全文
  • 第6章 C控制语句循环6.1 再探 while 循环6.1.1 程序注释6.1.2 C风格读取循环6.2 while 语句6.2.1 终止 while 循环6.2.2 何时终止循环6.2.3 while:入口循环条件6.2.4 语法要点6.3 _Bool 类型6.4 不确定循环和计数...
  • for循环嵌套,C语言for循环嵌套详解

    千次阅读 多人点赞 2021-02-06 16:50:51
    前面我们讲的是单个 for 循环的使用,最后再跟大家讲一下多层 for 之间的嵌套使用。虽说是多层,事实上 for 循环嵌套的层数也不能太多。通常为两个 for 循环的嵌套,超过两个的极少使用。与单个 for 循环相比,多个 ...
  • 摘要:相信大家都使用过子查询,因为使用子查询可以一次性的完成很多逻辑上需要多个步骤才能完成的SQL操作,比较灵活,我也喜欢用,可最近因为一包含子查询的select count(*)语句导致点开管理系统的一个功能模块...
  • 的非常规使用循环:while、do while、forwhile 循环do…while 循环for循环省略语句段跳出循环继续下一次迭代break/continue 标签总结switch 语句语法举个例子case 分组类型很关键 if 语句 if(...) 语句计算括号里的...
  • 展开全部有5.3.1 使用break 语句在Java 中,break语句有3种作用。第一,你已32313133353236313431303231363533e4b893e5b19e31333234303036经看到,在switch语句中,它被用来终止一个语句序列。第二,它能被用来退出...
  • 不管是一条语句还是多条语句都使用{}括起来 加上{}代码风格良好 使用单分支语句 三目运算符 多分枝语句 if else 判别键盘输入字符的类别,是否是数字字符,是否是小写字符,是否是大写字符,还有其他字符 改进代码 ...
  • 文章目录C控制语句循环本章内容再探while循环程序注释C风格读取循环while语句终止while循环while:入口条件循环语法要点用关系运算符和表达式比较大小什么是真其他真值真值的问题优先级和关系运算符不确定循环和...
  • 一、C 语句分类C 语言的语句用来向计算机系统发出指令,一个实际的源程序通常包含若干条语句,这些语句用来完成一定的操作任务。1.控制语句:(1).if ()…else…;else-if 条件语句(2).switch 多分支选择语句3 .for()...
  • redo log 酒店掌柜一个粉板,专门用来记录客人的赊账记录。如果赊账的人不多,那么他可以把顾客名和账目写在板上。但如果赊账的人多了,粉板总会有记不下的时候,这个...首先,你得找到这个人的赊账总额那记...
  • 【C语言】循环题目详解

    千次阅读 2021-05-20 01:49:08
    老九学堂传送门C语言3种循环:for、while、do while;接下来,老九君带着大家来详细的解析一下关于循环的题目,让你更加清楚和熟练的掌握循环。三大循环1.whlie循环:/* while----注意花括号的使用 *//* 糟糕的...
  • 当我们执行一MySQL查询语句时,对于客户端而言是一个很简单的过程,但对于服务端来说其内部却会涉及到一些复杂的组件和处理逻辑。了解MySQL语句的内部执行原理,助于我们更好地去处理一些复杂的SQL语句,帮助...
  • C++入门:循环结构

    2021-05-22 09:50:52
    原标题:C++入门:循环结构 春去春来,花开花谢,缘聚缘散,生死轮回,只有不断的变化才能永恒。我们在时间的更迭中,慢慢的变成自己的模样,却也慢慢渐行渐远。1身体质量指数BMI(BMI,Body Mass Index),是国际上...
  • 程序的3种控制结构条件控制语句循环控制语句跳转语句包含语句1.程序设计的结构大致分为顺序结构,选择(分支)结构和循环结构3种。循环结构可以按照需要多次重复执行一行或者多行代码,循环结构分为前测试型循环和后...
  • java 基本语法语句

    2021-02-12 12:20:02
    1.选择结构if语句if(表达式1){语句体1;}else if(表达式2){语句体2;}else if(表达式3){语句体3;}...else{语句体n+1;}执行流程:计算出表达式1的值如果值为true执行语句体1如果值为false计算表达式2的值如果值为...
  • 通过复制循环主体,在 if 和 else 语句中放一份循环体代码,实现将条件句的内部循环移到循环外部,进而提高循环的并行性。由于处理器可以快速运算矢量,因此执行速度得到提升。 3. 实验 要回答这个问题,最简单的...
  • 例如,在返回的30数据中,a条目是第7则会进行30次判断,弹出29次查无数据,也就是要点击29次关闭alert,很是让人不爽。了下列解决办法(利用flag标志来进行判断)var temp = false; //先建立一个flag标志//循环...
  • mysql查询锁表语句

    2021-01-18 23:09:49
    processlist命令的输出结果显示了哪些线程在运行,可以帮助识别出问题的查询语句,两种方式使用这个命令。1.进入mysql/bin目录下输入mysqladmin processlist;2.启动mysql,输入show processlist;如果SUPER权限...
  • 嵌套循环连接处理的两个数据集被称为外部循环(outer loop,也就是驱动数据源,driving row soulce )和内部循环〔 inner loop )嵌套循环连接处理的两个数据集被称为外部循环(outer loop,也就是驱动数据源,driving ...
  • python入门(一)---判断语句循环控制一、流程控制1、顺序流程2、选择流程3、循环流程如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右...
  • 内部循环在外部循环体中,在外部循环的每次执行过程中都会触发内部循环,直到内部循 ... 随机推荐 LeetCode:Gray Code(格雷码) 题目链接 The gray code is a binary numeral system where two successive values ...
  • 00 Java中的语句语句块(有时叫做复合语句),是用花括号扩起...语句块可以使用外部的变量,而外部不能使用语句块中定义的变量,因为语句块中定义的变量作用域只限于语句块。代码中的语句:public class Test19 {pub...
  • 什么是循环?在编程中,循环意味着以相同的顺序多次重复同一组计算。 什么是循环 在编程中,循环意味着以相同的顺序多次重复同一组计算。 想想现实生活中的情况。你是一位在森林里测量树木的野外生物学家。你选...
  • Java语言-for循环详解

    多人点赞 2021-09-27 16:52:01
    虽然所有循环结构都可以用 while 或者 do...while表示,但 Java 提供了另一种语句 —— for 循环,使一些循环结构变得更加简单。 for循环执行的次数是在执行前就确定的。 语法格式如下:
  • 经典SQL语句大全(1)

    千次阅读 2021-02-02 14:04:29
    9、说明:创建视图:create view viewname as select statement 删除视图:drop view viewname 10、说明:个简单的基本的sql语句 选择:select * from table1 where 范围 插入:insert into table1(field1,field2...
  • 5 . 1 简单语句 C++语言中的大多数语句都以... 第一条语句没什么用处,因为虽然执行了加法,但是相加的结果没被使用。比较普遍的情况是,表达式语句中的表达式在求值时附带其他效果,比如给变量赋了新值或者输出了
  • public class Test { public static void main(String[] args) { // TODO Auto-generated method stub List list=new Arr… continue和break可以改变循环的执行流程,但在多重循环中,这两条语句无法直接从内层循环...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 67,995
精华内容 27,198
关键字:

外部循环有几条语句