编译原理 | 第三章课后习题答案

已于 2023-07-14 11:55:15 修改
阅读量2.5w 收藏 397
点赞数 42
分类专栏： 编译原理 文章标签： 算法 c语言 学习方法 学习 经验分享
于 2023-05-27 15:50:00 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sun80760/article/details/130896512
版权

本文为编译原理（第三版）【清华大学出版社】部分课后答案
本答案均截取自网络，如有错误，望指正

编译原理（第三版）【清华大学出版社】
编译原理（第三版）【清华大学出版社】

📌第1题

【题目】

 【答案】

 

 

1.void MatchToken(char expected)  
2.{
3.   if (lookahead != expected)  
4.    {  
5.        printf("syntax error \n");  
6.        exit(0);  
7.    }  
8.    else  
9.    {  
10.        lookahead = getToken();  
11.    }  
12.}  
13.// 解析非终结符T:T→ST’
14.void ParseT()  
15.{  
16.    if (lookahead == 'a' || lookahead == '⋀' || lookahead == '(')  
17.      ParseS();
18.      ParseT′();
19.   else {  
20.        printf("syntax error \n");  
21.        exit(0);
22.      } 
23.}
24.// 解析非终结符T’:T’→,ST’|
25.void ParseT′()
26.{
27.   if (lookahead == ',')
28.         {
29.          MatchToken(',');  
30.          ParseS();
31.          ParseT′();
32.        }
33.    else if (lookahead == ')')  
34.       {  
35.       }  
36.    else {  
37.        printf("syntax error \n");  
38.        exit(0);
39.      } 
40.}
41.// 解析非终结符S→a||(T)
42.void ParseS()  
43.{  
44.    switch (lookahead)  
45.    {  
46.    case 'a':  
47.        MatchToken('a');;  
48.        break;  
49.    case '⋀':  
50.        MatchToken('⋀');;  
51.        break;  
52.    case '(':  
53.        MatchToken('(');  
54.        ParseT();  
55.        MatchToken(')');  
56.       break;  
57.default:  
58.       printf("syntax error \n");  
59.        exit(0);
        }

📌第2题

【题目】

 【答案】 

1.void MatchToken(char expected)  
2.{
3.   if (lookahead != expected)  
4.    {  
5.        printf("syntax error \n");  
6.        exit(0);  
7.    }  
8.    else  
9.    {  
10.        lookahead = getToken();  
11.    }  
12.}  
13.// 解析非终结符E
14.void ParseE()  
15.{  
16.    if (lookahead == '(' || lookahead == 'a' || lookahead == 'b' || lookahead == '⋀')  
17.    {  
18.        ParseT();  
19.        ParseE′();  
20.    }  
21.    else  
22.    {  
23.        printf("syntax error \n");  
24.        exit(0);  
25.    }  
26.}  
27.// 解析非终结符E′
28.void ParseE′()  
29.{  
30.    if (lookahead == '+')  
31.    {  
32.        MatchToken(')');  
33.        ParseE();  
34.    }  
35.    else if (lookahead == ')' || lookahead == '#')  
36.    {  
37.    }  
38.    else  
39.    {  
40.        printf("syntax error \n");  
41.        exit(0);  
42.    }  
43.}
44.// 解析非终结符T
45.void ParseT()  
46.{  
47.    switch (lookahead)  
48.    {  
49.    case '(', 'a', 'b', ' ⋀':  
50.        ParseF();  
51.        ParseT′();  
52.        break;  
53.    default:  
54.        printf("syntax error \n");  
55.        exit(0);  
56.    }  
57.}  
58.// 解析非终结符T′ 
59.void ParseT′()  
60.{  
61.    switch (lookahead)  
62.    {  
63.    case '(', 'a', 'b', ' ⋀':  
64.        ParseT();  
65.        break;  
66.    case '+', ' )', '#':  
67.        break;  
68.    default:  
69.        printf("syntax error \n");  
70.        exit(0);  
71.    }  
72.}  
73.// 解析非终结符F
74.void ParseF()  
75.{  
76.    switch (lookahead)  
77.    {  
78.    case '(', 'a', 'b', ' ⋀':  
79.        ParseP();  
80.        break;  
81.    default:  
82.        printf("syntax error \n");  
83.        exit(0);  
84.    }  
85.}  
86.// 解析非终结符F′
87.void ParseF′()  
88.{  
89.    switch (lookahead)  
90.    {  
91.    case '*':  
92.        MatchToken('*');  
93.        ParseF’();  
94.        break;  
95.    case '+', '(', ')', 'a', 'b', ' ⋀', '#':  
96.        break;  
97.    default:  
98.        printf("syntax error \n");  
99.        exit(0);  
100.    }  
101.}  
102.// 解析非终结符P
103.void ParseP()  
104.{  
105.    switch (lookahead)  
106.    {  
107.    case '(':  
108.        MatchToken('(');  
109.        ParseE();  
110.        MatchToken(')');  
111.        break;  
112.    case 'a':  
113.        MatchToken('a');  
114.        break;  
115.    case 'b':  
116.        MatchToken('b');  
117.        break;  
118.    case '⋀':  
119.        MatchToken('⋀');  
120.        break;  
121.    default:  
122.        printf("syntax error \n");  
123.        exit(0);  
124.    }  
}

📌第3题

【题目】

 【答案】

📌第4题

【题目】

 【答案】

📌第5题

【题目】

 【答案】

📌第6题

【题目】

【部分答案】

1.void MatchToken(char expected)  
2.{  
3.    if (lookahead != expected)  
4.    {  
5.        printf("syntax error\n");  
6.        exit(0);  
7.    }  
8.    else  
9.    {  
10.        lookahead = getToken();  
11.    }  
12.}  
13.// 解析非终结符S  
14.void ParseS()  
15.{  
16.    switch (lookahead)  
17.    {  
18.    case 'a':  ParseA(); break;
19.    case 'b': ParseB(); break; 
20.    default:   printf("syntax error\n");  exit(0); 
21.       }  
22.}  
23.// 解析非终结符A  
24.void ParseA()  
25.{  
26.      if (lookahead == 'a')  
27.        { MatchToken('a');  
28.          ParseA’();  
29.       }
30.       else
31.       {   printf("syntax error\n");  
32.            exit(0);
33.        }  
34.}
35.// 解析非终结符B  
36.void ParseB()  
37.{  
38.      if (lookahead == 'b')  
39.        { MatchToken('b');  
40.          ParseB();  
41.       }
42.       else
43.       {     printf("syntax error\n");  
44.            exit(0);
45.        }  
46.}
47.void ParseA’()  // 解析非终结符A’ 
48.{  
49.    switch (lookahead)  
50.    {  
51.        case 'a':   ParseA();   break;  
52.        case '#':    break;  
53.        default:  
54.            printf("syntax error\n");  
55.            exit(0);  
56.        }  
57.}  
58.// 解析非终结符B′  
59.void ParseB′()  
60.{  
61.    switch (lookahead)  
62.    {  
63.    case 'b':   ParseB();   break;  
64.    case '#':    break;   
65.      default:  
66.         printf("syntax error\n");    
67.         exit(0);  
68.   } 
}  

 

1.void MatchToken(char expected)  
2.{  
3.    if (lookahead != expected)  
4.    {  
5.        printf("syntax error\n");  
6.        exit(0);  
7.    }  
8.    else  
9.    {  
10.        lookahead = getToken();  
11.    }  
12.}  
13.// 解析非终结符S  
14.void ParseS()  
15.{  
16.    if (lookahead == 'd' || lookahead == 'b' || lookahead == 'a' || lookahead == '#')  
17.    {  
18.        ParseB();  
19.        ParseS′();  
20.    }  
21.    else  
22.    {  
23.        printf("syntax error\n");  
24.        exit(0);  
25.    }  
26.}  
27.
28.// 解析非终结符S′  
29.void ParseS′()  
30.{  
31.    switch (lookahead)  
32.    {  
33.    case 'a':  
34.        MatchToken('a');  
35.        break;  
36.    case '#':  
37.        break;  
38.    default:  
39.        printf("syntax error\n");  
40.        exit(0);  
41.    }  
42.}  
43.// 解析非终结符B  
44.void ParseB()  
45.{  
46.    switch (lookahead)  
47.    {  
48.    case 'a', 'd', 'b', '#':  
49.        ParseD();  
50.        ParseB′();  
51.        break;  
52.    default:  
53.        printf("syntax error\n");  
54.        exit(0);  
55.    }  
56.}  
57.// 解析非终结符B′  
58.void ParseB′()  
59.{  
60.    switch (lookahead)  
61.    {  
62.    case 'b':  
63.        MatchToken('b');  
64.        break;  
65.    case '#', 'a':  
66.        break;  
67.    default:  
68.        printf("syntax error\n");  
69.        exit(0);  
70.    }  
71.}
72.// 解析非终结符D  
73.void ParseD()  
74.{  
75.    switch (lookahead)  
76.    {  
77.    case 'd':  
78.        MatchToken('d');  
79.        break;  
80.    case 'b', 'a', '#':  
81.        break;  
82.    default:  
83.        printf("syntax error\n");  
84.        exit(0);  
85.    }  
} 

 

1.void MatchToken(char expected)  
2.{  
3.    if (lookahead != expected)  
4.    {  
5.        printf("syntax error\n");  
6.        exit(0);  
7.    }  
8.    else  
9.    {  
10.        lookahead = getToken();  
11.    }  
12.}  
13.// 解析非终结符S  
14.void ParseS()  
15.{  
16.    switch (lookahead)  
17.    {  
18.    case 'a': 
19.             // 
20.         MatchToken('a'); 
21.          ParseA();
22.          MatchToken('a'); 
23.          ParseB();
24.         break;
25.      Case 'b': // 
26.          MatchToken('b'); 
27.          ParseA();
28.          MatchToken('b'); 
29.          ParseB();
30.         break;
31.          default:  
32.             printf("syntax error\n");  
33.             exit(0);  
34.   }        
35. }
36.// 解析非终结符A 
37. 
38.void ParseA()  
39.{  
40.      switch (lookahead )  
41.       case 'a':   ParseS();break;
42.       case 'b':   ParseS(); break;
43.       case 'd':   MatchToken('d'); MatchToken('b'); break;
44.       default: 
45.       {   printf("syntax error\n");  
46.            exit(0);
47.        }  
48.} 
49.// 解析非终结符B  
50.void ParseB()  
51.{  
52.      switch (lookahead )   
53.       { 
54.         case 'a':   MatchToken('a');break; 
55.         case 'b':   MatchToken('b'); ParseB(); break;
56.         default:
57.       {     printf("syntax error\n");  
58.            exit(0);
59.        }  
}  

1.void MatchToken(char expected)  
2.{  
3.    if (lookahead != expected)  
4.    {  
5.        printf("syntax error\n");  
6.        exit(0);  
7.    }  
8.    else  
9.    {  
10.        lookahead = getToken();  
11.    }  
12.}  
13.// 解析非终结符S  
14.void ParseS()  
15.{  
16.    switch (lookahead)  
17.    {  
18.    case 'i':  
19.        MatchToken('i');  
20.        break;  
21.    case '(':  
22.        MatchToken('(');  
23.        ParseE();  
24.        MatchToken(')');  
25.        break;  
26.    default:  
27.        printf("syntax error\n");  
28.        exit(0);  
29.    }  
30.}  
31.// 解析非终结符E  
32.void ParseE()  
33.{  
34.    switch (lookahead)  
35.    {  
36.    case 'i', '(':  
37.        ParseS();  
38.        ParseE’();  
39.        break;  
40.    default:  
41.        printf("syntax error\n");  
42.        exit(0);  
43.    }  
44.}  
45.// 解析非终结符E′  
46.void ParseE′()  
47.{  
48.    switch (lookahead)  
49.    {  
50.    case '+':  
51.        MatchToken('+');  
52.        ParseS();  
53.        ParseE′();  
54.        break;  
55.    case '-':  
56.        MatchToken('-');  
57.        ParseS();  
58.        ParseE′();  
59.        break;  
60.    case ')':  
61.        break;  
62.    default:  
63.        printf("syntax error\n");  
64.        exit(0);  
65.    }  
} 

1.void MatchToken(char expected)  
2.{  
3.    if (lookahead != expected)  
4.    {  
5.        printf("syntax error\n");  
6.        exit(0);  
7.    }  
8.    else  
9.    {  
10.        lookahead = getToken();  
11.    }  
12.}  
13.// 解析非终结符S  
14.void ParseS()  
15.{  
16.     if (lookahead == 'b')  
17.        { MatchToken('b');  
18.          ParseB();  
19.          ParseS’();  }
20.       else
21.       {     printf("syntax error\n");  
22.            exit(0);
23.        }  
24.} 
25.// 解析非终结符S’  
26.void ParseS’()  
27.{  
28.     switch (lookahead)   
29.  {  
30.         case 'a':   MatchToken('a'); ParseA();ParseS’();break;
31.       case '#':     break;  
32.        default:  
33.            printf("syntax error\n");  
34.            exit(0);  
35.        }  
36.}
37. // 解析非终结符A  
38.void ParseA()  
39.{  
40.     switch (lookahead)   
41.  {  
42.         case 'a':   MatchToken('a'); ParseB();break;
43.         case 'c':    MatchToken('c'); break;  
44.        default:  
45.            printf("syntax error\n");  
46.            exit(0);  
47.        }  
48.}
49.void ParseB()  // 解析非终结符B 
50.{  
51.    if (lookahead=='d')  
52.    {  
53.        MatchToken('d'); 
54.        ParseB();  
55.       }
56.       else  
57.            { printf("syntax error\n");  
58.              exit(0);  
59.         }  
60.}  
61.// 解析非终结符B′  
62.void ParseB′()  
63.{  
64.    switch (lookahead)  
65.    {  
66.    case 'a', '#':    break;  
67.    case 'b':   MatchToken('b'); ParseB’();  break;   
68.    default:  
69.         printf("syntax error\n");    
70.         exit(0);  
71.   } 
} 

1.void MatchToken(char expected)  
2.{  
3.    if (lookahead != expected)  
4.    {  
5.        printf("syntax error\n");  
6.        exit(0);  
7.    }  
8.    else  
9.    {  
10.        lookahead = getToken();  
11.    }  
12.}  
13.// 解析非终结符M  
14.void ParseM()  
15.{  
16.    switch (lookahead)  
17.    {  
18.    case 'b', '(':  
19.        ParseH();  
20.        ParseM′();  
21.        break;  
22.    default:  
23.        printf("syntax error\n");  
24.        exit(0);  
25.    }  
26.}  
27.// 解析非终结符M′  
28.void ParseM′()  
29.{  
30.    switch (lookahead)  
31.    {  
32.    case 'a':  
33.        MatchToken('a');  
34.        ParseH();  
35.        ParseM′();  
36.        break;  
37.    case ')','#':  
38.        break;  
39.    default:  
40.        printf("syntax error\n");  
41.        exit(0);  
42.    }  
43.}  
44.// 解析非终结符H  
45.void ParseH()  
46.{  
47.    switch (lookahead)  
48.    {  
49.        case 'b':  
50.             MatchToken('b');  
51.             ParseH’();  
52.             break;  
53.        case '(':  
54.            MatchToken('(');  
55.            ParseM();  
56.            MatchToken(')');  
57.            break;  
58.        default:  
59.            printf("syntax error\n");  
60.            exit(0);  
61.        }  
62.}  
63.// 解析非终结符H′  
64.void ParseH′()  
65.{  
66.    switch (lookahead)  
67.    {  
68.    case '(':  
69.        MatchToken('(');  
70.        ParseM();  
71.        MatchToken(')');  
72.        break;  
73.    case ')', 'a', '#':  
74.        break;  
75.    default:  
76.        printf("syntax error\n");  
77.        exit(0);  
78.    }  
}

📌第7题

【题目】

 【答案】

 

 

拟墨画扇_
关注
  • 42
    点赞
  • 踩
  • 397
    收藏
    觉得还不错? 一键收藏
  • 7
    评论
专栏目录
编译原理第三版课后习题
qq_42711971的博客
12-22 9万+
编译原理课后习题 都是编译原理老师上课布置的课后习题的整理 第二章 1.P34-4 证明G(E)是二义的。 E->EOE|(E)|v|d O->+|* 2.P34-8 上下文无关文法G[S] :S->SS*|SS+|a 答：（1）S=>SS*=>SS+S*=>aS+S*=>aa+S*=>aa+a* (语法树略) （2）*和+的后缀表达式，即逆波兰式...
编译原理习题答案
chiefemail的专栏
11-22 1万+
第一章 编译程序概述1.1 什么是编译程序　　编译程序是现代计算机系统的基本组成部分之一，而且多数计算机系统都含有不止一个高级语言的编译程序。对有些高级语言甚至配置了几个不同性能的编译程序。1.2编译过程概述和编译程序的结构　　编译程序完成从源程序到目标程序的翻译工作，是一个复杂的整体的过程。从概念上来讲，一个编译程序的整个工作过程是划分成阶段进行的，每个阶段将源程序的一种表示形式转换成另
编译原理陈火旺第三版第十章答案
capture3333的博客
07-21 2979
编译原理第十章答案
编译原理（第3版） 清华大学出版社 黄贤英等人著作 部分课后习题答案
JamesHuang的博客
05-12 4万+
大家好，我是小黄鸭，平时作业，记录一下，方便考试复习 第一章 第一题 解释下列术语 翻译程序：翻译程序是一种把源语言书写的程序翻译成另一种语言书写的程序，而且后者和前者在逻辑上是等价的 编译程序：如果源语言为高级语言，目标语言为某台计算机上的汇编语言或机器语言（低级语言），则此翻译程序称为编译程序 解释程序：解释，执行高级语言源程序的程序 源程序：源语言编写的程序为源程序，一般为用高级语言编写的程序 目标程序：指用低级语言（机器语言或汇编语言）编写的程序 遍：是对源程序或其等价的中间语言程序从头到尾扫
编译原理及实践教程(黄贤英_王柯柯_编著)_习题答案
11-23
编译原理及实践教程(黄贤英_王柯柯_编著)_习题答案 编译原理及实践教程(黄贤英_王柯柯_编著)_习题答案
编译原理第三版答案
热门推荐
@you的博客
10-11 8万+
点此下载 第一章 1．典型的编译程序在逻辑功能上由哪几部分组成？ 答：编译程序主要由以下几个部分组成：词法分析、语法分析、语义分析、中间代码生成、中间代码优化、目标代码生成、错误处理、表格管理。 2. 实现编译程序的主要方法有哪些？ 答：主要有：转换法、移植法、自展法、自动生成法。 3. 将用户使用高级语言编写的程序翻译为可直接执行的机器语言程序有哪几种主要的方式？ ...
编译原理课后习题答案(清华大学第三版)
xqmids99的博客
04-26 2万+
第二章答案 第三章答案 第四章答案 第五章答案 第六章答案
编译原理第三版清华大学出版课后习题答案（第一章）
qq_60536278的博客
10-15 7608
编译程序通常包含8个组成成分：词法分析程序，语法分析程序，语义分析程序，中间代码生成程序，中间代码优化程序，目标代码生成程序，表格管理程序和错误处理程序。第四题：对下列错误信息，请指出可能是编译的那个阶段（词法分析、语法分析、语义分析、代码生成）报告的。第二题：编译程序有哪些主要构成成分？各自的主要功能是什么？第三题：什么是解析程序？它与编译程序主要的不同是什么？
编译原理 课后答案 第六章 清华
05-07
编译原理 课后答案 第六章 清华 张素琴 第二版
编译原理第三版课后习题答案
06-15
《编译原理第三版》是计算机科学领域的一本经典教材，涵盖了编译器设计的核心理论和技术。这本书的课后习题旨在帮助读者深入理解和掌握编译器构建过程中的各个环节，包括词法分析、语法分析、符号表管理、语法制导...
清华编译原理第三版答案
01-06
清华编译原理第三版答案
编译原理课后习题答案 清华大学
09-15
编译原理课后习题答案_清华大学_第二版 内容清晰
编译原理（第三版）答案.pdf
12-12
编译原理（第三版）答案.pdf
编译原理课后答案（第三版）
11-07
程序设计语言（编译原理）第三版，课后习题答案，国防工业出版社，内容包括词法分析，语法分析，自上而下分析文法，自下而上分析文法等
编译原理课后练习部分习题
12-22
这里收集了编译原理第三版中的课后习题的答案，主要是老师上课布置的一些习题P34 4、8、10、13(1),(2)、18(2) P64 1 （1） 2、 4 （b） 14，P99练习 １、 2（１），P121 1、3 (1)(2)
虎书(现代编译原理)课后习题答案
04-14
在"虎书(现代编译原理)课后习题答案"中，涵盖了第二章到第七章的部分习题解答。这些答案主要聚焦于最常见的问题，可能未包含所有学生的个体疑问，因为它们主要基于教师批改作业时发现的普遍困难和误解。这使得这个...
编译原理陈火旺第三版第七章课后题答案
capture3333的博客
04-27 1万+
编译原理陈火旺第三版第七章课后题答案
编译原理 | 第一章课后习题答案
鷾
03-01 3956
本文为编译原理（第三版）【清华大学出版社】第一章部分课后习题答案。本答案均截取自网络，如有错误，望指正
编译原理清华大学csdn
最新发布
09-16
编译原理是计算机科学中的一门重要课程，主要研究将高级语言代码转换为机器语言执行的过程和方法。清华大学作为中国顶尖的高等学府，自然也开设有关于编译原理的课程。而CSDN是一个面向程序员的知识分享网站，上面有很多关于编程和计算机科学的内容。 清华大学的编译原理课程主要包括编译原理基本概念、词法分析、语法分析、语义分析、中间代码生成、目标代码生成等内容。通过学习这门课程，学生可以了解编译器的基本原理和常用算法，能够编写简单的编译器前端，并且对于理解高级语言的底层运行原理也有很大帮助。 在CSDN上，有很多与编译原理相关的学习资源。这些资源可以帮助人们更好地理解和学习编译原理的知识。例如，有关词法分析器和语法分析器的实现原理和实践经验，关于语义分析和代码生成的案例和技巧等。这些内容可以帮助程序员更好地理解编译原理的核心概念和实际应用，提高他们的编程能力和代码质量。 总之，编译原理是计算机科学中重要的一门课程，清华大学为学生提供了相关的教学资源，而CSDN上也有很多与编译原理相关的学习资料。通过学习编译原理，人们可以深入了解编程语言的底层运行原理，并且提高自己的编程能力。
评论 7
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值