程序设计语言概念 第9版PDF电子书下载

第1章 预备知识 1

1.1 学习程序设计语言原理的原因 1

1.2 程序设计领域 3

1.2.1 科学应用 3

1.2.2 商务应用 3

1.2.3 人工智能 4

1.2.4 系统程序设计 4

1.2.5 网络软件 4

1.3 语言评价标准 5

1.3.1 可读性 5

1.3.2 可写性 9

1.3.3 可靠性 10

1.3.4 代价 11

1.4 影响语言设计的因素 13

1.4.1 计算机体系结构 13

1.4.2 程序设计方法学 14

1.5 程序设计语言的分类 15

1.6 语言设计中的权衡 16

1.7 实现方法 17

1.7.1 编译 18

1.7.2 完全解释 19

1.7.3 混合实现系统 20

1.7.4 预处理器 20

1.8 编程环境 21

小结 22

复习题 22

习题 23

第2章 主要程序设计语言的发展 24

2.1 Zuse的Plankalkul语言 25

2.1.1 历史背景 25

2.1.2 语言概述 26

2.2 最少硬件的程序设计：伪代码 27

2.2.1 Short Code语言 27

2.2.2 Speedcoding系统 28

2.2.3 UNIVAC“编译”系统 28

2.2.4 相关工作 28

2.3 IBM 704计算机与Fortran语言 29

2.3.1 历史背景 29

2.3.2 设计过程 29

2.3.3 Fortran Ⅰ概述 30

2.3.4 Fortran Ⅱ 30

2.3.5 Fortran Ⅳ、77、90、95和2003 31

2.3.6 评价 31

2.4 函数式程序设计：LISP语言 33

2.4.1 人工智能的起源和表处理 33

2.4.2 LISP语言的设计过程 33

2.4.3 语言概述 34

2.4.4 评价 35

2.4.5 LISP的两种后代语言 36

2.4.6 相关语言 36

2.5 迈向成熟的第一步：ALGOL 60 37

2.5.1 历史背景 37

2.5.2 早期设计过程 37

2.5.3 ALGOL 58概述 38

2.5.4 对ALGOL58报告的响应 38

2.5.5 ALGOL 60的设计过程 39

2.5.6 ALGOL 60概述 39

2.5.7 评价 40

2.6 商务记录计算机化：COBOL语言 41

2.6.1 历史背景 42

2.6.2 FLOW-MATIC语言 42

2.6.3 COBOL语言的设计过程 42

2.6.4 评价 43

2.7 分时处理的开始：BASIC语言 45

2.7.1 设计过程 46

2.7.2 语言概述 46

2.7.3 评价 46

2.8 满足所有人的需要：PL/I 48

2.8.1 历史背景 48

2.8.2 设计过程 48

2.8.3 语言概述 49

2.8.4 评价 49

2.9 两种早期的动态语言：APL和SNOBOL 50

2.9.1 APL语言的起源与特点 51

2.9.2 SNOBOL语言的起源与特点 51

2.10 数据抽象的开始：AIMULA 67 51

2.10.1 设计过程 51

2.10.2 语言概述 52

2.11 正交设计：ALGOL 68 52

2.11.1 设计过程 52

2.11.2 语言概述 52

2.11.3 评价 53

2.12 ALGOL系列语言的早期后代语言 53

2.12.1 为简单性而设计：Pascal语言 53

2.12.2 可移植的系统语言：C语言 55

2.13 基于逻辑的程序设计：Prolog语言 57

2.13.1 设计过程 57

2.13.2 语言概述 57

2.13.3 评价 58

2.14 历史上规模最大的设计工作：Ada语言 58

2.14.1 历史背景 58

2.14.2 设计过程 59

2.14.3 语言概述 60

2.14.4 评价 60

2.14.5 Ada 95 61

2.15 面向对象的程序设计：Smalltalk 62

2.15.1 设计过程 62

2.15.2 语言概述 62

2.15.3 评价 63

2.16 结合命令式和面向对象的特性：C++ 64

2.16.1 设计过程 64

2.16.2 语言概述 65

2.16.3 评价 65

2.16.4 一种相关语言：Eiffcl 65

2.16.5 另一种相关语言：Delphi 66

2.17 基于命令式的面向对象语言：Java 66

