编程语言原理 第10版PDF电子书下载

第1章 预备知识 1

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

1.2程序设计领域 4

1.2.1科学应用 4

1.2.2商务应用 4

1.2.3人工智能 5

1.2.4系统程序设计 5

1.2.5网络软件 5

1.3语言评价标准 6

1.3.1可读性 6

1.3.2可写性 10

1.3.3可靠性 11

1.3.4成本 13

1.4影响语言设计的因素 14

1.4.1计算机体系结构 14

1.4.2程序设计方法学 15

1.5程序设计语言的分类 16

1.6语言设计中的权衡 17

1.7实现方法 18

1.7.1编译 19

1.7.2完全解释 21

1.7.3混合实现系统 22

1.7.4预处理器 23

1.8编程环境 23

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

2.1 Zuse的Plankalkul语言 29

2.1.1历史背景 29

2.1.2语言概述 29

2.2伪代码 30

2.2.1 Short Code语言 31

2.2.2 Speedcoding系统 31

2.2.3 UNIVAC“编译”系统 32

2.2.4相关工作 32

2.3 IBM 704计算机与Fortran语言 32

2.3.1历史背景 32

2.3.2设计过程 33

2.3.3 Fortran Ⅰ概述 33

2.3.4 Fortran Ⅱ 34

2.3.5 Fortran Ⅳ、77、90、95、2003和2008 34

2.3.6评价 35

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

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

2.4.2 LISP语言的设计过程 37

2.4.3语言概述 37

2.4.4评价 39

2.4.5 LISP的两种后代语言 39

2.4.6相关语言 40

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

2.5.1历史背景 41

2.5.2早期设计过程 41

2.5.3 ALGOL 58概述 42

2.5.4对ALGOL 58报告的响应 42

2.5.5 ALGOL 60的设计过程 43

2.5.6 ALGOL 60概述 43

2.5.7评价 44

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

2.6.1历史背景 46

2.6.2 FLOW-MATIC语言 46

2.6.3 COBOL语言的设计过程 46

2.6.4评价 47

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

2.7.1设计过程 49

2.7.2语言概述 50

2.7.3评价 50

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

2.8.1历史背景 51

2.8.2设计过程 52

2.8.3语言概述 53

2.8.4评价 53

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

2.9.1 APL语言的起源与特点 54

2.9.2 SNOBOL语言的起源与特点 55

2.10数据抽象的开始：SIMULA 67 55

2.10.1设计过程 55

2.10.2语言概述 55

2.11正交设计：ALGOL 68 56

2.11.1设计过程 56

2.11.2语言概述 56

2.11.3评价 56

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

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

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

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

2.13.1设计过程 61

2.13.2语言概述 61

2.13.3评价 61

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

2.14.1历史背景 62

2.14.2设计过程 62

2.14.3语言概述 63

2.14.4评价 64

2.14.5 Ada 95和Ada 2005 65

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

2.15.1设计过程 65

2.15.2语言概述 66

2.15.3评价 67

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

2.16.1设计过程 68

2.16.2语言概述 68

2.16.3评价 69

2.16.4一种相关语言：Objective-C 69

2.16.5另一种相关语言：Delphi 69

2.16.6一种关系不大的语言：Go 70

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

2.17.1设计过程 70

2.17.2语言概述 71

2.17.3评价 72

2.18脚本语言 73

2.18.1 Perl的起源与特点 73

2.18.2 JavaScript的起源与特点 75

2.18.3 PHP的起源与特点 76

2.18.4 Python的起源与特点 77

2.18.5 Ruby的起源与特点 77

2.18.6 Lua的起源与特点 78

2.19一流的.NET语言：C 79

2.19.1设计过程 79

2.19.2语言概述 79

2.19.3评价 80

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

2.20.1 XSLT 81

2.20.2 JSP 82

第3章 描述语法和语义 89

3.1概述 90

3.2描述语法的普遍问题 91

3.2.1语言识别器 91

3.2.2语言生成器 92

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

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

3.3.2扩展的BNF 102

3.3.3文法与识别器 104

3.4属性文法 104

3.4.1静态语义 105

3.4.2基本概念 105

3.4.3属性文法定义 105

3.4.4本质属性 106

