DO-WHILE循环语句的翻译程序设计(简单优先法、输出四元式)
第四章。循环结构（while、do-while、for）
第四章。
循环结构（while、do-while、for）Top1.循环结构(while、do…while、for)1. 循环结构(while、do…while、for)1.1. 什么是循环结构在日常生活中，会有很多需要反复执行的事情，比如：每一年的4个季节，每一周的7天，每日的3餐，打印机每份文档打印50份，一圈跑道400米跑3圈，都是在反复执行的。
再看软件系统中的需求：问题1：输出100行语句，每行语句都一样，即:行动是成功的阶梯，行动越多，登得越高!行动是成功的阶梯，行动越多，登得越高!行动是成功的阶梯，行动越多，登得越高!…问题2：输出100行语句，每行语句都类似，即:第1,行动是成功的阶梯，行动越多，登得越高!第2,行动是成功的阶梯，行动越多，登得越高!第3,行动是成功的阶梯，行动越多，登得越高!…第100,行动是成功的阶梯，行动越多，登得越高!问题3：计算1到50乘以8.88的结果1×8.88 ＝8.882 ×8.88 ＝17.763 ×8.88 ＝26.644 ×8.88 ＝35.52…50 ×8.88 ＝444诸如此类问题都是在反复执行的，在软件系统中可以通过循环这种语法结构来解决。
循环是程序设计语言中反复执行某些代码的一种计算机处理过程，是一组相同或相似语句被有规律的重复性执行。
对于循环来说，需要考虑两个要素，其一要素为循环体，也就是被反复执行的相同或相似的语句，其二要素为循环的条件，也就是循环得以继续执行下去的条件，常常以循环次数的方式体现。
常用的循环结构有：while、do-while、for。
1.2. while语句1.2.1. while语句的执行逻辑while语句是循环的一种常见语法结构，语法如下：1.while(boolean表达式){语句块；2.}while语句的执行过程为，首先计算boolean表达式的值，而后进行判断，若值为true则执行语句块，语句块执行完后再次判断boolean表达式的值，如果为true则继续执行语句块，如此循环往复，直到boolean表达式的值为false时退出while循环而执行while之后的语句。
dowhile循环语句
dowhile循环语句篇一：Java编程-do-while语句语法5.4.2 do-while语句do-while语句由关键字do和while组成，是循环语句中最典型的“先循环再判断”的流程控制结构，这个和其它2个循环语句都不相同。
do-while语句的语法格式为：do{循环体;}while(循环条件);语法说明：在do-while语句中，循环体部分是重复执行的代码部分，循环条件指循环成立的条件，要求循环条件是boolean类型，值为true时循环执行，否则循环结束，最后整个语句以分号结束。
执行流程：当执行到do-while语句时，首先执行循环体，然后再判断循环条件，如果循环条件不成立，则循环结束，如果循环条件成立，则继续执行循环体，循环体执行完成以后再判断循环条件，依次类推。
实现和while语句实现的类似的示例，则死循环的示例代码为：do{System.out.println(‘a’);}while(true);实现输出0-9这10个数字的循环为：int i = 0;do{System.out.println(i); //输出变量的值i++; //变量增加1}while(i < 10);实现求1-10这10个数字的和的代码为：int i = 1;int sum = 0;do{sum += i; //求和i++; //变量增加1}while(i < 10);System.out.println(sum); //输出和同理，实现求5的阶乘的代码类似，在数学上5的阶乘指1×2×3×4×5，数学上规定0的阶乘等于1，在实际计算时，阶乘的值增加的非常快，所以需要注意结果不能溢出。
其具体代码为：int i = 1;int result = 1;do{result *= i;i++;}while(i <= 5);System.out.println(result);在实际的程序中，do-while的优势在于实现那些先循环再判断的逻辑，这个可以在一定程度上减少代码的重复，但是总体来说，do-while语句使用的频率没有其他的循环语句高。
WHILE循环语句的翻译程序设计(简单优先法,三地址输出)
目录1 问题域描述 (3)2 文法及属性文法的描述 (3)2.1 WHILE循环语句的文法 (3)2.2 WHILE循环语句的属性文法 (4)3 语法分析方法及中间代码形式的描述 (4)3.1语法分析方法 (4)3.2中间代码形式描述 (6)4 编译系统的概要设计 (7)4.1词法分析 (7)4.2语法制导翻译 (8)5 详细的算法描述 (8)5.1 文法设计 (8)5.2 算法描述 (8)5.3 源程序代码 (9)6 软件的调试过程和结果测试 (19)6.1调试过程 (19)6.2结果测试 (19)7 使用说明 (20)8 课设总结 (20)9 参考文献 (22)WHILE循环语句的翻译程序设计（简单优先法、输出三地址表示）1 问题域描述while循环语句的翻译程序设计（简单优先法，输出单地址表示），要求完成：（1）用C++语言正确编写程序，完成WHILE循环语句的翻译程序设计。
（2）求能正确进行词法分析，语法分析，并能正确的输出预期结果。
（3）根据指定的文法，判定程序的正确性。
本次课程设计中要求设计一个WHILE循环语句的词法﹑语法及语义分析程序，语法分析选择简单优先法，采用语法制导翻译输出中间代码三元式。
通过设计、编制、调试一个WHILE循环语句的语法及语义分析程序，加深对语法及语义分析原理的理解，实现功能。
while循环语句的格式为：while（P）{do A}，其中A为循环体，可为一个或多个赋值语句；P为循环控制条件。
while循环语句首先根据循环控制条件P进行判断，若满足条件则执行循环体A，否则执行下面的程序段；本次课程设计中系统首先要进行词法分析，即从左到右把源文件的字符序列逐个进行扫描，产生一个个的单词序列，作为语法分析的输入从而继续编译过程。
该程序的语法分析读入词法分析的结果，并判断输入语句是否满足while循环语句的文法所描述的形式。
通过简单优先法对语句进行分析，看是否能通过给定的输入串归约到文法的开始符号。
dowhile循环语句格式讲解
dowhile循环语句格式讲解
嘿，朋友！你知道什么是dowhile 循环语句吗？这玩意儿可有趣啦！
比如说，你想要一直做一件事，直到某个条件不满足为止，这时候dowhile 循环就派上用场啦！想象一下，你在沙漠里找水源，只要还没
找到水，你就一直不停地找，这就有点像 dowhile 循环。
它的格式大概是这样：
do {
// 要执行的代码
} while (条件);
就好比你每天早上起床，先穿衣服（这是要执行的代码），然后看
看是不是周末（这就是条件），如果不是周末，那就乖乖去上班。
再比如，你想让计算机一直输出数字，直到数字大于 100 为止。
do {
System.out.println(数字);
数字++;
} while (数字 <= 100);
这不就像你一直吃蛋糕，直到吃撑了才停下嘛！
怎么样，是不是对 dowhile 循环语句有点感觉啦？
我的观点是，dowhile 循环语句虽然不像 for 循环那么常用，但在某些特定场景下，它可是能发挥大作用的，能让我们的程序更加灵活和强大！。
控制语句的翻译四元式例题及答案
控制语句的翻译四元式例题及答案
1. 例题：if语句
高级语言代码：
python
if x > 5:
y = x + 10
else:
y = x - 10
翻译四元式：
1: if x > 5 goto 4
2: y = x + 10
3: goto 5
4: y = x - 10
5: (end if)
答案解析：
- 第1行表示条件判断，如果x大于5，则跳转到第4行执行。
- 第2行为if语句为真时的语句，将x加10赋值给y。
- 第3行为跳转到if语句结束位置的标记。
- 第4行为if语句为假时的语句，将x减10赋值给y。
- 第5行为if语句结束位置的标记。
2. 例题：while循环语句
高级语言代码：
python
while x > 0:
y = y + x
x = x - 1
翻译四元式：
1: (start while)
2: if x > 0 goto 4
3: goto 5
4: y = y + x
5: x = x - 1
6: goto 2
7: (end while)
答案解析：
- 第1行为while循环的起始位置。
- 第2行为条件判断，如果x大于0，则跳转到第4行执行循环体内的语句。
- 第3行为否则跳转到while循环结束位置的标记。
- 第4行为循环体内的语句，将y加上x的值。
- 第5行为循环体内的语句，将x减1。
- 第6行为跳转回while循环起始位置的标记。
- 第7行为while循环结束位置的标记。
dowhile语句的用法
dowhile语句的用法
do-while语句是一种循环结构，它会先执行循环体内的代码，然后再检查循环条件。
只有当循环条件为真时，才会继续执行下一次循环。
do-while语句的用法如下：
```
do
//循环体的代码
} while (循环条件);
```
具体解释如下：
1.执行循环体的代码。
2.检查循环条件。
如果条件为真，继续执行下一次循环；如果条件为假，退出循环。
3.重复步骤1和2，直到条件为假。
与其他循环结构（如for和while）不同的是，do-while语句保证循环体中的代码至少会执行一次，即使循环条件一开始就为假。
这是因为循环条件是在循环体执行完之后才被检查的。
do-while语句通常用于需要至少执行一次循环体的情况，例如用户输入验证和菜单选择等。
do while循环语句 顺序
do while循环语句顺序
`do-while` 循环语句是一种循环结构，它会先执行循环体，然后检查循环条件。
循环体至少会被执行一次，即使初始时循环条件为false。
`do-while` 循环的基本形式如下：
```c
do {
// 循环体
} while (循环条件);
```
执行流程顺序如下：
1. 执行循环体。
2. 检查循环条件。
3. 如果循环条件为真（true），则继续执行循环体，然后再次检查循环条件。
4. 如果循环条件为假（false），则退出循环，继续执行后续代码。
`do-while` 循环适用于那些至少要执行一次循环体的情况。
以下是一个简单的示例，演示了`do-while` 循环的使用：
```c
#include <stdio.h>
int main() {
int i = 0;
do {
printf("%d ", i);
i++;
} while (i < 5);
return 0;
}
```
这个例子中，`do-while` 循环会输出数字0 到4。
即使`i` 的初始值是0，而循环条件是`i < 5`，循环体还是会被执行一次。
while和dowhile循环，C语言while和dowhile循环详解
while和dowhile循环，C语言while和dowhile循环详解当循环体中的语句多于一条时，要用{} 把这些语句括起来形成一条复合语句，如下所示。
while(Exp_cntrl){Statement_1;Statement_2;}当循环体为一条简单语句时，可以省略 {}，即:while(Exp_cntrl)Simple_Statement;//循环体while 循环的执行流程为，首先判断循环控制表达式 Exp_cntrl 的值，当该表达式的值为逻辑真（非0）时，会一直执行循环体，直到表达式的值为逻辑假（0）才结束循环。
while 循环流程图如图 1 所示。
图 1通常把循环控制表达式 ExP_cntrl 中含有的变量，称为循环控制变量。
为了避免程序陷入死循环，必须要有能改变循环控制变量的语句，使循环控制表达式 Exp_cntrl 的值趋于逻辑假，以便使循环趋于终止。
【例 1】统计输出 100 以内的所有奇数之和。
分析：本题是重复执行“把 100 以内的当前奇数 1、3、5、7，… 累加求和”的相似操作，故采用循环结构。
循环算法的关键是要确定循环条件表达式和循环体。
循环控制变量及初始条件确定：由题意可知，奇数 i 作为循环控制变量，初值为第一个奇数，即 i=1。
另外，还有求和变量 sum=0。
循环条件表达式的确定：循环控制变量 i 为 [1,100] 间的奇数。
故循环条件表达式为 i<=100。
循环体确定：该题循环体中包含以下两部分操作。
•把当前奇数变量 i 累加到求和变量 sum 中，即 sum+=i;•为计算当前奇数的下一个奇数做准备，也就是控制变量的增量部分，即 i+=2。
流程图如图 2 所示。
图 2 流程图实现代码如下：复制纯文本复制1.#include<stdio.h>2.int main (void){3.int sum=0,i=1; //i初始为第一个素数4.while (i<=100) //循环执行的判断条件5.{6.sum+=i;7.i+=2; //控制变量的增量8.}9.printf('sum=%d\n',sum);10.return 0;11.}#include<stdio.h> int main (void){ int sum=0,i=1; //i初始为第一个素数 while (i<=100) //循环执行的判断条件 { sum+=i; i+=2; //控制变量的增量 } printf('sum=%d\n',sum); return 0; }运行结果为：sum=2500需要说明的是，必须在零的基础上进行累加，故 sum 需要初始化为0，否则将是无意义的随机值。
do-while循环的使用及特点
do-while循环的使⽤及特点为什么要使⽤do-while循环：
while循环是先判断后循环，就好⽐考试后先判断你的成绩是否及格如果不及格就需要补考。
do-while循环是先循环后判断，就像需要先进⾏考试，之后才能判断你是否及格。
语法及案例：
do{
//代码块
}while（）；
=================
public void test01(){
String answer=null;
do{
//循环操作
System.out.println("先上机编程考试");
System.out.print("⽼师我合格了么？（y/n）: ");
answer=sc.next();
}while("n".equals(answer)); // 循环条件
System.out.println("程序结束");
}
先执⾏⼀次System.out.println("先上机编程考试"); System.out.print("⽼师我合格了么？（y/n）: ");。
然后判断是否需要继续考试，如果输⼊的是n 则就会回到顶部继续循环程序。
如果输⼊的是y 则结束循环，继续执⾏下⼀步的代码程序。
while循环和dp-while循环的区别：
while循环是先判断，后循环。
do-while循环是先执⾏后判断。
⼆者的区别是 do-while循环⾄少会执⾏⼀次。
while循环可能⼀次都也执⾏。
⼆者都有各⾃的特点，⽅便我们做各种的判断。
c语言中do while语句的用法及规则
c语言中do while语句的用法及规则
C语言中的`do while`语句属于循环语句的一种，其基本格式如下：
```c
do {
// 循环体
} while (条件表达式);
```
其执行过程是：首先，执行一次循环体中的代码。
然后，判断条件表达式的值，如果为真（非零），则继续执行循环体中的代码；如果为假（零），则结束循环。
重复上述步骤，直到条件表达式的值为假（零）为止。
与`while`循环语句的区别在于，`do while`语句在每次循环之后检验条件，这意味着循环体中的代码至少会执行一次。
因此，在使用`do while`语句时，需要在循环体中设置能够跳出循环的条件，否则可能会导致死循环。
总的来说，`do while`语句在某些情况下非常有用，例如当循环体中的代码需要至少执行一次，或者循环的次数不确定，而是由条件表达式决定时。
在使用`do while`语句时，需要注意其语法和执行逻辑，以确保程序的正确性和可靠性。
DO-While--Loop循环语句知识讲解
__4___________2_9______
分析并完善程序 已知S=1+2+3+……..+N，找出一个最大的整数N，使得S<300.
S=0 N=0 Do While _S_<_3_0_0_
N=N+1 S=S+N _L_o__o_p_______ N=N-1 print “最大整数N为：”; N
说明：划线处代码是M=M+1，每执行完一次循环，M都增加1。在这个程序中， 此语句十分重要，如果缺少，就会出现条件M<=10永远成立的情况，程序将会 无限地循环。因此在使用Do语句时，必须注意条件表达式中的变量值的变化方 式，有可能会出现无限循环的情况。
分析并完善程序
a=1:b=0 do while a <=3
Do While <条件> <循环体>
Loop
循环语句
， 才 终 止 D o 语 句 的 执 行 ， 其 执 行 过 程 如 下 图 所 示 。
首先判断条件是否成立，若条件成立，则执行循环语句。遇到 Loop语句后，再次判断条件是否成立，若成立，继续执行循 环语句，如此不断重复，当条件不成立时，则终止Do语句的 执行。
例题 用Do语句计算1+…+100
开始 i=1
s=0 i=i+1
i<=100?
否 输出s
是 s=s+i
结束
Dim S As Integer, I As Integer S=0 I=0 Do While I <= 100
S=S+I I=I+1 Loop Print “s=", S
dowhile语句实践运用
dowhile语句实践运用do-while语句是一种循环结构，它先执行一次循环体，然后再根据条件判断是否继续执行循环。
接下来，我将以人类的视角，用准确的中文描述，给你展示几个do-while语句的实践运用场景。
一、购物结算小明去超市购物，他买了苹果、香蕉和橙子。
他需要使用do-while 语句来实现购物结算的功能。
首先，他将购买的商品放入购物车，然后计算购物车中商品的总价。
接着，他询问是否继续购买，如果是，则继续添加商品到购物车，否则结束购物并输出购物车中商品的总价。
二、学生成绩统计某班级有10名学生，老师需要使用do-while语句来统计学生的成绩。
老师首先输入学生的姓名和成绩，然后判断是否还有其他学生需要输入成绩。
如果是，则继续输入下一位学生的成绩，否则结束输入并计算学生的平均成绩和最高分。
三、密码验证某应用程序需要使用do-while语句来验证用户的密码。
用户需要输入密码，然后程序判断密码是否正确。
如果密码不正确，则提示用户重新输入密码，直到输入正确的密码为止。
四、游戏猜数小明和小红在玩一个猜数字的游戏。
小红想一个数字，小明需要猜这个数字是多少。
小明每次猜完后，小红会告诉他猜的数字是大了还是小了。
小明使用do-while语句来循环猜数字，直到猜中为止。
五、倒计时某个倒计时程序需要使用do-while语句来实现倒计时功能。
程序首先设置倒计时的时间，然后开始倒计时。
在每次倒计时结束后，程序判断是否还需要继续倒计时。
如果是，则继续倒计时，否则结束倒计时。
六、跳绳计数小明正在练习跳绳，他使用do-while语句来记录他跳绳的次数。
每次跳绳后，他会询问自己是否还要继续跳绳。
如果是，则继续跳绳并增加跳绳次数，否则结束跳绳并输出跳绳的总次数。
七、旅行计划小红正在计划一个旅行，她使用do-while语句来帮助她安排旅行的行程。
首先，她选择旅行的目的地和出发日期。
然后，她询问自己是否还要添加其他目的地。
如果是，则继续添加目的地和出发日期，否则结束计划并输出旅行的行程安排。
DO-WHILE循环语句的翻译程序设计(简单优先法、输出三地址表示)
附件1：学号：0120910340525课程设计题目DO-WHILE（简单优先法、输出三地址表示）学院计算机科学与技术专业计算机科学与技术班级0905姓名明正超指导教师杨克俭2012 年 1 月 3 日课程设计任务书学生姓名：明正超专业班级：计算机0905班指导教师：杨克俭工作单位：计算机科学与技术学院题目: DO-WHILE循环语句的翻译程序设计（简单优先法、输出三地址表示）初始条件：理论：学完编译课程，掌握一种计算机高级语言的使用。
实践：计算机实验室提供计算机及软件环境。
如果自己有计算机可以在其上进行设计。
要求完成的主要任务:（包括课程设计工作量及其技术要求，以及说明书撰写等具体要求）（1）写出符合给定的语法分析方法的文法及属性文法。
（2）完成题目要求的中间代码三地址表示的描述。
（3）写出给定的语法分析方法的思想，完成语法分析和语义分析程序设计。
（4）编制好分析程序后，设计若干用例，上机测试并通过所设计的分析程序。
（5）设计报告格式按附件要求书写。
课程设计报告书正文的内容应包括：1 系统描述（问题域描述）；2 文法及属性文法的描述；3 语法分析方法描述及语法分析表设计；4 按给定的题目给出中间代码形式的描述及中间代码序列的结构设计；5 编译系统的概要设计；6 详细的算法描述（流程图或伪代码）；7 软件的测试方法和测试结果；8 研制报告（研制过程，本设计的评价、特点、不足、收获与体会等）；9 参考文献（按公开发表的规范书写）。
时间安排：设计安排一周：周1、周2：完成系统分析及设计。
周3、周4：完成程序调试及测试。
周5：撰写课程设计报告。
设计验收安排：设计周的星期五第1节课开始到实验室进行上机验收。
设计报告书收取时间：设计周的次周星期一上午10点。
指导教师签名： 2011年 11月23日系主任（或责任教师）签名： 2011年 11月 23日（一）系统描述根据所学编译原理有关词法分析，语法分析，语义分析有关规则,对DO_WHILE循环语句的翻译程序进行设计，使用高级语言或者伪代码形式，进行编写，其中要求使用简单优先法法并在程序的最终结果中显示出表达式的三地址形式。
do while 循环语句 实例 c语言
C语言中的do while循环语句是一种常用的循环结构，它与while循环和for循环一样，能够让程序根据条件多次执行特定的代码块。
本文将介绍do while循环语句的基本语法和工作原理，并通过实例演示其在C语言中的应用，帮助读者更好地理解和掌握这一重要的编程概念。
一、基本语法在C语言中，do while循环语句的基本语法如下：1. do2. {3. // 待执行的代码块4. // 可能包括一些需要循环执行的操作5. }6. while (条件表达式);其中，关键字do和while分别表示循环的开始和结束，大括号内的代码是需要执行的循环体，条件表达式则决定了循环何时结束。
do while循环与while循环的不同之处在于，它先执行一次循环体，再判断条件是否成立，即使条件不成立也至少会执行一次。
二、工作原理do while循环的工作原理如下：1. 首先执行循环体内的代码；2. 然后判断条件表达式的值，如果为真，则继续执行循环体内的代码，否则结束循环。
无论条件表达式的值如何，do while循环至少会执行一次循环体内的代码。
这一特性使得do while循环在某些情况下比while循环更加适用，特别是当需要至少执行一次循环体内的代码时。
三、实例演示接下来，我们通过一个实例演示do while循环在C语言中的应用。
假设我们需要编写一个程序，计算1到10的整数之和，并将结果输出到屏幕上。
以下是相应的C语言代码：```c#include <stdio.h>int m本人n(){int num = 1;int sum = 0;do{sum += num;num++;} while (num <= 10);printf("1到10的整数之和为：d\n", sum);return 0;}```在这个示例中，我们首先定义了两个变量num和sum，分别用于存储当前的整数和整数之和。
Visual Foxpro程序设计第四章第6讲 DO WHILE循环结构
DO WHILE .NOT. EOF()
DO CASE
CASE zcmc="教授"
t1=t1+1
CASE zcmc="副教授"
t2=t2+1
8
CASE zcmc="讲师"
中国矿业大学计算机学院 李向群
t3=t3+1
OTHERWISE
t4=t4+1
ENDCASE
SKIP
ENDDO
@1,10 SAY " 教授的人数："+STR(t1)
@3,10 SAY "副教授的人数："+STR(t2)
@5,10 SAY "讲师的人数："+STR(t3)
@7,10 SAY "助教的人数："+STR(t4)
USE
RETURN
9
中国矿业大学计算机学院 李向群
（1）DO WHILE循环又称_____循环。 （2）当循环条件为______是开始执行DO WHILE循环。 （3）LOOP语句的功能是_________。 （4）EXIT语句的功能是________。
EXIT语句的功能是退出循环。EXIT语句可以放在循环 体内的任何位置，当执行EXIT语句时，直接退出循环， 执行ENDDO后面的语句。通常，EXIT语句是在条件语 句控制下，当条件得到满足时便跳出循环。
6
DO WHILE 循环
中国矿业大学计算机学院 李向群
例1:计算 S=1+2+……+100
ENDDO
3
DO WHILE 循环结构
中国矿业大学计算机学院 李向群
c++的do while语句
C++中的Do While语句是一种循环语句，它和While语句的作用类似，都是用来控制程序的循环执行。
在C++中，Do While语句的使用非常灵活，可以帮助程序员实现各种复杂的逻辑操作。
下面将详细介绍C++中Do While语句的相关内容。
一、Do While语句的基本语法C++中的Do While语句的基本语法如下：```do {// 这里是循环体} while (条件表达式);```在这个语法结构中，循环体是一系列需要重复执行的语句，条件表达式是一个逻辑表达式，用来控制循环的终止条件。
当条件表达式的值为真时，循环体会被重复执行；当条件表达式的值为假时，循环体将不再执行。
二、Do While语句的执行过程C++中的Do While语句的执行过程如下：1. 程序会执行一次循环体的代码；2. 程序会判断条件表达式的值，如果为真，则继续执行循环体的代码，否则结束循环。
需要注意的是，无论条件表达式的值如何，Do While语句至少会执行一次循环体的代码。
三、Do While语句的使用注意事项在使用C++中的Do While语句时，需要注意以下几个问题：1. 循环体中的代码应该能够在有限次数内执行完成，避免出现无限循环的情况；2. 条件表达式应该能够在循环执行过程中得到修改，以便控制循环的次数和终止条件；3. 在编写循环体和条件表达式时，应该考虑代码的执行效率和逻辑正确性。
四、Do While语句的应用场景C++中的Do While语句可以用于各种不同的场景，例如：1. 实现一个菜单选择的功能，让用户可以不断地选择不同的操作；2. 处理文件或网络数据，直到读取完所有数据为止；3. 进行一些需要重复执行的初始化操作，直到满足某个条件为止。
总结在C++中，Do While语句是一种非常常用的循环语句，它可以帮助程序员实现各种复杂的逻辑操作。
通过合理地使用Do While语句，可以提高程序的执行效率和逻辑正确性，从而实现更加强大和灵活的功能。
编译原理课程设计_算术表达式、for、while语句转换为四元式
计算机与信息学院《操作系统与编译原理联合课程设计报告》专题：编译原理部分学生姓名：学号：专业班级：指导教师：2014 年 7 月一、设计目标设计一个语法制导翻译器，将算术表达式、for语句、while语句翻译成四元式。
要求先确定一个定义算术表达式、for语句、while语句的文法，为其设计一个语法分析程序，为每条产生式配备一个语义子程序，按照一遍扫描的语法制导翻译方法，实现翻译程序。
对用户输入的任意一个正确的表达式，程序将其转换成四元式输出。
二、设计思路开发平台：Visual C++ MFC解决这个问题的方案分为以下几个步骤：1.将算数表达式、for语句、while语句转换为四元式的第一步为对读入的表达式进行处理，即删除不必要的空格、回车、换行等，保证之后的步骤能够顺利进行。
2.分析算术表达式、for语句、while语句的文法。
3.通过词法分析判断语句中的每个字符的类型，如：数字、字母、符号等。
4.建立每种文法的LR(0)分析表，通过每个文法的LR(0)分析表对相应的表达式进行语法分析。
5.在语法分析正确的情况下，通过语法分析的中间过程的符号栈输出四元式，四元式的形式为：（op arg1 arg2 result）。
（一）算术表达式转换为四元式将算术表达式转换为四元式首先考虑了括号的问题，对于不同的算术表达式第一步进行词法分析，即确定各种符号的位置。
而括号中的式子是优先级最高的，应该最先进行处理。
我使用了一个数组记录算术表达式中括号的位置，并且定义了first_cc和first_jj函数对括号的乘除法和加减法分别进行处理。
后将括号的式子以四元式的形式输出。
通过以上转换，已将原算术表达式中的括号中的容使用大写字母’A’、’B’……等代替（其中定义声明了change函数，用来将括号部分替换为大写字母）。
新的式子中，只含有加减乘除以及赋值这四种运算，后根据优先级的不同，逐步生成四元式。
其算法流程图如右图所示。
WHILE循环语句的翻译程序设计(LR方法、输出四元式)资料
目录课程设计任务书 (1)1系统描述 (2)2文法及属性文法描述 (2)2.1文法的描述 (2)2.2属性文法的描述 (2)3语法分析方法描述及语法分析表设计 (2)3.1语法分析表设计 (2)3.1.1文法的DFA (3)3.1.2LR(0)分析表 (4)3.1.3LR(0)分析方法描述说明 (4)4中间代码形式的描述及中间代码序列的结构设计 (4)5编译系统的概要设计 (5)5.1词法分析 (5)5.2语法分析 (6)5.3语法制导翻译 (7)6详细的算法描述 (8)7 软件的测试方法和测试结果 (14)8小结与体会 (18)9参考文献 (18)本科生课程设计成绩评定表 (20)课程设计任务书学生姓名：王世创专业班级：计算机0909班指导教师：高曙工作单位：计算机科学与技术学院题目: WHILE循环语句的翻译程序设计（LR方法、输出四元式）初始条件：理论：学完编译课程，掌握一种计算机高级语言的使用。
实践：计算机实验室提供计算机及软件环境。
如果自己有计算机可以在其上进行设计。
要求完成的主要任务:（包括课程设计工作量及其技术要求，以及说明书撰写等具体要求）（1）写出符合给定的语法分析方法的文法及属性文法。
（2）完成题目要求的中间代码四元式的描述。
（3）写出给定的语法分析方法的思想，完成语法分析和语义分析程序设计。
（4）编制好分析程序后，设计若干用例，上机测试并通过所设计的分析程序。
（5）设计报告格式按附件要求书写。
课程设计报告书正文的内容应包括：1 系统描述（问题域描述）；2 文法及属性文法的描述；3 语法分析方法描述及语法分析表设计；4 按给定的题目给出中间代码形式的描述及中间代码序列的结构设计；5 编译系统的概要设计；6 详细的算法描述（流程图或伪代码）；7 软件的测试方法和测试结果；8 研制报告（研制过程，本设计的评价、特点、不足、收获与体会等）；9 参考文献（按公开发表的规范书写）。
时间安排：设计安排一周：周1、周2：完成系统分析及设计。
do while语句格式
do while语句格式
嘿，朋友！你知道吗？do while 语句格式就像是一个固执的小孩，非得先把事情做一遍，然后再去判断条件是否满足。
比如说，你让这小孩去洗手，他会先洗一次，然后才会看看手是不是真的洗干净了。
在编程里，do while 语句是这样的：先执行一次循环体中的代码，然后再去判断条件。
就好比你参加一场比赛，先冲出去跑一圈，然后才看自己有没有达到规定的成绩。
假设我们要写一个程序，计算 1 到 10 的和。
用 do while 语句就会是这样：
int sum = 0;
int i = 1;
do {
sum += i;
i++;
} while (i <= 10);
你看，先不管三七二十一，把计算和、增加数字的操作做了，然后再看 i 是不是小于等于 10 来决定要不要继续。
这不就像是你先大胆地尝试做一件事，然后再看结果是不是符合预期嘛！
我觉得啊，do while 语句格式有时候虽然有点“任性”，但在某些情况下，还真是能解决大问题，让程序更加灵活多变呢！。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
（二）DO-WHILE循环语句的翻译程序设计（简单优先法、输出四元式）一、1.简单优先法的基本思想根据优先关系的定义，将简单优先文法中各文法符号之间的这种关系用一个矩阵表示，称作简单优先矩阵。
PDA读入一个单词后，比较栈顶符号和该单词的优先级，若栈顶符号优先级低于该单词，继续读入；若栈顶符号优先级高于或等于读入符号，则找句柄进行归约，找不到句柄就继续读入。
直到最后栈内只剩下开始符号，输入串读到“＃”为止。
此时识别正确。
可分点描述如下:（1）、对句型中相邻的文法符号规定优先关系，以寻找句型中的句柄;（2）、规定句柄内各相邻符号之间具有相同的优先级;（3）、规定句柄两端符号优先级要比位于句柄之外而又和句柄相邻的符号的优先级高，以先归约句柄;（4）、对于文法中所有符号，只要它们可能在某个句型中相邻，就要为它们规定相应的优先关系，若某两个符号永远不可能相邻，则它们之间就无关系.2.简单优先矩阵用于表示文法符号之间的简单优先关系的矩阵。
3.简单优先法的优缺点优点：技术简单,当做简单优先矩阵是要求较短。
缺点：适用范围小，分析表尺寸太大。
二、源代码实现：#include<iostream>#define MAX 35#include<list>#include<string>#include<fstream>using namespace std;#define TABLE_LEN 8#define STR_LEN 256int zhlen;char sTable[TABLE_LEN+1] = {"+-*/()i#"};//顺序索引int ShipTable[TABLE_LEN][TABLE_LEN] = //优先表{{ 1, 1,-1,-1,-1, 1,-1, 1},{ 1, 1,-1,-1,-1, 1,-1, 1},{ 1, 1, 1, 1,-1, 1,-1, 1},{ 1, 1, 1, 1,-1, 1,-1, 1},{-1,-1,-1,-1,-1, 0,-1,-2},{ 1, 1, 1, 1,-2, 1,-2, 1},{ 1, 1, 1, 1,-2, 1,-2, 1},{-1,-1,-1,-1,-1,-2,-1, 0}};char X,a;char VN[11]={'K','L','P','S','E','G','T','R','F','Q','\0'};char VT[15]={'i','=','<','>','+','-','*','/','(',')','d','w',';','#','\0'};charp[18][6]={"dLwS\0","SP\0",";SP\0","\0","iQE\0","TG\0","+TG\0","-TG\0","\0","FR\0","*FR\0","/FR\0","\0","(E)\0","i\0","=\0","<\0",">\0"};char stack[MAX];char queue[MAX];int sp,front;intM[10][14]={ {-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,0,-1,-1,-1},{1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1},{-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,3,2,-1},{4,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1},{5,-1,-1,-1,-1,-1,-1,-1,5,-1,-1,-1,-1,-1},{-1,-1,-1,-1,6,7,-1,-1,-1,-1,-1,8,8, 8},{9,-1,-1,-1,-1,-1,-1,-1,9,-1,-1,-1,-1,-1},{-1,-1,-1,-1,12,12,10,11,-1,-1,-1,12,12,12},{14,-1,-1,-1,-1,-1,-1,-1,13,-1,-1,-1,-1,-1},{-1,15,16,17,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1},};int f=0; int count=0;int c=0;char arr_i[MAX];char var[MAX]; //表格管理int td[MAX]; int t=0;int opd=-1;int opr=-1;int id=0;int d=0;char arr[MAX][4];//存放待输出的四元式//char keyword[2][7]={"do\0","while\0"};bool IsCharInStr(char c,char s[]){for(int i=0;s[i]!='\0';i++){if(s[i]==c)return true;}return false;}int GetIndex(char s[],char c){for(int i=0;s[i]!='\0';i++){if(c==s[i])return i;}return -1;}//string GetSubString(char s[],int from,int to){string st;for(int i=from;i<to;i++){st+=s[i];}return st;}/*******************************************翻译赋值表达式********************************************/void translatefuzhi(char *sInput){//栈结构的初始化char Stack[STR_LEN]={0};int index = 0;int top = 1;Stack[0] = '#';list<char> rPolish;list<string> Num;int begin=0;while(sInput[begin]!='='){if(IsCharInStr(sInput[begin],sTable)){cout<<"Equal expression is illegal!"<<endl;return ;}begin++;}Num.push_back(GetSubString(sInput,0,begin));int now = begin+1;int before = begin;rPolish.push_back('i');while(sInput[now]!='\0'){if(IsCharInStr(sInput[now],sTable)){char temp[3]={0};if(now-before>1){temp[0] = 'i';temp[1] = sInput[now];Num.push_back(GetSubString(sInput,before+1,now));}else{temp[0] = sInput[now];}int i=0;while(temp[i]!=0){int left = GetIndex(sTable,Stack[index]);int right = GetIndex(sTable,temp[i]);switch(ShipTable[left][right]){case -1://移入Stack[top++] = temp[i];index = top-1;i++;break;case 0://脱括号if(Stack[index]=='('){Stack[top++] = ')';Stack[index] = 'E';top = index+1;index--;}else//规约{if(top!=2){return;}rPolish.push_back('=');list<char>::iterator iter;list<string>::iterator siter=Num.begin();string fuzhi[256];int d=0,m;for(iter=rPolish.begin();iter!=rPolish.end();iter++){if(*iter=='i'){fuzhi[d++]=*siter;siter++;}else{fuzhi[d++]=*iter;}}m=d;string op1,op2;int flag,xiabiao=0;for(d=0;d<m;d++)cout<<"("<<fuzhi[d]<<","<<op1<<","<<op2<<","<<"T"<<xiabiao<<")"<<endl;fuzhi[d] = "T";fuzhi[d]+=(xiabiao+'0');xiabiao++;}//cout<<fuzhi[d];}return;}i++;break;case 1://归约if(Stack[index]=='i'){rPolish.push_back('i');Stack[index] = 'E';index--;}else{rPolish.push_back(Stack[index]);Stack[index-1] = 'E';top = index;index-=2;}break;default:return;}}before=now;}now++;}}int len(char str[]){int i=0;while(str[i]!='\0')i++;return i;}int index(char ch,char str[]){int i=0;while(str[i]!='\0'){if(ch!=str[i])i++;else break;}if(str[i]=='\0')return -1;return i;}void err(int n){if(n==1)cout<<"字符不匹配"<<endl;else if(n==2)cout<<"字符没有出现在产生式中"<<endl;else if(n==3)cout<<"没有找到合适的¨选产式"<<endl;else cout<<"该句子是文法语言的句子"<<endl;}void print(){cout<<"(";if(count<10)cout<<'0';cout<<count<<")";int i;for(i=0;i<=sp;i++)cout<<stack[i];for(;i<=20;i++)cout<<" ";for(i=0;i<front;i++)cout<<" ";for(;queue[i]!='#';i++)cout<<queue[i];cout<<queue[i];for(;i<=20;i++)cout<<" ";}void semantic(){if(VT[opr]=='='){arr[d][0]='=';arr[d][1]=arr_i[opd];arr[d][2]=id;arr[d][3] ='--';id++;}elseif(opr==-2){arr[d][0]='=';arr[d][1]=id-1;arr[d][2]=arr_i[opd];arr[d][3]='--';} else {arr[d][0]=VT[opr];arr[d][1]=arr_i[opd];arr[d][2]=id;if(VT[opr]!='<'&&VT[opr]!='>')arr[d][3]=id-1;else arr[d][3]=id+1;id++;} d++;}void syntax(){//语法分析int n;count++;print();X=stack[sp];a=queue[front];if(X=='#'&&a=='#')f=4;if(X<'A'||X>'Z'){if(X==a){sp--;front++;if(a!='i'){if(a!='d'&&a!='w'&&a!=';'&&a!='#'){opr=index(a,VT);semantic();}else if(a==';'||a=='w'||a=='#'){opr=-2;semantic();}cout<<'\t'<<'\''<<a<<"'匹配"<<endl;}else {opd=c;cout<<'\t'<<'\''<<arr_i[c++]<<"'匹配"<<endl;}}else f=1;}else {int tx=index(X,VN);int ta=index(a,VT);n=M[tx][ta];td[t++]=M[tx][ta];if(ta==-1){f=2;cout<<a<<endl;}else if(n==-1)f=3;else {sp--;cout<<'\t'<<X<<"->";if(len(p[n])!=0){for(inti=len(p[n])-1;i>=0;i--){stack[++sp]=p[n][i];cout<<p[n][len(p[n])-1-i];} cout<<endl;}else cout<<"空串"<<endl;}}if(f==0)syntax();else {td[t]='-1';err(f);}}void lexical(){ //词法分析int i,j,d;char ch;j=d=0;for(i=0;var[i]!='#';i++){ch=var[i];if(ch=='d'&&var[i+1]=='o'){cout<<"do"<<'\t'<<"keword"<<endl;queue[j++]='d' ;i+=1;}else if(ch=='w'){ch=var[i+1];if(ch=='h'){ch=var[i+2];if(ch=='i'){ch=var[i+3];if(ch=='l'){ch=var[i+4];if(ch=='e'){ch=var[i+5];}}}}cout<<"while"<<'\t'<<"keyword"<<endl;queue[j++]='w';i+=4;}else if(index(ch,VT)<=0){if(ch!='{'&&ch!='}'&&ch!='('&&ch!=')'){cout<<ch<<'\t'<<"variable:i["<<d++< <"]"<<endl;arr_i[d-1]=ch;queue[j++]='i';}else cout<<ch<<'\t'<<"bound"<<endl;}elseif(index(ch,VT)>0){cout<<ch<<'\t'<<"operator"<<endl;queue[j++]=ch;} }queue[j]='#';for(i=0;queue[i]!='#';i++)cout<<queue[i];cout<<endl;}int main(){int i=0,j=0;int len,length;char temp;char S='K';sp=front=0;stack[0]='#';sp++;stack[1]='K';cout<<" ****************************"<<endl;cout<<" * DO-WHILE循环语句 *"<<endl;cout<<" * (简单优先法输出四元式) *"<<endl;cout<<" ****************************"<<endl;ifstream table;table.open("dowhile.txt");if(!table){cout<<"error!";}table.seekg(0,ios::end);length = table.tellg();table.seekg(0,ios::beg);while(length!=table.tellg()){table.read((char*)&temp,1);var[i]=temp;i++;if(var[i]==' ')i--;if(var[i]=='#')break;}table.close();len=i;var[i]='\0';cout<<"词法分析"<<endl;lexical();char fuzhi[20];int flag1,fuzhilen;int s=0; for(i=0;i<len;i++){if(var[i]==';'){flag1=i;}}fuzhilen=flag1-2;for(i=3;i<flag1;i++){fuzhi[s++]=var[i];}fuzhi[s]='#';char shuru;char zh[100];int kaishi=0;zh[0]='d';for(kaishi=1;kaishi<s+1;kaishi++){zh[kaishi]=fuzhi[kaishi-1];}zh[kaishi++]=';';zh[kaishi++]='W';for(i=flag1+8;i<len;i++){if(var[i]=='}')break;else{zh[kaishi++]=var[i];}}zh[kaishi++]='#';zhlen=kaishi;cout<<"输出四元式"<<endl;cout<<"do"<<endl;translatefuzhi(fuzhi);cout<<"("<<var[flag1+9]<<","<<var[flag1+8]<<","<<var[flag1+10]<<","<<"T2"< <")"<<endl;cout<<"if T2=true goto T0"<<endl;return 0;}三、测试结果：词法分析部分：输出四元式：四、课程小结：这次编译原理课程设计的题目是用简单优先分析法进行DO-WHILE循环语句的语法分析,并输出四元式.设计的特点是利用定义每个终极符和非终极符之间优先关系,来进行符号的移进与规约,如果栈顶符号优先级低于该单词，继续读入；若栈顶符号优先级高于或等于读入符号，则找句柄进行归约，找不到句柄就继续读入。