2.17.1 设计过程 66

2.17.2 语言概述 67

2.17.3 评价 68

2.18 脚本语言 69

2.18.1 Perl的起源与特点 69

2.18.2 JavaScript的起源与特点 71

2.18.3 PHP的起源与特点 72

2.18.4 Python的起源与特点 73

2.18.5 Ruby的起源与特点 73

2.18.6 Lua的起源与特点 74

2.19 一种新千年的基于C的语言：C 74

2.19.1 设计过程 74

2.19.2 语言概述 75

2.19.3 评价 76

2.20 标记与程序设计混合的语言 77

2.20.1 XSLT 77

2.20.2 JSP 77

小结 78

文献注释 78

复习题 79

习题 80

程序设计练习 81

访谈：用户设计与语言设计 82

第3章 描述语法和语义 85

3.1 概述 85

3.2 描述语法的普遍问题 86

3.2.1 语言识别器 86

3.2.2 语言生成器 87

3.3 描述语法的形式化方法 87

3.3.1 巴科斯-诺尔范式和上下文无关文法 87

3.3.2 扩展的BNF 96

3.3.3 文法与识别器 97

3.4 属性文法 98

3.4.1 静态语义 98

3.4.2 基本概念 98

3.4.3 属性文法定义 99

3.4.4 本质属性 99

3.4.5 属性文法的例子 99

3.4.6 计算属性值 101

3.4.7 评价 102

3.5 描述程序的意义：动态语义 102

3.5.1 操作语义 103

3.5.2 指称语义 104

3.5.3 公理语义 108

小结 118

文献注释 119

复习题 119

习题 120

第4章 词法分析和语法分析 124

4.1 概述 124

4.2 词法分析 125

4.3 语法分析问题 132

4.3.1 语法分析概述 132

4.3.2 自顶向下的语法分析器 133

4.3.3 自底向上的语法分析器 133

4.3.4 语法分析的复杂度 134

4.4 递归下降的语法分析 134

4.4.1 递归下降的语法分析过程 134

4.4.2 LL文法类 139

4.5 自底向上的语法分析 142

4.5.1 自底向上语法分析器的分析问题 142

4.5.2 移进-归约算法 143

4.5.3 LR语法分析器 144

小结 147

复习题 148

习题 149

程序设计练习 150

第5章 名字、绑定和作用域 151

5.1 引言 151

5.2 名字 151

5.2.1 设计问题 151

5.2.2 名字形式 152

5.2.3 特殊字 153

5.3 变量 154

5.3.1 名字 154

5.3.2 地址 154

5.3.3 类型 155

5.3.4 数值 155

5.4 绑定的概念 156

5.4.1 属性与变量绑定 156

5.4.2 绑定类型 156

5.4.3 存储绑定和生存期 160

5.5 作用域 162

5.5.1 静态作用域 163

5.5.2 块 164

5.5.3 声明的次序 165

5.5.4 全局作用域 166

5.5.5 静态作用域评估 168

5.5.6 动态作用域 168

5.5.7 动态作用域评估 169

5.6 作用域和生存期 170

5.7 引用环境 171

5.8 命名常量 172

小结 174

复习题 175

问题集 175

编程题 180

访谈：脚本语言以及其他灵活解决方案的例子 180

第6章 数据类型 183

6.1 引言 183

6.2 基本数据类型 184

6.2.1 数值类型 184

6.2.2 布尔类型 186

6.2.3 字符类型 187

6.3 字符串类型 187

6.3.1 设计问题 187

6.3.2 字符串及其操作 187

6.3.3 字符串长度的设计选项 189

6.3.4 评估 190

6.3.5 字符串类型的实现 190

6.4 用户定义的序数类型 191

6.4.1 枚举类型 191

6.4.2 子界类型 193

6.4.3 用户定义的有序类型的实现 194

6.5 数组类型 194

6.5.1 设计问题 195

6.5.2 数组和索引 195

6.5.3 下标的绑定和数组的种类 196

6.5.4 数组初始化 198

6.5.5 数组操作 200

6.5.6 矩形数组和不规则数组 201

6.5.7 切片 201

6.5.8 评估 202

6.5.9 数组类型的实现 202

6.6 关联数组 204

6.6.1 结构和操作 205

6.6.2 关联数组的实现 206