3.4.5属性文法的例子 106

3.4.6计算属性值 108

3.4.7评价 109

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

3.5.1操作语义 110

3.5.2指称语义 112

3.5.3公理语义 116

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

4.1概述 134

4.2词法分析 135

4.3语法分析问题 142

4.3.1语法分析概述 142

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

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

4.3.4语法分析的复杂度 144

4.4递归下降的语法分析 144

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

4.4.2 LL文法类 149

4.5自下而上的语法分析 152

4.5.1自下而上的语法分析器的分析问题 152

4.5.2移进-归约算法 154

4.5.3 LR语法分析器 155

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

5.1概述 164

5.2名字 164

5.2.1设计问题 165

5.2.2名字形式 165

5.2.3特殊字 166

5.3变量 166

5.3.1名字 167

5.3.2地址 167

5.3.3类型 168

5.3.4数值 168

5.4绑定的概念 168

5.4.1属性与变量绑定 169

5.4.2绑定类型 169

5.4.3存储绑定和生存期 172

5.5作用域 175

5.5.1静态作用域 175

5.5.2块 177

5.5.3声明的次序 179

5.5.4全局作用域 180

5.5.5静态作用域的评价 182

5.5.6动态作用域 183

5.5.7动态作用域的评价 183

5.6作用域和生存期 184

5.7引用环境 185

5.8命名常量 186

第6章 数据类型 195

6.1概述 196

6.2基本数据类型 197

6.2.1数值类型 197

6.2.2布尔类型 200

6.2.3字符类型 200

6.3字符串类型 200

6.3.1设计问题 201

6.3.2字符串及其操作 201

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

6.3.4评价 203

6.3.5字符串类型的实现 203

6.4用户定义的序数类型 204

6.4.1枚举类型 205

6.4.2子界类型 207

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

6.5数组类型 208

6.5.1设计问题 208

6.5.2数组和索引 209

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

6.5.4数组的初始化 212

6.5.5数组操作 213

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

6.5.7切片 215

6.5.8评价 216

6.5.9数组类型的实现 216

6.6关联数组 218

6.6.1结构和操作 219

6.6.2关联数组的实现 220

6.7记录类型 220

6.7.1记录的定义 221

6.7.2记录域的引用 222

6.7.3评价 222

6.7.4记录类型的实现 223

6.8元组类型 223

6.9列表类型 224

6.10联合类型 227

6.10.1设计问题 227

6.10.2判别式联合与自由联合 227

6.10.3 Ada的联合类型 228

6.10.4 F#的联合类型 229

6.10.5评价 230

6.10.6联合类型的实现 230

6.11指针和引用类型 231

6.11.1设计问题 232

6.11.2指针操作 232

6.11.3指针的相关问题 233

6.11.4 Ada中的指针 234

6.11.5 C和C++中的指针 235

6.11.6引用类型 236

6.11.7评价 237

6.11.8指针和引用类型的实现 237

6.12类型检查 242

6.13强类型化 242

6.14类型等价 243

6.15 理论和数据类型 246

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

7.1概述 258

7.2算术表达式 258

7.2.1运算符的运算顺序 259

7.2.2操作数的运算顺序 264

7.3运算符重载 266

7.4类型转换 267

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

7.4.2显式类型转换 269

7.4.3表达式中的错误 269

7.5关系表达式和布尔表达式 270

7.5.1关系表达式 270

7.5.2布尔表达式 270

7.6短路求值 271

7.7赋值语句 273

7.7.1简单赋值 273

7.7.2条件赋值 273

7.7.3混合赋值运算符 273

7.7.4一元赋值运算符 274

7.7.5赋值表达式 275

7.7.6多重赋值 276

7.7.7函数式编程语言中的赋值 276

7.8混合模式赋值 277

第8章 语句级控制结构 283

8.1概述 284

8.2选择语句 285

8.2.1双路选择语句 285

8.2.2多重选择结构 289

8.3迭代语句 295

8.3.1计数控制循环 296

8.3.2逻辑控制循环 300

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

8.3.4基于数据结构的迭代 303

8.4无条件分支 306

8.5防护命令 307

8.6结论 309

第9章 子程序 315

9.1概述 316

