本书从为什么学习程序设计语言、评估程序设计语言和语言结构的标准、常见的设计权衡以及基本的实现方法开始讲起，然后简略描述了本书讨论的大部分语言的演化。在第3章讨论语法和语义，在第4章为不开设编译课程的学校新增了词法和语法分析的内容。本书主要是描述命令式语言的主要结构的设计问题及其实现，涉及变量、数据类型、表达式和赋值语句、控制语句、子程序、数据抽象设施、支持面向对象程序设计的语言特性（继承和动态方法绑定）、并发程序单元和异常处理等内容。最后两章描述了函数式程序设计语言和逻辑程序设计语言。
本书适用面很广，既可用作计算机专业本科生程序设计语言课程的教材，也可用作自学语言的参考书。经验丰富的计算机工作者也可以用它来更新知识。
无
本书的目标、结构和方式与先前的四个版本相同。主要的目标是为读者提供对已有的和未来的程序设计语言进行批判性评估所需的工具。另一个目标是为读者学习编译器设计做准备。
第5版是第4版的一个更新版本，其中增加了新的一章描述词法分析和语法分析，还增加了对 JavaScript 的一些有趣的特征描述。还修改了Java 线程的讨论以反映这种语言后来版本中的变化。在许多地方，关于比较老的语言（例如ALGOL 68 和 Modula-2）的材料或者被删除或者用当代的语言（如 C++、Java和 Perl）中的类似材料来替代。
本书通过讨论各种语言结构的设计问题，用某些常用语言检查这些结构的设计选择，以及批判性地比较设计替代方案，来描述程序设计语言的基本概念。
对程序设计语言的任何认真的研究都需要考虑一些相关的课题，包括描述程序设计语言的语法和语义的形式方法。各种语言结构的实现技术也必须被考虑：语法和语义是第3章的主题，词法分析和语法分析在第4章中讨论，子程序链接的实现是第10章的主题。一些其他语言结构的实现也在本书的不同部分被讨论。
下面的段落概略说明第5版的内容：
第1章首先讨论为什么学习程序设计语言，然后讨论评估程序设计语言和语言结构的标准，还有对语言设计的主要影响、常见的设计权衡以及基本的实现方法。
第2章简略描述大部分在本书中讨论的重要的语言的演化。虽然没有完整描述一种语言，但对每种语言的起源、目的和贡献都进行了讨论。这种历史回顾为理解当代语言设计的实践和理论基础提供必需的背景。它也给进一步研究语言设计和评估提供动力。除此之外，因为书中的其他章都不依赖于第2章，它可以作为一个独立的部分来阅读。
第3章讨论描述程序设计语言语法主要的形式方法，即BNF。接着是属性文法的描述，它在编译器设计中扮演着重要的角色。然后是语义描述这个困难的任务。最后简短介绍三个最常用的语义描述方法：操作语义、公理语义和指称语义。
第4章是新增加的，它介绍词法分析和语法分析。这一章是为那些课程设置中没有编译器设计课程的学校准备的。书中的后续章节都不依赖于第4章中的材料。
从第5章到第14章详细地描述命令式语言主要构造的设计问题。对每一种结构，描述和评估几种范例语言的设计选择。第5章是变量的多种特性。第6章是数据类型。第7章解释表达式和赋值语句。第8章描述控制语句。第9章和第10章是子程序及其实现。第11章讨论数据抽象设施。第12章讨论支持面向对象程序设计的语言特征（继承和动态方法绑定）。第13章是关于并发程序单元的。而第14章是关于异常处理的。
最后两章（第15章和第16章）描述两种最重要的与命令式程序设计不同的程序设计范型：函数式程序设计和逻辑程序设计。第15章介绍Scheme语言，包括它的一些基本功能、特殊的形式和函数形式，以及用Scheme语言写的一些简单函数的例子。然后通过对 COMMON LISP、ML和 Haskell的简短描述来说明各种不同的函数式语言。第16章介绍逻辑程序设计和逻辑程序设计语言Prolog。
致教师
在科罗拉多大学科罗拉多斯普林斯分校低年级的程序设计语言课程中，本书是这样使用的：我们详细地讲授第1章和第3章，虽然学生会很有兴趣自己阅读。由于第2章没有难的技术内容，而且，正如我们前面谈到的，后面章节的材料都不依赖于这一章，它能被完全地跳过。因为我们要求有编译器设计课程，所以第4章也不讲授。
从第5章到第9章，以及第11章对有 C++、Ada 和 Java 的广泛程序设计经验的学生是相对容易的。第10、12、13和14章比较困难一些，因而需要比较详细地讲授。
第15章和第16章对大多数低年级学生是全新的。 在理想的情况下，应该对那些要求学习这两章内容的学生提供 Scheme 和 Prolog的语言处理器。书中有充足的材料使学生可以写简单的程序。
本科课程或许不能详细地包括最后两章的全部。然而，研究生课程可以跳过前面几章关于命令式语言的部分，从而可以完整地讨论非命令式语言。
教辅材料
1. 教这门课的教师可以得到许多练习题的答案。如需要请与当地的AW销售人员联系。
2. 教师也可以得到一组教学笔记幻灯片。这些幻灯片是以微软公司 PowerPoint 源文件的形式提供的。书的前十五章，每章一个文件。这些笔记幻灯片是在过去几年中以这本书为基础教课时写成的。
3. 书中所有的图的 PowerPoint幻灯片也包含在教辅材料中。
4. 请在线访问 www.aw.com/cssupport以获得有关这本书的教辅材料的更多信息。
语言处理器
这本书中讨论的一些程序设计语言的处理器以及一些关于程序设计语言的信息能在下列 Web 站点获得：
Java http://java.sun.com
Haskell http://haskell.org
Scheme http://www.cs.rice.edu/CS/PLT/packages/drscheme/
Perl http://www.perl.com
(美)Robert W.Sebesta：Robert W.Sebesta: 科罗拉多大学科罗拉多斯普林斯分校计算机科学系的副教授和系主任。Sebesta教授在科罗拉多大学博尔德分校获得应用数学学士学位，在宾夕法尼亚州立大学获得计算机科学硕士和博士学位。他有三十多年的教授计算机科学的经验。他的专业兴趣是设计和评估程序设计语言、编译器设计以及软件测试方法和工具。他是ACM和IEEE计算机学会的成员。
张勤：暂无简介
本书由 Robert W. Sebesta 所著，是一本在美国、加拿大广泛使用的大学教材，被用于计算机科学或计算机工程专业二、三年级的程序设计语言课程。这里翻译的是它的第5版。它被多次再版的事实说明了该书受欢迎的程度。一本书的市场价值常常反映出了它在技术上的价值。
计算机科学离不开程序设计语言。在计算机工作者的一生中必然会接触到好几种语言。当一种新的语言问世并被广泛接受时，你必须学习这种语言以更新你的知识。当接手一个新项目时，你必须为它选择一种最合适的语言，也许你还必须为一个项目而专门设计并实现一种新的语言。本书向你提供程序语言方面广泛而又有深度的知识。该书并不教授如何使用一种语言，它讨论的是语言的结构与特性，这些结构与特性在不同语言中的不同设计与实现，以及这些结构与特性带给语言的优点与缺点。掌握了这些知识，会让读者在学习新的语言时有一种“似曾相识”的感觉，语言中的许多特性都会在预料之中。当需要选择一种语言时，你可以根据各种语言的适用性及它们的优缺点做到知“语”善用。当需要构造一种新语言时，你更会知道应该从何处着手，来选择出最优的设计实现方案。另外，本书所提供的关于语言“内部” 结构的设计与实现的知识，正是大多数介绍语言使用方法的书籍所缺少的。这种知识能够让读者将一种语言的优点充分地发挥出来，并且避免该语言本身的缺点可能带来的种种问题。
可以将本书的主要内容分成为四个部分。第一部分包括它的第1章和第2章；第二部分包括第3章和第4章。第三部分则是从第5章到第14章；第四部分包括第15章和第16章。第1章介绍一些预备性的基础知识。第2章是对程序设计语言的历史所进行的有趣且引人入胜的回顾。这一章包括了一种在第二次世界大战期间在德国开发的功能十分齐全，然而鲜为人知的语言：Plankalk焞。它介绍了 FORTRAN 出人预料的巨大成功及其深远的影响。还包括 ALGOL、COBOL、Pascal、Ada、C、C++以及最新的 Java等语言，几乎涉及了所有重要的语言。它为程序设计语言描绘了一个完整的家谱。在这里，各种语言的来龙去脉变成了一幅清晰的图画。
第二部分中的第3章是关于语法和语义的描述。语法和语义是语言中的两大要素。这一章讨论对于程序设计语言的语法和语义进行形式描述的方法。这一部分中的第4章简明地介绍了程序设计语言的编译原理。这一章是专门为不开设编译技术课程的学校而编写的。然而实际上，即使你将要去啃一本编译技术的大部头，或者是将要去学习一门编译课程，这一章也很值得读一读。它会让你事先获得编译技术的概貌，而不至于一头扎入大量的技术细节，导致“不识卢山真面目”。
第三部分是这本书的主要内容，也是其中最精彩之处。这一部分使用了大量的篇幅，详细地剖析语言的各个组成部分设计的实现。程序设计语言的主要组成部分包括变量、类型、表达式、赋值语句、控制结构、子程序等等。本书对于语言的每一个组成部分首先是讨论其必要性，接着分析设计中所必须解决的问题，然后给出了各种不同的解决方法，并分别评价各种方法的优缺点，最后讨论了一些重要语言中具体设计的实现。在读完这一部分之后，一门语言将不再是一个黑盒子，而像是一台在硬件高手面前打开了盖子的计算机。各个部分的特征、优劣以及对整体性能的影响，都变得清清楚楚。这些有关语言的知识对于编写可靠高效的程序将是极有帮助的。例如，如果一位程序员了解他所使用的语言中的子程序调用的代价，他就能根据对程序速度和程序模块化的特定要求而决定是否使用子程序。同样，如果一位程序员熟悉他所使用的语言中的变量引用环境，他的程序中由于变量引用错误而产生的“疑难病症”就会少得多。有时，这些知识还能让你判断出编译器内部的错误，而不只是一味地挑剔你的那些无辜的程序。
最后的一部分介绍两种“另类”的语言。这里所介绍的是，以 LISP为代表的函数式语言以及逻辑程序设计语言 Prolog。它们都是人工智能语言。在此之前所讨论的语言都属于命令式语言。命令式语言的程序向机器发出一条条可执行的命令语句。然而，在函数式和逻辑程序设计语言中程序设计却遵循一种完全不同的思维方式，连算法设计都大相径庭。在这些语言里，没有我们习惯的似乎是必不可少的赋值语句、循环语句等等。使用这些语言时，程序设计不再能够先画框图，然后将每一个框图翻译成一条或几条命令语句。函数式程序设计通过函数调用来解决问题，逻辑程序设计则是通过逻辑推理来解决问题。在这两章中，作者给出了几个很好的例子，让你很容易转换脑筋，接受这两种不同的方式。还给出了妙不可言的算法来解决传统的问题。 这两章会帮助你拓广解决问题的思路。也许在你的下一个项目中，这两种程序设计的知识能够使你在解决问题时另辟蹊径，获取出人意料的成功。
这是一本适应面很广的书，既可用作大学程序设计语言课程的教材，也可用作自学语言的读物。毕业多年的经验丰富的计算机工作者也可以用它来更新知识。
第1章 基本概念 1
1.1 学习程序设计语言原理的缘由 2
1.2 程序设计领域 3
1.2.1 科学应用 4
1.2.2 商务应用 4
1.2.3 人工智能 4
1.2.4 系统程序设计 4
1.2.5 脚本语言 5
1.2.6 专用语言 5
1.3 语言评估标准 5
1.3.1 可读性 6
1.3.2 可写性 10
1.3.3 可靠性 11
1.3.4 代价 12
1.4 影响语言设计的因素 13
1.4.1 计算机体系结构 13
1.4.2 程序设计方法学 14
1.5 语言分类 15
1.6 语言设计中的权衡 15
1.7 实现方法 16
1.7.1 编译方法 17
1.7.2 单纯解释 19
1.7.3 混合实现系统 20
1.8 程序设计环境 20
本章小结 21
复习题 21
练习题 22
第2章 主要程序设计语言的发展 23
2.1 Zuse的Plankalk焞语言 25
2.1.1 历史背景 25
2.1.2 语言概述 25
2.2 最小硬件的程序设计：伪代码 26
2.2.1 短代码 26
2.2.2 快速编码 27
2.2.3 UNIVAC “编译”系统 27
2.2.4 相关的工作 27
2.3 IBM 704 计算机和 FORTRAN 语言 27
2.3.1 历史背景 27
2.3.2 设计过程 28
2.3.3 FORTRAN I 概况 28
2.3.4 FORTRAN II 概况 29
2.3.5 FORTRAN IV、FORTRAN 77和FORTRAN 90 29
2.3.6 评估 30
2.4 函数式程序设计：LISP语言 31
2.4.1 人工智能和表数据处理的开始 31
2.4.2 LISP 的设计过程 32
2.4.3 语言概述 32
2.4.4 评估 33
2.4.5 LISP 的两种后代语言 34
2.4.6 相关的语言 35
2.5 迈向成熟的第一步： ALGOL 60 35
2.5.1 历史背景 35
2.5.2 早期设计过程 36
2.5.3 ALGOL 58 概况 36
2.5.4 ALGOL 58 报告的接受 36
2.5.5 ALGOL 60 的设计过程 37
2.5.6 ALGOL 60 语言概述 37
2.5.7 ALGOL 60 的评估 38
2.6 商务记录的计算机化：COBOL 39
2.6.1 历史背景 39
2.6.2 FLOW-MATIC 语言 39
2.6.3 COBOL 的设计过程 40
2.6.4 评估 40
2.7 分时操作的开始：BASIC 42
2.7.1 设计过程 43
2.7.2 语言概述 43
2.7.3 评估 43
2.8 用途广泛的语言：PL/I 44
2.8.1 历史背景 44
2.8.2 设计过程 45
2.8.3 语言概述 45
2.8.4 评估 46
2.9 两种早期的动态语言：APL 和 SNOBOL 47
2.9.1 APL 的起源与特征 47
2.9.2 SNOBOL 的起源与特征 47
2.10 数据抽象的开始：SIMULA 67 48
2.10.1 设计过程 48
2.10.2 语言概述 48
2.11 正交性语言的设计：ALGOL 68 48
2.11.1 设计过程 49
2.11.2 语言概述 49
2.11.3 评估 49
2.12 ALGOL 系列语言的重要后代语言 50
2.12.1 为简单性而设计的语言: Pascal 50
2.12.2 可移植的系统语言: C 51
2.12.3 ALGOL 的其他后代语言 53
2.13 基于逻辑的程序设计：Prolog 54
2.13.1 设计过程 54
2.13.2 语言概述 54
2.13.3 评估 55
2.14 历史上最大规模的语言设计：Ada 55
2.14.1 历史背景 55
2.14.2 设计过程 55
2.14.3 语言概述 57
2.14.4 评估 57
2.14.5 Ada 95 58
2.15 面向对象的程序设计：Smalltalk 59
2.15.1 设计过程 59
2.15.2 语言概述 60
2.15.3 评估 60
2.16 结合命令式与面向对象的特性：C++ 61
2.16.1 设计过程 61
2.16.2 语言概述 62
2.16.3 评估 62
2.16.4 一种相关语言: Eiffel 62
2.17 万维网程序设计：Java 63
2.17.1 设计过程 63
2.17.2 语言概述 63
2.17.3 评估 64
本章小结 65
文献注释 65
复习题 66
练习题 67
第3章 描述语法和语义 69
3.1 介绍 70
3.2 描述语法的普遍问题 70
3.2.1 语言识别器 71
3.2.2 语言生成器 71
3.3 描述语法的形式方法 71
3.3.1 巴科斯-诺尔范式与上下文无关文法 71
3.3.2 扩展的BNF 79
3.3.3 语法图 80
3.3.4 文法与识别器 80
3.4 属性文法 80
3.4.1 静态语义 81
3.4.2 基本概念 81
3.4.3 属性文法定义 81
3.4.4 内在属性 82
3.4.5 属性文法的例子 82
3.4.6 计算属性值 83
3.4.7 评估 83
3.5 描述程序的意义：动态语义 84
3.5.1 操作语义 84
3.5.2 公理语义 86
3.5.3 指称语义 93
本章小结 96
文献注释 97
复习题 97
练习题 97
第4章 词法分析和语法分析 101
4.1 介绍 102
4.2 词法分析 102
4.3 语法分析问题 105
4.3.1 语法分析介绍 105
4.3.2 自顶向下语法分析器 106
4.3.3 自底向上语法分析器 106
4.3.4 语法分析的复杂性 106
4.4 递归下降语法分析 107
4.4.1 递归下降语法分析过程 107
4.4.2 LL 文法类 109
4.5 自底向上语法分析 110
4.5.1 自底向上语法分析器的语法分析问题 110
4.5.2 移进-归约算法 112
4.5.3 LR语法分析器 112
本章小结 115
复习题 116
练习题 117
第5章 名字、绑定、类型检测和作用域 119
5.1 介绍 120
5.2 名字 120
5.2.1 设计问题 120
5.2.2 名字形式 120
5.2.3 特殊字 121
5.3 变量 122
5.3.1 名字 122
5.3.2 地址 122
5.3.3 类型 123
5.3.4 值 123
5.4 绑定概念 123
5.4.1 属性-变量绑定 124
5.4.2 类型绑定 124
5.4.3 存储绑定与生存期 126
5.5 类型检测 128
5.6 强类型化 129
5.7 类型兼容性 130
5.8 作用域 132
5.8.1 静态作用域 132
5.8.2 块 134
5.8.3 静态作用域的评估 134
5.8.4 动态作用域 136
5.8.5 动态作用域的评估 137
5.9 作用域与生存期 137
5.10 引用环境 138
5.11 命名常量 139
5.12 变量初始化 141
本章小结 141
复习题 142
练习题 142
第6章 数据类型 147
6.1 介绍 148
6.2 基本数据类型 149
6.2.1 数值类型 149
6.2.2 布尔类型 150
6.2.3 字符类型 150
6.3 字符串类型 151
6.3.1 设计问题 151
6.3.2 字符串及操作 151
6.3.3 串长度的选择 152
6.3.4 评估 153
6.3.5 字符串类型的实现 153
6.4 用户定义的序数类型 154
6.4.1 枚举类型 154
6.4.2 子范围类型 155
6.4.3 实现用户定义的序数类型 156
6.5 数组类型 156
6.5.1 设计问题 157
6.5.2 数组和下标 157
6.5.3 下标绑定和数组类别 158
6.5.4 数组中的下标数目 159
6.5.5 数组初始化 160
6.5.6 数组操作 160
6.5.7 片 161
6.5.8 评估 162
6.5.9 数组类型的实现 162
6.6 相关数组 165
6.6.1 结构和操作 165
6.6.2 实现相关数组 166
6.7 记录类型 166
6.7.1 记录的定义 166
6.7.2 对记录域的引用 167
6.7.3 记录操作 168
6.7.4 评估 168
6.7.5 记录类型的实现 169
6.8 联合类型 169
6.8.1 设计问题 169
6.8.2 自由联合 169
6.8.3 Pascal 联合类型 169
6.8.4 Ada 联合类型 171
6.8.5 评估 172
6.8.6 联合类型的实现 172
6.9 集合类型 173
6.9.1 Pascal 中的集合 173
6.9.2 评估 173
6.9.3 集合类型的实现 174
6.10 指针类型 174
6.10.1 设计问题 175
6.10.2 指针操作 175
6.10.3 指针的一些问题 176
6.10.4 Pascal 语言中的指针 176
6.10.5 Ada 中的指针 177
6.10.6 C 和 C++ 中的指针 177
6.10.7 FORTRAN 90 中的指针 178
6.10.8 引用类型 179
6.10.9 评估 179
6.10.10 指针类型和引用类型的实现 180
本章小结 183
文献注释 184
复习题 184
练习题 185
第7章 表达式与赋值语句 187
7.1 介绍 188
7.2 算术表达式 188
7.2.1 操作符求值顺序 188
7.2.2 操作数求值顺序 192
7.3 重载操作符 193
7.4 类型转换 195
7.4.1 表达式中的强制转换 195
7.4.2 显式类型转换 196
7.4.3 表达式中的错误 196
7.5 关系表达式和布尔表达式 197
7.5.1 关系表达式 197
7.5.2 布尔表达式 197
7.6 短路求值 198
7.7 赋值语句 199
7.7.1 简单赋值 200
7.7.2 多目标 200
7.7.3 条件目标 200
7.7.4 复合赋值操作符 200
7.7.5 一元赋值操作符 201
7.7.6 赋值作为表达式 201
7.8 混合模式赋值 202
本章小结 203
复习题 203
练习题 203
第8章 语句层次的控制结构 207
8.1 介绍 208
8.2 复合语句 208
8.3 选择语句 209
8.3.1 双向选择语句 209
8.3.2 多向选择结构 212
8.4 循环语句 217
8.4.1 计数器控制的循环 217
8.4.2 逻辑控制的循环 223
8.4.3 用户定位的循环控制机制 224
8.4.4 基于数据结构的重复 226
8.5 无条件转移 227
8.5.1 无条件转移中的问题 227
8.5.2 标号形式 228
8.6 受保护命令 228
8.7 结论 230
本章小结 231
复习题 231
练习题 232
第9章 子程序 235
9.1 介绍 236
9.2 子程序的基本原理 236
9.2.1 子程序的共同特征 236
9.2.2 基本定义 236
9.2.3 参数 237
9.2.4 过程与函数 238
9.3 子程序的设计问题 239
9.4 局部引用环境 240
9.5 参数传递方法 241
9.5.1 参数传递的语义模型 241
9.5.2 参数传递的实现模型 242
9.5.3 主要语言中的参数传递 245
9.5.4 参数类型检测 246
9.5.5 实现参数传递方法 247
9.5.6 多维数组作为参数 248
9.5.7 设计考虑 251
9.5.8 参数传递的例子 251
9.6 子程序名作为参数传递 254
9.7 重载子程序 256
9.8 通用子程序 257
9.8.1 Ada 中的通用子程序 257
9.8.2 C++ 中的通用函数 258
9.9 分别编译与独立编译 260
9.10 函数的设计问题 261
9.10.1 函数的副作用 261
9.10.2 返回值的类型 261
9.11 访问非局部环境 261
9.11.1 FORTRAN COMMON 块 261
9.11.2 外部声明和模块 262
9.12 用户定义的重载操作符 263
9.13 协同程序 263
本章小结 265
复习题 265
练习题 266
第10章 实现子程序 269
10.1 调用与返回的一般语义 270
10.2 实现 FORTRAN 77 子程序 270
10.3 在类 ALGOL语言中实现子程序 272
10.3.1 更复杂的活动记录 272
10.3.2 一个没有递归及非局部引用的例子 273
10.3.3 递归 275
10.3.4 实现非局部引用的机制 275
10.4 块 285
10.5 实现动态作用域 286
10.5.1 深访问 286
10.5.2 浅访问 287
10.6 子程序名参数的实现 288
10.6.1 静态链方法 288
10.6.2 显示 288
10.6.3 再次讨论引用环境的混乱 288
本章小结 290
文献注释 290
复习题 290
练习题 291
第11章 抽象数据类型 293
11.1 抽象的概念 294
11.2 封装 294
11.3 数据抽象的介绍 295
11.3.1 浮点数作为抽象数据类型 295
11.3.2 用户定义的抽象数据类型 296
11.3.3 一个例子 296
11.4 设计问题 297
11.5 语言示例 297
11.5.1 SIMULA 67 中的类 297
11.5.2 Ada 中的抽象数据类型 298
11.5.3 C++ 中的抽象数据类型 301
11.6 有参数的抽象数据类型 305
11.6.1 Ada 305
11.6.2 C++ 305
本章小结 306
复习题 307
练习题 307
第12章 支持面向对象的程序设计 309
12.1 介绍 310
12.2 面向对象程序设计 310
12.2.1 介绍 310
12.2.2 继承 310
12.2.3 多态与动态绑定 312
12.2.4 面向对象语言的计算 312
12.3 面向对象语言的设计问题 313
12.3.1 纯对象模型 313
12.3.2 子类是子类型吗 313
12.3.3 实现继承与接口继承 313
12.3.4 类型检测与多态 314
12.3.5 单继承与多继承 314
12.3.6 对象的分配与解除分配 315
12.3.7 动态绑定与静态绑定 315
12.4 Smalltalk 概况 315
12.4.1 一般特征 316
12.4.2 Smalltalk 环境 316
12.5 Smalltalk 语言介绍 316
12.5.1 表达式 316
12.5.2 方法 318
12.5.3 赋值语句 319
12.5.4 块与控制结构 320
12.5.5 类 322
12.5.6 方法的更多方面 323
12.6 Smalltalk 程序示例 324
12.6.1 简单表格处理 324
12.6.2 LOGO 风格的图形 325
12.7 Smalltalk 的轮廓特性 329
12.7.1 类型检测与多态 329
12.7.2 继承 329
12.8 Smalltalk 的评估 329
12.9 C++ 对面向对象程序设计的支持 330
12.9.1 一般特征 330
12.9.2 继承 330
12.9.3 动态绑定 333
12.9.4 评估 334
12.10 Java 对面向对象程序设计的支持 335
12.10.1 一般特征 335
12.10.2 继承 336
12.10.3 动态绑定 336
12.10.4 封装 336
12.10.5 评估 337
12.11 Ada 95 对面向对象程序设计的支持 337
12.11.1 一般特征 337
12.11.2 继承 338
12.11.3 动态绑定 338
12.11.4 评估 339
12.12 Eiffel 对面向对象程序设计的支持 339
12.12.1 一般特征 340
12.12.2 继承 340
12.12.3 动态绑定 341
12.12.4 评估 341
12.13 JavaScript 的对象模型 341
12.13.1 一般特征 341
12.13.2 JavaScript 对象 342
12.13.3 对象的创建与修改 342
12.13.4 评估 343
12.14 面向对象结构的实现 343
12.14.1 存储实例数据 343
12.14.2 消息对方法的动态绑定 344
本章小结 345
复习题 345
练习题 346
第13章 并发 349
13.1 介绍 350
13.1.1 多处理器体系结构 350
13.1.2 并发的种类 351
13.1.3 学习并发的动机 351
13.2 子程序层次并发的介绍 351
13.2.1 基本概念 351
13.2.2 为并发而设计的语言 353
13.2.3 设计问题 354
13.3 信号量 354
13.3.1 介绍 354
13.3.2 合作同步 354
13.3.3 竞争同步 356
13.3.4 评估 357
13.4 管程 357
13.4.1 介绍 357
13.4.2 竞争同步 358
13.4.3 合作同步 358
13.4.4 评估 361
13.5 消息传递 361
13.5.1 介绍 361
13.5.2 同步消息传递的概念 361
13.5.3 Ada 83 的消息传递模型 361
13.5.4 合作同步 365
13.5.5 竞争同步 365
13.5.6 任务的终止 367
13.5.7 优先级 367
13.5.8 二元信号量 367
13.5.9 评估 368
13.6 Ada 95中的并发 368
13.6.1 保护的对象 368
13.6.2 异步消息 369
13.7 Java线程 370
13.7.1 Thread类 370
13.7.2 优先级 370
13.7.3 竞争同步 371
13.7.4 合作同步 371
13.7.5 评估 373
13.8 语句层次的并发 373
本章小结 375
文献注释 376
复习题 376
练习题 376
第14章 异常处理 379
14.1 异常处理介绍 380
14.1.1 基本概念 380
14.1.2 设计问题 381
14.1.3 历史 383
14.2 PL/I 中的异常处理 384
14.2.1 异常处理程序 384
14.2.2 异常与异常处理程序的绑定 384
14.2.3 继续 384
14.2.4 其他设计选择 384
14.2.5 示例 385
14.2.6 评估 386
14.3 Ada 中的异常处理 387
14.3.1 异常处理程序 387
14.3.2 异常与异常处理程序的绑定 387
14.3.3 继续 388
14.3.4 其他设计选择 389
14.3.5 示例 390
14.3.6 评估 391
14.4 C++ 中的异常处理 391
14.4.1 异常处理程序 391
14.4.2 异常与异常处理程序的绑定 391
14.4.3 继续 392
14.4.4 其他设计选择 392
14.4.5 示例 393
14.4.6 评估 393
14.5 Java 中的异常处理 394
14.5.1 异常类 394
14.5.2 异常处理程序 394
14.5.3 异常与异常处理程序的绑定 394
14.5.4 继续 395
14.5.5 其他设计选择 396
14.5.6 示例 396
14.5.7 finally子句 397
14.5.8 评估 398
本章小结 399
文献注释 399
复习题 399
练习题 400
第15章 函数式程序设计语言 403
15.1 介绍 404
15.2 数学函数 404
15.2.1 简单函数 404
15.2.2 函数形式 405
15.3 函数式程序设计语言的基础 406
15.4 第一种函数式程序设计语言: LISP 406
15.4.1 数据类型和结构 407
15.4.2 第一个LISP 解释器 407
15.5 Scheme 介绍 408
15.5.1 Scheme 的起源 409
15.5.2 原始函数 409
15.5.3 构造函数的函数 410
15.5.4 谓词函数 412
15.5.5 控制流程 414
15.5.6 Scheme 示例函数 415
15.5.7 函数形式 418
15.5.8 产生代码的函数 419
15.5.9 Scheme的命令式特性 419
15.6 COMMON LISP 420
15.7 ML 422
15.8 Haskell 423
15.9 函数式语言的应用 425
15.10 函数式语言和命令式语言的比较 426
本章小结 426
文献注释 427
复习题 427
练习题 427
第16章 逻辑程序设计语言 429
16.1 介绍 430
16.2 谓词演算的简短介绍 430
16.2.1 命题 430
16.2.2 子句形式 431
16.3 谓词演算与定理证明 432
16.4 逻辑程序设计概述 434
16.5 Prolog 的起源 435
16.6 Prolog 的基本元素 435
16.6.1 项 435
16.6.2 事实语句 435
16.6.3 规则语句 436
16.6.4 目标语句 437
16.6.5 Prolog 的推理过程 437
16.6.6 简单算术 439
16.6.7 链表结构 441
16.7 Prolog 的缺陷 444
16.7.1 归结次序控制 444
16.7.2 封闭世界假设 446
16.7.3 否定问题 446
16.7.4 内在的限制 448
16.8 逻辑程序设计的应用 448
16.8.1 关系数据库管理系统 448
16.8.2 专家系统 448
16.8.3 自然语言处理 449
16.8.4 教育 449
16.9 结论 449
本章小结 450
文献注释 450
复习题 450
练习题 451
参考文献 453
索引 465
