程序设计语言原理（原书第12版） kindle 电子书 免费 下载地址

本书从为什么学习程序设计语言、常用程序设计语言的演化史、评估程序设计语言结构的标准，以及这些语言基本的实现方法开始讲起，通过不局限于特定语言种类地分析语言结构的设计问题,检测设计选择,以及比较设计可选方案来讲述程序设计语言基本原理。

译者序

第12版的变化

前言

致谢

第1章 预备知识 1

1.1 掌握程序设计语言概念的必要性 1

1.2 程序设计领域 3

1.2.1 科学计算应用 3

1.2.2 商业应用 3

1.2.3 人工智能 4

1.2.4 Web软件 4

1.3 语言评价标准 4

1.3.1 可读性 5

1.3.2 可写性 9

1.3.3 可靠性 9

1.3.4 成本 10

1.4 影响语言设计的因素 11

1.4.1 计算机体系结构 11

1.4.2 程序设计方法学 13

1.5 程序设计语言分类 14

1.6 语言设计中的权衡 14

1.7 实现方法 15

1.7.1 编译 16

1.7.2 纯解释 18

1.7.3 混合实现系统 19

1.7.4 预处理程序 19

1.8 程序设计环境 20

小结 20

复习题 21

习题 21

第2章 主要程序设计语言发展简史 23

2.1 Zuse研制的Plankalkül语言 23

2.1.1 历史背景 23

2.1.2 语言概述 25

2.2 伪代码 25

2.2.1 短码 26

2.2.2 快码 26

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、77、90、95、2003和 200829

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 相关语言 34

2.5 迈向成熟的第一步：ALGOL 6035

2.5.1 历史背景 35

2.5.2 早期设计过程 35

2.5.3 ALGOL 58概述 36

2.5.4 ALGOL 58报告的接受度 37

2.5.5 ALGOL 60的设计过程 37

2.5.6 ALGOL 60概述 37

2.5.7 评价 38

2.6 商业处理语言：COBOL 39

2.6.1 历史背景 39

2.6.2 FLOW-MATIC 40

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 46

2.8.1 历史背景 47

2.8.2 设计过程 47

2.8.3 语言概述 48

2.8.4 评价 48

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

2.9.1 APL的起源及特征 49

2.9.2 SNOBOL的起源和特征 50

2.10 数据抽象的开端：SIMULA 6750

2.10.1 设计过程 50

2.10.2 语言概述 50

2.11 正交设计：ALGOL 6850

2.11.1 设计过程 51

2.11.2 语言概述 51

2.11.3 评价 51

2.12 ALGOL系列语言的早期继承者 52

2.12.1 简洁的设计：Pascal 52

2.12.2 一个轻便的系统语言：C 53

2.13 基于逻辑的程序设计：Prolog 55

2.13.1 设计过程 55

2.13.2 语言概述 55

2.13.3 评价 56

2.14 历史上规模最大的语言设计：Ada 56

2.14.1 历史背景 56

2.14.2 设计过程 56

2.14.3 语言概述 57

2.14.4 评价 58

2.14.5 Ada 95和Ada 200558

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 Swift：Objective-C的替代品 62

2.16.5 另一个相关语言：Delphi 63

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

2.17.1 设计过程 63

2.17.2 语言概述 64

2.17.3 评价 65

2.18 脚本语言 66

2.18.1 Perl的起源与特点 66

2.18.2 JavaScript的起源与特点 67

2.18.3 PHP的起源与特点 69

2.18.4 Python的起源与特点 69

2.18.5 Ruby的起源与特点 70

2.19 .NET旗帜语言：C# 70

2.19.1 设计过程 70

2.19.2 语言概述 71

2.19.3 评价 71

2.20 混合标记程序设计语言 72

2.20.1 XSLT 72

2.20.2 JSP 73

小结 74

文献注记 74

复习题 74

习题 76

程序设计练习 76

第3章 语法和语义描述 77

3.1 概述 77

3.2 语法描述的一般问题 78

3.2.1 语言识别器 78

3.2.2 语言生成器 79

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

3.3.1 Backus-Naur范式与上下文无关文法 79

3.3.2 扩展的BNF范式 88

3.3.3 文法和识别器 90

3.4 属性文法 90

3.4.1 静态语义 90

3.4.2 基本概念 91

3.4.3 属性文法的定义 91

3.4.4 内在属性 91

3.4.5 属性文法示例 91