9.2子程序的基本原理 316

9.2.1子程序的一般性质 316

9.2.2子程序的基本定义 316

9.2.3参数 318

9.2.4过程与函数 321

9.3子程序的设计问题 322

9.4局部引用环境 323

9.4.1局部变量 323

9.4.2嵌套子程序 324

9.5参数传递方式 325

9.5.1参数传递的语义模型 325

9.5.2参数传递的实现模型 326

9.5.3参数传递方法的实现 329

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

9.5.5参数的类型检查 332

9.5.6多维数组作为参数 333

9.5.7设计考虑 336

9.5.8参数传递的例子 336

9.6子程序作为参数 339

9.7间接调用子程序 340

9.8重载子程序 342

9.9泛型子程序 343

9.9.1 C++中的泛型函数 343

9.9.2 Java 5.0中的泛型方法 345

9.9.3 C# 2005中的泛型方法 346

9.9.4 F#中的泛型函数 347

9.10函数的设计问题 348

9.10.1函数的副作用 348

9.10.2返回值的类型 348

9.10.3返回值的个数 348

9.11用户定义重载运算符 349

9.12闭包 349

9.13协同程序 351

第10章 实现子程序 359

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

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

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

10.3.1更复杂的活动记录 363

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

10.3.3递归调用 367

10.4嵌套子程序 368

10.4.1基础知识 368

10.4.2静态链 369

10.5块 373

10.6动态作用域的实现 375

10.6.1深层访问 375

10.6.2浅层访问 376

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

11.1抽象的概念 384

11.2数据抽象简介 385

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

11.2.2用户自定义的抽象数据类型 386

11.2.3示例 387

11.3抽象数据类型的设计问题 387

11.4语言示例 388

11.4.1 Ada中的抽象数据类型 388

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

11.4.3 Objective-C中的抽象数据类型 395

11.4.4 Java中的抽象数据类型 400

11.4.5 C#中的抽象数据类型 401

11.4.6 Ruby中的抽象数据类型 403

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

11.5.1 Ada 406

11.5.2 C++ 407

11.5.3 Java 5.0 409

11.5.4 C# 2005 411

11.6封装结构 411

11.6.1引言 411

11.6.2 C中的封装 412

11.6.3 C++中的封装 412

11.6.4 Ada包 413

11.6.5 C#程序集 413

11.7命名封装 414

11.7.1 C++命名空间 414

11.7.2 Java包 415

11.7.3 Ada包 416

11.7.4 Ruby模块 417

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

12.1概述 426

12.2面向对象编程 426

12.2.1引言 426

12.2.2继承 426

12.2.3动态绑定 428

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

12.3.1对象的排他性 430

12.3.2子类是子类型吗 430

12.3.3单继承与多继承 431

12.3.4对象的分配和释放 432

12.3.5动态绑定与静态绑定 433

12.3.6嵌套类 433

12.3.7对象的初始化 433

12.4 Smalltalk对面向对象编程的支持 434

12.4.1一般特征 434

12.4.2继承 434

12.4.3动态绑定 435

12.4.4 Smalltalk的评价 435

12.5 C++对面向对象编程的支持 436

12.5.1一般特征 436

12.5.2继承 436

12.5.3动态绑定 441

12.5.4评价 443

12.6 Objective-C对面向对象编程的支持 444

12.6.1一般特征 444

12.6.2继承 445

12.6.3动态绑定 446

12.6.4评价 447

12.7 Java对面向对象编程的支持 447

12.7.1一般特征 447

12.7.2继承 447

12.7.3动态绑定 449

12.7.4被嵌套的类 449

12.7.5评价 450

12.8 C#对面向对象编程的支持 450

12.8.1一般特征 450

12.8.2继承 450

12.8.3动态绑定 450

12.8.4被嵌套的类 451

12.8.5评价 451

12.9 Ada 95对面向对象编程的支持 452

12.9.1一般特征 452

12.9.2继承 452

12.9.3动态绑定 453

12.9.4子包 454

12.9.5评价 455

12.10 Ruby对面向对象编程的支持 455

12.10.1一般特征 455

12.10.2继承 457

12.10.3动态绑定 457

12.10.4评价 457

12.11面向对象构造的实现 457

