图书信息
图书目录

程序设计语言概念(第七版 影印版)


暂无简介


作者:
[美] Robert W. Sebesta

定价:
49.00 元

出版时间:
2006-06-30

ISBN:
978-7-04-019411-1

物料号:
19411-00

读者对象:
高等教育

一级分类:
计算机/教育技术类

二级分类:
计算机类专业核心课程

三级分类:
程序设计基础

重点项目:
暂无

版面字数:
940千字

开本:
16开

装帧形式:
平装

页数:
724

最新
印次时间:
2013年01月
  • 目录
    • Chapter 1 Preliminaries
      • 1.1 Reasons for Studying Concepts of Programming Languages
        • 1.2 Programming Domains
          • 1.3 Language Evaluation Criteria
            • 1.4 Influences on Language Design
              • 1.5 Language Categories
                • 1.6 Language Design Trade-offs
                  • 1.7 Implementation Methods
                    • 1.8 Programming Environments
                      • Summary·Review Questions·Problem Set
                      • Chapter 2 Evolution of the Major Programming Languages
                        • 2.1 Zuse's Plankalk0l
                          • 2.2 Minimal Hardware Programming: Pseudocodes
                            • 2.3 The IBM 704 and Fortran
                              • 2.4 Functional Programming: LISP
                                • 2.5 The First Step Toward Sophistication: ALGOL 60
                                  • 2.6 Computerizing Business Records: COBOL
                                    • 2.7 The Beginnings of Timesharing: BASIC
                                      • Interview. ALAN COOPER—User Design and Language Design
                                        • 2.8 Everything for Everybody: Pl/I
                                          • 2.9 Two Early Dynamic Languages: APL and SNOBOL
                                            • 2.10 The Beginnings of Data Abstraction: SIMULA 67
                                              • 2.11 Orthogonal Design: ALGOL 68
                                                • 2.12 Some Early Descendants of the ALGOLs
                                                  • 2.13 Programming Based on Logic: Prolog
                                                    • 2.14 History's Largest Design Effort: Ada
                                                      • 2.15 Object-Oriented Programming: Smalltalk
                                                        • 2.16 Combining Imperative and Object-Oriented Features: C++
                                                          • 2.17 An Imperative-Based Object-Oriented Language: Java
                                                            • 2.18 Scripting Languages: JavaScript, PHP, and Python
                                                              • 2.19 A C-Based Language for the New Millennium: C#
                                                                • 2.20 Markup/Programming Hybrid Languages
                                                                  • Summary·Bibliographic Notes·Review Questions·Problem Set
                                                                  • Chapter 3 Describing Syntax and Semantics
                                                                    • 3.1 Introduction
                                                                      • 3.2 The General Problem of Describing Syntax
                                                                        • 3.3 Formal Methods of Describing Syntax
                                                                          • 3.4 Attribute Grammars
                                                                            • History Note
                                                                              • 3.5 Describing the Meanings of Programs: Dynamic Semantics
                                                                                • History Note
                                                                                  • Summary·Bibliographic Notes·Review Questions·Problem Set·Programming Exercises
                                                                                  • Chapter 4 Lexical and Syntax Analysis
                                                                                    • 4.1 Introduction
                                                                                      • 4.2 Lexical Analysis
                                                                                        • 4.3 The Parsing Problem
                                                                                          • 4.4 Recursive-Descent Parsing
                                                                                            • 4.5 Bottom-Up Parsing
                                                                                              • Summary·Review Questions·Problem Set·Programming Exercises
                                                                                              • Chapter 5 Names, Bindings,Type Checking, and Scopes
                                                                                                • 5.1 Introduction
                                                                                                  • 5.2 Names
                                                                                                    • History Note
                                                                                                      • History Note
                                                                                                        • 5.3 Variables
                                                                                                          • History Note
                                                                                                            • 5.4 The Concept of Binding
                                                                                                              • Interview: RASMUS LERDORF—Scripting Languages and Other Examples of Slick Solutions
                                                                                                                • 5.5 Type Checking
                                                                                                                  • 5.6 Strong Typing
                                                                                                                    • 5.7 Type Compatibility
                                                                                                                      • History Note
                                                                                                                        • 5.8 Scope
                                                                                                                          • 5.9 Scope and Lifetime
                                                                                                                            • 5.10 Referencing Environments
                                                                                                                              • 5.11 Named Constants
                                                                                                                                • Summary·Review Questions·Problem Set·Programming Exercises
                                                                                                                                • Chapter 6 Data Types
                                                                                                                                  • 6.1 Introduction
                                                                                                                                    • 6.2 Primitive Data Types
                                                                                                                                      • 6.3 Character String Types
                                                                                                                                        • History Note
                                                                                                                                          • 6.4 User-Defined Ordinal Types
                                                                                                                                            • 6.5 Array Types
                                                                                                                                              • History Note
                                                                                                                                                • History Note
                                                                                                                                                  • 6.6 Associative Arrays
                                                                                                                                                    • Interview: RASMUS LERDORF—The Open Source Movement and Work Life
                                                                                                                                                      • 6.7 Record Types
                                                                                                                                                        • 6.8 Union Types
                                                                                                                                                          • 6.9 Pointer and Reference Types
                                                                                                                                                            • History Note
                                                                                                                                                              • Summary·Bibliographic Notes·Review Questions·Problem Set·Programming Exercises
                                                                                                                                                              • Chapter 7 Expressions and Assignment Statements
                                                                                                                                                                • 7.1 Introduction
                                                                                                                                                                  • 7.2 Arithmetic Expressions
                                                                                                                                                                    • History Note
                                                                                                                                                                      • 7.3 Overloaded Operators
                                                                                                                                                                        • 7.4 Type Conversions
                                                                                                                                                                          • History Note
                                                                                                                                                                            • 7.5 Relational and Boolean Expressions
                                                                                                                                                                              • History Note
                                                                                                                                                                                • 7.6 Short-Circuit Evaluation
                                                                                                                                                                                  • 7.7 Assignment Statements
                                                                                                                                                                                    • History Note
                                                                                                                                                                                      • 7.8 Mixed-mode Assignment
                                                                                                                                                                                        • Summary·Review Questions·Problem Set·Programming Exercises
                                                                                                                                                                                        • Chapter 8 Statement-Level Control Structures
                                                                                                                                                                                          • 8.1 Introduction
                                                                                                                                                                                            • 8.2 Selection Statements
                                                                                                                                                                                              • History Note
                                                                                                                                                                                                • History Note
                                                                                                                                                                                                  • 8.3 Iterative Statements
                                                                                                                                                                                                    • istoty Note
                                                                                                                                                                                                      • Interview: LARRY WALL—Part 1:Linguistics and the Birth of Perl
                                                                                                                                                                                                        • 8.4 Unconditional Branching
                                                                                                                                                                                                          • Histoty Note
                                                                                                                                                                                                            • 8.5 Guarded Commands
                                                                                                                                                                                                              • 8.6 Conclusions
                                                                                                                                                                                                                • Summary·Review Questions·Problem Set·Programming Exercises
                                                                                                                                                                                                                • Chapter 9 Subprograms
                                                                                                                                                                                                                  • 9.1 Introduction
                                                                                                                                                                                                                    • 9.2 Fundamentals of Subprograms
                                                                                                                                                                                                                      • 9.3 Design Issues for Subprograms
                                                                                                                                                                                                                        • 9.4 Local Referencing Environments
                                                                                                                                                                                                                          • 9.5 Parameter-Passing Methods
                                                                                                                                                                                                                            • Interview. LARRY WALL-Part 2: Scripting Languages in General and Perl in Particular
                                                                                                                                                                                                                              • History Note
                                                                                                                                                                                                                                • History Note
                                                                                                                                                                                                                                  • History Note
                                                                                                                                                                                                                                    • 9.6 Parameters That Are Subprogram Names
                                                                                                                                                                                                                                      • History Note
                                                                                                                                                                                                                                        • 9.7 Overloaded Subprograms
                                                                                                                                                                                                                                          • 9.8 Generic Subprograms
                                                                                                                                                                                                                                            • 9.9 Design Issues for Functions
                                                                                                                                                                                                                                              • 9.10 User-Defined Overloaded Operators
                                                                                                                                                                                                                                                • 9.11 Coroutines
                                                                                                                                                                                                                                                  • History Note
                                                                                                                                                                                                                                                    • Summary·Review Questions·Problem Set·Programming Exercises
                                                                                                                                                                                                                                                    • Chapter 10 Implementing Subprograms
                                                                                                                                                                                                                                                      • 10.1 The General Semantics of Calls and Returns
                                                                                                                                                                                                                                                        • 10.2 Implementing “Simple”Subprograms
                                                                                                                                                                                                                                                          • 10.3 Implementing Subprograms with Stack-Dynamic Local Variables
                                                                                                                                                                                                                                                            • 10.4 Nested Subprograms
                                                                                                                                                                                                                                                              • Interview. NIKLAUS WIRTH—Keeping It Simple
                                                                                                                                                                                                                                                                • 10.5 Blocks
                                                                                                                                                                                                                                                                  • 10.6 Implementing Dynamic Scoping
                                                                                                                                                                                                                                                                    • Summary·Review Questions·Problem Set
                                                                                                                                                                                                                                                                    • Chapter 11 Abstract Data Types and Encapsulation Constructs
                                                                                                                                                                                                                                                                      • 11.1 The Concept of Abstraction
                                                                                                                                                                                                                                                                        • 11.2 Introduction to Data Abstraction
                                                                                                                                                                                                                                                                          • 11.3 Design Issues for Abstract Data Types
                                                                                                                                                                                                                                                                            • 11.4 Language Examples
                                                                                                                                                                                                                                                                              • Interview. BJARNE STROUSTRUP-C++: Its Birth, Its Ubiquitousness, and Common Criticisms
                                                                                                                                                                                                                                                                                • 11.5 Parameterized Abstract Data Types
                                                                                                                                                                                                                                                                                  • 11.6 Encapsulation Constructs
                                                                                                                                                                                                                                                                                    • 11.7 Naming Encapsulations
                                                                                                                                                                                                                                                                                      • Summary·Review Questions·Problem Set·Programming Exercises
                                                                                                                                                                                                                                                                                      • Chapter 12 Support for Object-Oriented Programming
                                                                                                                                                                                                                                                                                        • 12.1 Introduction
                                                                                                                                                                                                                                                                                          • 12.2 Object-Oriented Programming
                                                                                                                                                                                                                                                                                            • 12.3 Design Issues for Object-Oriented Languages
                                                                                                                                                                                                                                                                                              • 12.4 Support for Object-Oriented Programming in Smalltalk
                                                                                                                                                                                                                                                                                                • 12.5 Support for Object-Oriented Programming in C++
                                                                                                                                                                                                                                                                                                  • Interview. BJARNE STROUSTRUP—On Paradigms and Better Programming
                                                                                                                                                                                                                                                                                                    • 12.6 Support for Object-Oriented Programming in Java
                                                                                                                                                                                                                                                                                                      • 12.7 Support for Object-Oriented Programming in C#
                                                                                                                                                                                                                                                                                                        • 12.8 Support for Object-Oriented Programming in Ada 95
                                                                                                                                                                                                                                                                                                          • 12.9 The Object Model.of JavaScript
                                                                                                                                                                                                                                                                                                            • 12.10 Implementation of Object-Oriented Constructs
                                                                                                                                                                                                                                                                                                              • Summary·Review Questions·Problem Set·Programming Exercises
                                                                                                                                                                                                                                                                                                              • Chapter 13 Concurrency
                                                                                                                                                                                                                                                                                                                • 13.1 Introduction
                                                                                                                                                                                                                                                                                                                  • 13.2 Introduction to Subprogram-Level Concurrency
                                                                                                                                                                                                                                                                                                                    • 13.3 Semaphores
                                                                                                                                                                                                                                                                                                                      • HIstory NOte
                                                                                                                                                                                                                                                                                                                        • 13.4 Monitors
                                                                                                                                                                                                                                                                                                                          • 13.5 Message Passing
                                                                                                                                                                                                                                                                                                                            • 13.6 Ada Support for Concurrency
                                                                                                                                                                                                                                                                                                                              • 13.7 Java Threads
                                                                                                                                                                                                                                                                                                                                • 13.8 C# Threads
                                                                                                                                                                                                                                                                                                                                  • 13.9 Statement-Level Concurrency
                                                                                                                                                                                                                                                                                                                                    • Summary·Bibliographic Notes·Review Questions·Problem Set·Programming Exercises
                                                                                                                                                                                                                                                                                                                                    • Chapter 14 Exception Handling and Event Handling
                                                                                                                                                                                                                                                                                                                                      • 14.1 Introduction to Exception Handling
                                                                                                                                                                                                                                                                                                                                        • History Note
                                                                                                                                                                                                                                                                                                                                          • 14.2 Exception Handling in Ada
                                                                                                                                                                                                                                                                                                                                            • 14.3 Exception Handling in C++
                                                                                                                                                                                                                                                                                                                                              • 14.4 Exception Handling in Java
                                                                                                                                                                                                                                                                                                                                                • Interview. JAMES GOSLING—The Birth of Java
                                                                                                                                                                                                                                                                                                                                                  • 14.5 Introduction to Event Handling
                                                                                                                                                                                                                                                                                                                                                    • 14.6 Event Handling with Java
                                                                                                                                                                                                                                                                                                                                                      • Summary·Bibliographic Notes·Review Questions·Problem Set
                                                                                                                                                                                                                                                                                                                                                      • Chapter 15 Functional Programming Languages
                                                                                                                                                                                                                                                                                                                                                        • 15.1 Introduction
                                                                                                                                                                                                                                                                                                                                                          • 15.2 Mathematical Functions
                                                                                                                                                                                                                                                                                                                                                            • 15.3 Fundamentals of Functional Programming Languages
                                                                                                                                                                                                                                                                                                                                                              • 15.4 The First Functional Programming Language: LISP
                                                                                                                                                                                                                                                                                                                                                                • 15.5 An Introduction to Scheme
                                                                                                                                                                                                                                                                                                                                                                  • 15.6 COMMON LISP
                                                                                                                                                                                                                                                                                                                                                                    • 15.7 M L
                                                                                                                                                                                                                                                                                                                                                                      • 15.8 Haskell
                                                                                                                                                                                                                                                                                                                                                                        • 15.9 Applications of Functional Languages
                                                                                                                                                                                                                                                                                                                                                                          • 15.10 A Comparison of Functional and Imperative Languages
                                                                                                                                                                                                                                                                                                                                                                            • Summary·Bibliographic Notes·Review Questions·Problem Set·Programming Exercises
                                                                                                                                                                                                                                                                                                                                                                            • Chapter 16 Logic Programming Languages
                                                                                                                                                                                                                                                                                                                                                                              • 16.1 Introduction
                                                                                                                                                                                                                                                                                                                                                                                • 16.2 A Brief Introduction to Predicate Calculus
                                                                                                                                                                                                                                                                                                                                                                                  • 16.3 Predicate Calculus and Proving Theorems
                                                                                                                                                                                                                                                                                                                                                                                    • 16.4 An Overview of Logic Programming
                                                                                                                                                                                                                                                                                                                                                                                      • 16.5 The Origins of Prolog
                                                                                                                                                                                                                                                                                                                                                                                        • 16.6 The Basic Elements of Prolog
                                                                                                                                                                                                                                                                                                                                                                                          • 16.7 The Deficiencies of Prolog
                                                                                                                                                                                                                                                                                                                                                                                            • 16.8 Applications of Logic Programming
                                                                                                                                                                                                                                                                                                                                                                                              • Summary·Bibliographic Notes·Review Questions.Problem Set·Programming Exercises
                                                                                                                                                                                                                                                                                                                                                                                              • Bibliography
                                                                                                                                                                                                                                                                                                                                                                                                • Index
                                                                                                                                                                                                                                                                                                                                                                                                1