3.4.6 计算属性值 93

3.4.7 评价 94

3.5 描述程序的含义：动态语义 94

3.5.1 操作语义 95

3.5.2 指称语义 97

3.5.3 公理语义 100

小结 110

文献注记 110

复习题 110

习题 111

第4章 词法和语法分析 115

4.1 概述 115

4.2 词法分析 116

4.3 语法分析问题 122

4.3.1 语法分析基础 122

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

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

4.3.4 语法分析的复杂度 124

4.4 递归下降的语法分析 124

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

4.4.2 LL文法类 129

4.5 自底向上的语法分析 131

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

4.5.2 移进-归约算法 133

4.5.3 LR语法分析器 133

小结 137

复习题 138

习题 138

程序设计练习 139

第5章 名字、绑定与作用域 140

5.1 概述 140

5.2 名字 140

5.2.1 设计问题 140

5.2.2 名字形式 141

5.2.3 特殊单词 141

5.3 变量 142

5.3.1 名字 142

5.3.2 地址 142

5.3.3 类型 143

5.3.4 值 143

5.4 绑定的概念 143

5.4.1 属性到变量的绑定 144

5.4.2 绑定类型 144

5.4.3 存储绑定和生存期 147

5.5 作用域 149

5.5.1 静态作用域 149

5.5.2 分程序 150

5.5.3 声明顺序 153

5.5.4 全局作用域 153

5.5.5 对静态作用域的评价 156

5.5.6 动态作用域 156

5.5.7 对动态作用域的评价 157

5.6 作用域和生存期 157

5.7 引用环境 158

5.8 有名常量 159

小结 161

复习题 161

习题 162

程序设计练习 165

第6章 数据类型 167

6.1 概述 167

6.2 基本数据类型 168

6.2.1 数值类型 168

6.2.2 布尔类型 170

6.2.3 字符类型 171

6.3 字符串类型 171

6.3.1 设计问题 171

6.3.2 字符串及其运算 171

6.3.3 字符串长度选项 173

6.3.4 评价 173

6.3.5 字符串类型的实现 174

6.4 枚举类型 175

6.4.1 设计问题 175

6.4.2 设计 175

6.4.3 评价 176

6.5 数组类型 177

6.5.1 设计问题 177

6.5.2 数组和索引 178

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

6.5.4 数组初始化 180

6.5.5 数组运算 181

6.5.6 矩阵数组和锯齿形数组 182

6.5.7 切片 182

6.5.8 评价 183

6.5.9 数组类型的实现 183

6.6 关联数组 185

6.6.1 结构与运算 185

6.6.2 关联数组的实现 186

6.7 记录类型 186

6.7.1 记录的定义 187

6.7.2 记录中字段的引用 187

6.7.3 评价 188

6.7.4 记录类型的实现 188

6.8 元组类型 189

6.9 列表类型 190

6.10 联合类型 192

6.10.1 设计问题 192

6.10.2 判别式与自由联合类型 192

6.10.3 F#的联合类型 193

6.10.4 评价 193

6.10.5 联合类型的实现 194

6.11 指针和引用类型 194

6.11.1 设计问题 194

6.11.2 指针运算 194

6.11.3 指针的相关问题 195

6.11.4 C和C++中的指针 196

6.11.5 引用类型 198

6.11.6 评价 199

6.11.7 指针和引用类型的实现 199

6.12 可选类型 203

6.13 类型检查 203

6.14 强类型 204

6.15 类型等价 205

6.16 理论和数据类型 208

小结 209

文献注记 210

复习题 210

习题 211

程序设计练习 212

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

7.1 概述 214

7.2 算术表达式 214

7.2.1 运算符求值顺序 215

7.2.2 运算分量求值顺序 219

7.3 重载运算符 221

7.4 类型转换 222

7.4.1 表达式中的强制转换 222

7.4.2 显式类型转换 223

7.4.3 表达式错误 224

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

7.5.1 关系表达式 224

7.5.2 布尔表达式 225

7.6 短路求值 226

7.7 赋值语句 227

7.7.1 简单赋值 227

7.7.2 条件赋值 227

7.7.3 复合赋值运算符 227

7.7.4 一元赋值运算符 228

7.7.5 赋值表达式 229

7.7.6 多重赋值 229

7.7.7 函数式程序设计语言中的赋值 230

7.8 混合方式赋值 230

小结 231

复习题 231