12.11.1存储实例数据 457

12.11.2方法调用到方法的动态绑定 458

第13章 并发 467

13.1概述 468

13.1.1多处理器体系结构 469

13.1.2并发的种类 470

13.1.3使用并发的目的 471

13.2子程序级并发概述 471

13.2.1基本概念 471

13.2.2为并发而设计的语言 475

13.2.3设计问题 475

13.3信号量 475

13.3.1概述 475

13.3.2合作同步 476

13.3.3竞争同步 478

13.3.4评价 479

13.4管程 479

13.4.1概述 479

13.4.2竞争同步 480

13.4.3合作同步 480

13.4.4评价 480

13.5消息传递 481

13.5.1概述 481

13.5.2同步消息传递的原理 481

13.6 Ada对并发的支持 482

13.6.1基本原理 482

13.6.2合作同步 485

13.6.3竞争同步 486

13.6.4任务终止 487

13.6.5优先级 487

13.6.6受保护对象 488

13.6.7评价 489

13.7 Java线程 489

13.7.1 Thread类 490

13.7.2优先级 491

13.7.3信号量 492

13.7.4竞争同步 492

13.7.5合作同步 493

13.7.6非阻塞同步 496

13.7.7显式锁定 496

13.7.8评价 497

13.8 C#线程 497

13.8.1基本线程操作 497

13.8.2同步线程 500

13.8.3评价 500

13.9函数式语言中的并发 501

13.9.1 Multilisp 501

13.9.2并发ML 501

13.9.3 F 502

13.10语句级并发 503

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

14.1异常处理概述 512

14.1.1基本概念 513

14.1.2设计问题 514

14.2 Ada中的异常处理 517

14.2.1异常处理程序 517

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

14.2.3继续 518

14.2.4其他设计选择 519

14.2.5例子 520

14.2.6评价 522

14.3 C++中的异常处理 522

14.3.1异常处理程序 522

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

14.3.3继续 524

14.3.4其他设计选择 524

14.3.5例子 524

14.3.6评价 526

14.4 Java中的异常处理 526

14.4.1异常类 526

14.4.2异常处理程序 527

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

14.4.4其他设计选择 528

14.4.5例子 529

14.4.6 finally子句 530

14.4.7断言 531

14.4.8评价 531

14.5事件处理概述 532

14.6 Java的事件处理 533

14.6.1 Java Swing的GUI组件 533

14.6.2 Java事件模型 534

14.7 C#中的事件处理 537

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

15.1概述 546

15.2数学函数 547

15.2.1简单函数 547

15.2.2函数形式 548

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

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

15.4.1数据类型和结构 550

15.4.2第一个LISP解释器 551

15.5 Scheme概述 553

15.5.1 Scheme的起源 553

15.5.2 Scheme解释器 553

15.5.3基本数值函数 553

15.5.4定义函数 554

15.5.5输出函数 556

15.5.6数值谓词函数 556

15.5.7控制流 557

15.5.8表函数 557

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

15.5.10 Scheme函数示例 561

15.5.11 LET 564

15.5.12 Scheme中的尾递归 565

15.5.13函数形式 566

15.5.14构建代码的函数 567

15.6 Common LISP 568

15.7 ML 570

15.8 Haskell 574

15.9 F 578

15.10基本命令式语言对函数式编程的支持 581

15.11函数式语言和命令式语言的比较 582

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

16.1概述 590

16.2谓词演算简介 590

16.2.1命题 591

16.2.2子句形式 592

16.3谓词演算与定理证明 593

16.4逻辑程序设计概述 595

16.5 Prolog的起源 596

16.6 Prolog的基本元素 597

16.6.1项 597

16.6.2事实语句 598

16.6.3规则语句 598

16.6.4目标语句 599

16.6.5 Prolog的推理过程 600

16.6.6简单算术 602

16.6.7表结构 604

16.7 Prolog存在的缺陷 609

16.7.1归结的顺序控制 609

16.7.2封闭世界假设 610

16.7.3否定问题 611

16.7.4固有的限制 612

16.8逻辑程序设计的应用 613

16.8.1关系数据库管理系统 613

16.8.2专家系统 613

16.8.3自然语言处理 614

参考文献 617