6.7 记录类型 206

6.7.1 记录的定义 207

6.7.2 记录域引用 208

6.7.3 记录操作 208

6.7.4 评估 209

6.7.5 记录类型的实现 209

6.8 联合类型 210

6.8.1 设计问题 210

6.8.2 判别式联合与自由联合 210

6.8.3 Ada的联合类型 211

6.8.4 评估 212

6.8.5 联合类型的实现 212

6.9 指针和引用类型 213

6.9.1 设计问题 214

6.9.2 指针操作 214

6.9.3 指针的相关问题 215

6.9.4 Ada语言中的指针 216

6.9.5 C和C++中的指针 216

6.9.6 引用类型 218

6.9.7 评估 219

6.9.8 指针和引用类型的实现 219

6.10 类型检查 223

6.11 强类型化 223

6.12 类型等价 224

6.13 理论和数据类型 227

小结 229

参考文献注释 230

复习题 230

问题集 231

编程题 232

访谈：Lua 233

第7章 表达式与赋值语句 237

7.1 引言 237

7.2 算术表达式 237

7.2.1 运算符运算顺序 238

7.2.2 操作对象运算顺序 242

7.3 运算符重载 244

7.4 类型转换 245

7.4.1 表达式中的强制类型转换 246

7.4.2 显式类型转换 247

7.4.3 表达式中的错误 248

7.5 关系表达式和逻辑表达式 248

7.5.1 关系表达式 248

7.5.2 逻辑表达式 249

7.6 短路求值 250

7.7 赋值语句 251

7.7.1 简单赋值 252

7.7.2 条件赋值 252

7.7.3 混合赋值运算符 252

7.7.4 一元赋值运算符 253

7.7.5 赋值作为表达式 253

7.7.6 列表赋值 254

7.8 混合模式赋值 255

小结 255

复习题 256

问题集 257

编程题 259

第8章 语句级控制结构 260

8.1 引言 260

8.2 选择语句 261

8.2.1 双路选择语句 261

8.2.2 多重选择结构 265

8.3 迭代语句 272

8.3.1 计数控制循环 273

8.3.2 逻辑控制循环 277

8.3.3 用户自定义的循环控制机制 279

8.3.4 基于数据结构的迭代 280

8.4 无条件分支 283

8.5 防护命令（Guarded Commands） 283

8.6 结论 285

小结 286

复习题 287

问题集 288

编程题 288

访谈：第一部分：语言学的研究和脚本语言Perl的诞生 290

第9章 子程序 293

9.1 引言 293

9.2 子程序基本原理 293

9.2.1 子程序的一般性质 293

9.2.2 子程序的基本定义 294

9.2.3 参数 295

9.2.4 Ruby语言的块 299

9.2.5 过程与函数 300

9.3 子程序的设计问题 301

9.4 局部引用环境 302

9.4.1 局部变量 302

9.4.2 嵌套子程序 303

9.5 参数传递方式 304

9.5.1 参数传递的语义模型 304

9.5.2 参数传递的实现模式 304

9.5.3 参数传递方法的实现 308

9.5.4 常见语言的参数传递方法 309

9.5.5 参数类型检查 311

9.5.6 多维数组作参数 313

9.5.7 设计考虑 316

9.5.8 参数传递的例子 316

9.6 子程序作为参数 319

9.7 重载子程序 320

9.8 泛型子程序 321

9.8.1 Ada中的泛型子程序 322

9.8.2 C++中的泛型函数 323

9.8.3 Java 5.0中的泛型方法 325

9.8.4 C#2005中的泛型方法 326

9.9 函数的设计问题 327

9.91 函数副作用 327

9.9.2 返回值类型 327

9.9.3 返回值的个数 327

9.10 用户定义重载运算符 328

9.11 协同程序 328

小结 330

复习题 331

问题集 332

编程题 334

访谈：第二部分：一般的脚本语言和特殊的Perl语言 335

第10章 实现子程序 337

10.1 调用和返回的一般语义 337

10.2 实现“简单”的子程序 337

10.3 通过栈动态局部变量实现子程序 339

10.3.1 更复杂的活动记录 339

10.3.2 一个不含递归调用的例子 341

10.3.3 递归调用 343

10.4 嵌套子程序 345