习题 232

程序设计练习 233

第8章 语句级控制结构 234

8.1 概述 234

8.2 选择语句 235

8.2.1 二路选择语句 235

8.2.2 多路选择语句 238

8.3 重复语句 244

8.3.1 计数控制循环 245

8.3.2 逻辑控制循环 248

8.3.3 用户定义的循环控制机制 249

8.3.4 基于数据结构的迭代 250

8.4 无条件分支 253

8.5 保护命令 254

8.6 结论 256

小结 256

复习题 257

习题 257

程序设计练习 258

第9章 子程序 260

9.1 概述 260

9.2 子程序基础 260

9.2.1 子程序的一般性质 260

9.2.2 基本定义 260

9.2.3 参数 262

9.2.4 过程与函数 265

9.3 子程序的设计问题 265

9.4 局部引用环境 266

9.4.1 局部变量 266

9.4.2 嵌套子程序 267

9.5 参数传递方法 267

9.5.1 参数传递的语义模型 268

9.5.2 参数传递的实现模型 268

9.5.3 参数传递方法的实现 272

9.5.4 常用语言的参数传递方法 272

9.5.5 参数类型检查 274

9.5.6 多维数组参数 276

9.5.7 设计考量 277

9.5.8 参数传递实例 277

9.6 子程序作为参数 280

9.7 子程序间接调用 281

9.8 函数设计问题 282

9.8.1 函数的副作用 283

9.8.2 返回值类型 283

9.8.3 返回值的个数 283

9.9 重载子程序 283

9.10 泛型子程序 284

9.10.1 C++泛型函数 285

9.10.2 Java 5.0泛型方法 286

9.10.3 C# 2005泛型方法 287

9.10.4 F#泛型函数 288

9.11 用户定义的重载运算符 288

9.12 闭包 289

9.13 协同程序 290

小结 292

复习题 293

习题 294

程序设计练习 295

第10章 子程序实现 297

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

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

10.3 具有栈动态局部变量的子程序实现 299

10.3.1 更复杂的活动记录 299

10.3.2 不含递归的例子 301

10.3.3 递归 302

10.4 嵌套子程序 304

10.4.1 基础 304

10.4.2 静态链 305

10.5 分程序 309

10.6 动态作用域的实现 310

10.6.1 深层访问 310

10.6.2 浅层访问 311

小结 312

复习题 312

习题 313

程序设计练习 315

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

11.1 抽象的概念 316

11.2 数据抽象简介 317

11.2.1 浮点型抽象数据类型 317

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

11.2.3 示例 318

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

11.4 语言示例 319

11.4.1 C++中的抽象数据类型 320

11.4.2 Java中的抽象数据类型 325

11.4.3 C#中的抽象数据类型 326

11.4.4 Ruby中的抽象数据类型 327

11.5 参数化抽象数据类型 330

11.5.1 C++ 330

11.5.2 Java 5. 0331

11.5.3 C# 2005333

11.6 封装结构 333

11.6.1 概述 334

11.6.2 C中的封装 334

11.6.3 C++中的封装 334

11.6.4 C#程序集 335

11.7 命名封装 336

11.7.1 C++命名空间 336

11.7.2 Java包 337

11.7.3 Ruby模块 338

小结 338

复习题 339

习题 340

程序设计练习 340

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

12.1 概述 342

12.2 面向对象程序设计 342

12.2.1 引言 342

12.2.2 继承 343

12.2.3 动态绑定 344

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

12.3.1 对象的排他性 346

12.3.2 子类是否为子类型 346

12.3.3 单继承与多继承 347

12.3.4 对象的分配和释放 347

12.3.5 动态绑定与静态绑定 348

12.3.6 嵌套类 348

12.3.7 对象的初始化 349

12.4 支持面向对象程序设计的特定语言 349

12.4.1 Smalltalk 349

12.4.2 C++ 350

12.4.3 Java 359

12.4.4 C# 362

12.4.5 Ruby 363

12.5 面向对象结构的实现 366

12.5.1 存储示例数据 366

12.5.2 方法调用与方法的动态绑定 366

12.6 反射 368

12.6.1 概述 368

12.6.2 什么是反射 368

12.6.3 Java中的反射 369

12.6.4 C#中的反射 371

小结 372

复习题 373

习题 375

程序设计练习 375

第13章 并发 376

13.1 概述 376

13.1.1 多处理器体系结构 377