10.4.1 基础 345

10.4.2 静态链 346

10.5 块 350

10.6 动态作用域的实现 351

10.6.1 深访问 351

10.6.2 浅访问 353

小结 354

复习题 355

问题集 355

编程题 358

访谈：保持尽量简单 359

第11章 抽象数据类型与封装结构 361

11.1 抽象的概念 361

11.2 数据抽象的介绍 362

11.2.1 抽象数据类型之浮点型 362

11.2.2 抽象数据类型之用户定义类型 362

11.2.3 示例 363

11.3 抽象数据类型的设计要点 364

11.4 语言示例 364

11.4.1 Ada中的抽象数据类型 365

11.4.2 C++中的抽象数据类型 369

11.4.3 Java中的抽象数据类型 372

11.4.4 C#中的抽象数据类型 374

11.4.5 Ruby中的抽象数据类型 375

11.5 参数化的抽象数据类型 377

11.5.1 Ada 378

11.5.2 C++ 378

11.5.3 Java 5.0 380

11.5.4 C#2005 381

11.6 封装结构 381

11.6.1 引言 381

11.6.2 嵌套子程序 381

11.6.3 C中的封装 382

11.6.4 C++中的封装 382

11.6.5 Ada包 383

11.6.6 C#程序集 383

11.7 命名封装 384

11.7.1 C++命名空间 384

11.7.2 Java包 385

11.7.3 Ada包 386

11.7.4 Ruby模块 387

小结 387

复习题 388

问题集 389

编程题 390

附录1 391

访谈：C++：它的诞生，它的无处不在和它受到的常见质疑 391

第12章 面向对象程序设计的支持 394

12.1 概述 394

12.2 面向对象程序设计 394

12.2.1 引言 394

12.2.2 继承 395

12.2.3 动态绑定 396

12.3 面向对象语言的设计问题 397

12.3.1 对象的排他性 397

12.3.2 子类是子类型吗 397

12.3.3 类型检查和多态 398

12.3.4 单继承与多继承 399

12.3.5 对象的分配和释放 399

12.3.6 动态绑定与静态绑定 400

12.3.7 嵌套类 400

12.3.8 对象的初始化 400

12.4 Smalltalk对面向对象程序设计支持 400

12.4.1 一般特征 401

12.4.2 类型检查和多态 401

12.4.3 继承 401

12.4.4 Smalltalk的评估 402

12.5 C++对面向对象程序设计的支持 402

12.5.1 一般特征 403

12.5.2 继承 403

12.5.3 动态绑定 407

12.5.4 评估 409

12.6 Java中对面向对象程序设计的支持 410

12.6.1 一般特征 410

12.6.2 继承 411

12.6.3 动态绑定 412

12.6.4 被嵌套的类 412

12.6.5 评估 413

12.7 C#中对面向对象程序设计的支持 413

12.7.1 一般特征 413

12.7.2 继承 413

12.7.3 动态绑定 413

12.7.4 被嵌套的类 414

12.7.5 评估 414

12.8 Ada 95对面向对象程序设计的支持 414

12.8.1 一般特征 414

12.8.2 继承 415

12.8.3 动态绑定 416

12.8.4 子程序包 417

12.8.5 评估 418

12.9 Ruby对面向对象程序设计的支持 418

12.9.1 一般特征 418

12.9.2 继承 420

12.9.3 动态绑定 421

12.9.4 评估 421

12.10 面向对象构造的实现 421

12.10.1 存储实例数据 421

12.10.2 方法调用到方法的动态绑定 422

小结 424

复习题 425

问题集 426

编程题 427

访谈：关于程序设计范型和更好的程序设计 427

第13章 描述语法和语义 430

13.1 概述 430

13.1.1 多处理器体系结构 431

13.1.2 并发的种类 432

13.1.3 使用并发的目的 432

13.2 子程序级并发的介绍 433

13.2.1 基本概念 433

13.2.2 为并发而设计的语言 435

13.2.3 设计问题 436

13.3 信号量 436

13.3.1 概述 436

13.3.2 合作同步 436

13.3.3 竞争同步 438

13.3.4 评价 439

13.4 管程 440

13.4.1 概述 440

13.4.2 竞争同步 440

13.4.3 合作同步 440

13.4.4 评价 440