13.1.2 并发的分类 378

13.1.3 使用并发的动机 378

13.2 子程序级并发 379

13.2.1 基本概念 379

13.2.2 并发语言设计 382

13.2.3 设计问题 382

13.3 信号量 382

13.3.1 概述 382

13.3.2 合作同步 383

13.3.3 竞争同步 385

13.3.4 评价 386

13.4 管程 386

13.4.1 概述 386

13.4.2 竞争同步 386

13.4.3 合作同步 386

13.4.4 评价 387

13.5 消息传递 387

13.5.1 概述 387

13.5.2 同步消息传递的概念 388

13.6 Ada并发支持 388

13.6.1 基本概念 388

13.6.2 合作同步 391

13.6.3 竞争同步 392

13.6.4 受保护对象 393

13.6.5 评价 394

13.7 Java线程 394

13.7.1 线程类 395

13.7.2 优先级 397

13.7.3 信号量 397

13.7.4 竞争同步 397

13.7.5 合作同步 398

13.7.6 非阻塞同步 401

13.7.7 显式锁 401

13.7.8 评价 402

13.8 C#线程 402

13.8.1 基本线程操作 402

13.8.2 同步线程 404

13.8.3 评价 405

13.9 函数式语言中的并发 405

13.9.1 Multi-LISP 405

13.9.2 并发ML 406

13.9.3 F# 406

13.10 语句级并发 407

13.10.1 高性能Fortran 407

小结 409

文献注记 410

复习题 410

习题 411

程序设计练习 412

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

14.1 异常处理概述 413

14.1.1 基本概念 414

14.1.2 设计问题 415

14.2 C++异常处理 417

14.2.1 异常处理程序 417

14.2.2 异常绑定到处理程序 418

14.2.3 延续 418

14.2.4 其他设计选择 418

14.2.5 示例 419

14.2.6 评价 420

14.3 Java异常处理 420

14.3.1 异常类别 421

14.3.2 异常处理程序 421

14.3.3 异常绑定到处理程序 421

14.3.4 其他设计选择 422

14.3.5 示例 423

14.3.6 finally子句 424

14.3.7 断言 425

14.3.8 评价 425

14.4 Python和Ruby的异常处理 426

14.4.1 Python 426

14.4.2 Ruby 427

14.5 事件处理概述 428

14.6 Java事件处理 428

14.6.1 Java Swing GUI组件 428

14.6.2 Java事件模型 429

14.7 C#事件处理 432

小结 434

文献注记 435

复习题 435

习题 436

程序设计练习 437

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

15.1 概述 438

15.2 数学函数 439

15.2.1 简单函数 439

15.2.2 函数形式 440

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

15.4 第一个函数式程序设计语言：LISP 442

15.4.1 数据类型和结构 442

15.4.2 第一个LISP解释器 442

15.5 Scheme概述 444

15.5.1 Scheme的起源 444

15.5.2 Scheme解释器 444

15.5.3 基本数值函数 445

15.5.4 函数定义 445

15.5.5 输出函数 447

15.5.6 数字谓词函数 447

15.5.7 控制流 448

15.5.8 列表函数 448

15.5.9 符号原子和列表的谓词函数 451

15.5.10 Scheme函数示例 452

15.5.11 LET 454

15.5.12 Scheme语言中的尾递归 455

15.5.13 函数形式 456

15.5.14 代码编写函数 457

15.6 Common LISP 458

15.7 ML 459

15.8 Haskell 463

15.9 F# 466

15.10 主要命令式语言对函数式程序设计的支持 469

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

小结 472

文献注记 473

复习题 473

习题 474

程序设计练习 475

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

16.1 概述 477

16.2 谓词演算简介 477

16.2.1 命题 478

16.2.2 子句形式 479

16.3 谓词演算和定理证明 480

16.4 逻辑程序设计概要 481

16.5 Prolog起源 482

16.6 Prolog基本元素 483

16.6.1 项 483

16.6.2 事实陈述 483

16.6.3 规则语句 484

16.6.4 目标语句 485

16.6.5 Prolog的推理过程 485

16.6.6 简单的计算 487

16.6.7 列表结构 489

16.7 Prolog的缺点 493

16.7.1 解析顺序控制 493

16.7.2 封闭世界假设 495

16.7.3 否定的问题 495

16.7.4 内在的局限性 497

16.8 逻辑程序设计应用 497

16.8.1 关系数据库管理系统 497

16.8.2 专家系统 498

16.8.3 自然语言处理 498

小结 498

文献注记 499

复习题 499

习题 500

程序设计练习 500

参考文献 501

索引 510

罗伯特·W. 塞巴斯塔（Robert W. Sebesta），科罗拉多大学斯普林斯分校计算机科学系荣休副教授，拥有40多年计算机科学课程教学经验，研究兴趣包括程序设计语言的设计和评估以及Web程序设计。

暂无出版社相关信息，正在全力查找中！

暂无相关书籍摘录，正在全力查找中！

在线阅读地址：程序设计语言原理（原书第12版）在线阅读

在线听书地址：程序设计语言原理（原书第12版）在线收听

在线购买地址：程序设计语言原理（原书第12版）在线购买

从20世纪50年代中期开始，人们在许多不同的领域对人工智能产生了兴趣。一些来自于语言学领域，一些来自于心理学领域，而另一些来自于数学领域。

语言的正交性与语言的简单性是紧密相关的：程序设计语言的正交性设计得越好，该语言规则中的异常情况就会越少。

书籍介绍

本书从为什么学习程序设计语言、常用程序设计语言的演化史、评估程序设计语言结构的标准，以及这些语言基本的实现方法开始讲起，通过不局限于特定语言种类地分析语言结构的设计问题,检测设计选择,以及比较设计可选方案来讲述程序设计语言基本原理。

• 作者： Yona 发布时间：2011-02-08 03:35:07

  玛西亚太可爱

• 作者： 人狗同归 发布时间：2022-09-25 13:17:20

  千万不要读前言，大大的泄底

• 作者： 腐草为萤 发布时间：2022-02-20 23:03:14

  语言诗意，故事深远。比较喜欢的一本。

• 作者： 程序员金俊 发布时间：2022-06-02 00:52:49

  不错

• 作者： 智娴读书 发布时间：2023-09-04 19:43:55

  好看，把美食与传说结合起来，都是有历史的美食

• 作者： 徐钧 发布时间：2012-11-30 18:28:10

  目前全球范围内，精神分析与佛学对话中最高水平的著作之一。是几十位具有佛学禅修经验的精神分析家（全球第一排的精神分析家）讨论、辩论而成的一本伟大经典。

• 一本《程序发展史》

  作者：Ningz 发布时间：2007-03-06 17:14:12

  我有个“坏习惯”：碰到我买到的书都要评论，呵呵。

  《概念》我也买了，不过买的是第 5 版的英文版。这本书我比较欣赏的是她介绍语言发展的部分《Evolution of the Major Programming Languages》（即：《主流程序设计语言的演化》），从我之前听都没听过的 Zuse Plankalkal 到现在的主流语言，即有我熟知的汇编、C/C++、Basic，也有我浅闻的 Fortran、Eiffel、Ada、Pascal、LISP、Shcema 等，等于是把我零散的概念全部串接在了一切。

  对于一些熟知的编程概念，像什么“数组”、“变量”、“作用域”、“结构”、“类”、“对象”之类的，书中都有阐述其原理及其新旧实现方法。当然，这些实现方法只是“概念”，如果要学习实际的实现方法，这本书显然不怎么适合。

  正如“Reasons for Studying Concepts of Programming Languages”（即“学习程序设计语言概念的理由”）一章中说的那样，学习这些，可以更好地学习一门新的编程语言，更好地理解现有的编程概念。至少对于我，这些是成立的。

  有点不爽的是，我买回去的时候发现有一页是被撕毁栏的（但还可拼接起来）……虽然可以更换，可一算算车费几乎都可以再买一本了，只好怏怏地用胶布贴起来了事了。算是我读这本书的一段小插曲，呵呵

  顺便说一句，经典的书都好贵啊……

• 对程序语言泛泛而谈，缺少对语言的本质解释

  作者：佚名 发布时间：2013-05-16 09:35:19

  这本书的名气很大，很多人说是经典之作。

  读过后是什么感觉呢？就是没什么感觉。读之前对程序语言有多少困惑和不解，读之后还是有多少困惑和不解。

  为什么，因为书里对各种语言的叙述更多停留在语法层面上，是的，不同语言的语法是不一样的。但是为什么新的语言引入了一种东西，这种东西到底是什么？为什么大大提高了编程效率，不同语言的抽象到了什么程度？这些书里都没有讲。