13.5 消息传递 441

13.5.1 概述 441

13.5.2 同步消息传递的原理 442

13.6 Ada对并发的支持 442

13.6.1 基本原理 442

13.6.2 合作同步 445

13.6.3 竞争同步 446

13.6.4 任务终止 448

13.6.5 优先级 448

13.6.6 二元信号量 448

13.6.7 受保护对象 449

13.6.8 异步消息传递 450

13.6.9 评价 451

13.7 Java线程 451

13.7.1 Thread类 451

13.7.2 优先级 453

13.7.3 竞争同步 453

13.7.4 合作同步 454

13.7.5 评价 457

13.8 C#线程 457

13.8.1 基本线程操作 457

13.8.2 同步线程 458

13.8.3 评价 458

13.9 语句级并发 458

13.9.1 高性能Fortran 459

小结 460

文献注释 461

复习题 461

习题 463

程序设计练习 463

第14章 异常处理和事件处理 464

14.1 异常处理概述 464

14.1.1 基本概念 465

14.1.2 设计问题 466

14.2 Ada中的异常处理 469

14.2.1 异常处理程序 469

14.2.2 将异常绑定到处理程序 470

14.2.3 继续 470

14.2.4 其他设计选择 471

14.2.5 例子 472

14.2.6 评价 474

14.3 C++中的异常处理 474

14.3.1 异常处理程序 474

14.3.2 异常与处理程序的绑定 475

14.3.3 继续 476

14.3.4 其他设计选择 476

14.3.5 例子 476

14.3.6 评价 478

14.4 Java中的异常处理 478

14.4.1 异常类 478

14.4.2 异常处理程序 479

14.4.3 异常与处理程序的绑定 479

14.4.4 其他设计选择 480

14.4.5 例子 481

14.4.6 finally子句 482

14.4.7 断言 483

14.4.8 评价 484

14.5 事件处理概述 484

14.6 Java的事件处理 485

14.6.1 Java Swing的GUI组件 485

14.6.2 Java事件模型 486

小结 489

文献注释 490

复习题 490

习题 491

程序设计练习 492

访谈：Java的诞生 493

第15章 函数式程序设计语言 495

15.1 概述 495

15.2 数学函数 496

15.2.1 简单函数 496

15.2.2 函数形式 497

15.3 函数式程序设计语言基础 497

15.4 第一种函数式程序设计语言：LISP 498

15.4.1 数据类型和结构 499

15.4.2 第一个LISP解释器 499

15.5 Scheme概述 501

15.5.1 Scheme的起源 501

15.5.2 Scheme解释器 501

15.5.3 基本数值函数 501

15.5.4 定义函数 502

15.5.5 输出函数 503

15.5.6 数值谓词函数 503

15.5.7 控制流 504

15.5.8 表函数 505

15.5.9 用于符号原子和表的谓词函数 507

15.5.10 Scheme函数示例 508

15.5.11 Scheme中的尾递归 512

15.5.12 函数形式 512

15.5.13 构建代码的函数 514

15.6 COMMON LISP 515

15.7 ML 515

15.8 Haskell 518

15.9 函数式语言的应用 522

15.10 函数式语言和命令式语言的比较 522

小结 524

文献注释 525

复习题 525

习题 526

程序设计练习 527

第16章 逻辑程序设计语言 528

16.1 概述 528

16.2 谓词演算简介 528

16.2.1 命题 529

16.2.2 子句形式 530

16.3 谓词演算与定理证明 531

16.4 逻辑程序设计概述 533

16.5 Prolog的起源 534

16.6 Prolog的基本元素 534

16.6.1 项 534

16.6.2 事实语句 535

16.6.3 规则语句 536

16.6.4 目标语句 536

16.6.5 Prolog的推理过程 537

16.6.6 简单算术 539

16.6.7 表结构 541

16.7 Prolog的缺陷 545

16.7.1 归结顺序的控制 545

16.7.2 封闭世界假设 547

16.7.3 否定问题 548

16.7.4 固有的限制 549

16.8 逻辑程序设计的应用 550

16.8.1 关系数据库管理系统 550

16.8.2 专家系统 550

16.8.3 自然语言处理 551

小结 551

文献注释 551

复习题 552

习题 552

程序设计练习 553

参考文献 554