注册 | 登录读书好,好读书,读好书!
读书网-DuShu.com
当前位置: 首页出版图书科学技术计算机/网络软件与程序设计C/C++及其相关C语言教程:英文版

C语言教程:英文版

C语言教程:英文版

定 价:¥65.00

作 者: (美)Al Kelley,(美)Ira Pohl著
出版社: 机械工业出版社
丛编项: 经典原版书库
标 签: C

ISBN: 9787111134145 出版时间: 2004-01-01 包装: 胶版纸
开本: 24cm 页数: 726 字数:  

内容简介

  本书是ANSIC程序设计语言的最畅销的教材和参考书之一。第4版继承了前几版的许多优点,改进、更新和扩展了C的范围,并包含了如何从C过渡到Java和C++的相关知识。初学者和专业程序员都可以借助本书提供的大量示例和练习深入理解书中讲解的每个概念。作者通过循序渐进地解析程序代码,阐明了C语言结构的正确使用和语法,并揭示出其应用的基础逻辑。全书阐述清晰、层次分明,是一本全面论述C语言的权威著作。本书特色新增和更新了编程示例和相关解析——这是本书作者用来说明和讲授语言概念的标志性的技巧。正文论述和练习经过反复推敲,突出了递归的重要性。对多文件编程给予更大的关注,因为这是关系到正确性和类型安全的一些问题。对函数模型的使用贯穿全书。详细论述了抽象数据类型,这是对于理解对象来说必不可少的关键概念。更新了相关资料,讲述如何从C过渡到C++以及Java,其中包括面向对象程序设计的重要概念。以简单表格的形式列出C的关键函数和特征,供读者参考。

作者简介

  IraPohl是美国加州大学圣克鲁兹分校计算机科学技术系教授,具有20多年软件教学经验,是C和C++语言程序设计的国际权威,著有多部与C和C++语言有关的经典著作(其中,《C++精粹》和《C语言解析教程》已经由机械工业出版社翻译出版)。他曾为多家机构提供技术咨询服务,包括DEC公司、苹果公司,斯坦福线形加速器研究中心、Xylinx和Gupta公司等。

图书目录

PrefaCe                  
 Chapter 0                  
 Starting from Zero                  
 0. 1    Why C?                  
 0. 2    ANSI C Standard                  
 0. 3    From C to C++                  
 0. 4    From C and C++to java                  
 Chapter 1                  
 An Overview of C                  
 1. 1    Programming and Preparation                  
 1. 2    Program Output                  
 1. 3    Variables, Expressions, and Assignment                  
 1. 4    The Use of #define and #include                  
 1. 5    The USe of printf()and Scanf()                  
 1. 6    Flow of Control                  
 1. 7    Functions                  
 Call-by-value                  
 1. 8    ArrayS, Strings, and Pointers                  
 Arrays                  
 Strings                  
 Pointers                  
 1. 9    Files                  
 1.10  Operating System Considerations                  
 Writing and Running a C Program                  
 Interrupting a Program                  
 Typing an End-of-file Signal                  
 Redirection of the Input and the Output                  
 Summary                  
 Exercises                  
 Chapter 2                  
 Lexical Elements, Operators, and the C System                  
 2.1   Characters and Lexical Elements                  
 2.2   Syntax Rules                  
 2.3   Comments                  
 2.4   Keywords                  
 2.5   Identifiers                  
 2.6   Constants                  
 2.7   String Constants                  
 2.8   Operators and Punctuators                  
 2.9   Precedence and Associativity of Operators                  
 2.10  Increment and Decrement Operators                  
 2.11  Assignment Operators                  
 2.12  An Example: Computing Powers of 2                  
 2.13  The C System                  
 The Preprocessor                  
 The Standard Library                  
 Summary                  
 Exercises                  
 Chapter 3                  
 The Fundamental Data Types                  
 3.1   Declarations, Expressions, and Assignment                  
 3.2   The Fundamental Data Types                  
 3.3   Characters and the Data Type char                  
 3.4   The Data Type int                  
 3.5   The integral Types short, long, and unsigned                  
 3.6   The Floating Types                  
 3.7   The Use of typedef                  
 3.8   The sizeof Operator                  
 3.9   The Use of getchar() and putchar()                  
 3.10  Mathematical Functions                  
 The Use of abs() and fabs()                  
 UNIX and the Mathematics Library                  
 3.11  Conversions and Casts                  
 The Integral Promotions                  
 The Usual Arithmetic Conversions                  
 Casts                  
 3.12  Hexadecimal and Octal Constants                  
 C.13  Summary                  
 Exercises                  
 Chapter 4                  
 Flow of Control                  
 4.1   Relational, Equality, and Logical Operators                  
 4.2   Relational Operators and Expressions                  
 4.3   Equality Operators and Expressions                  
 4.4   Logical Operators and Expressions                  
 Short-circuit Evaluation                  
 4.5   The Compound Statement                  
 4.6   The Expression and Empty Statement                  
 4.7   The if and the if-else Statements                  
 4.8   The while Statement                  
 4.9   The for Statement                  
 4.10  An Example: Boolean Variables                  
 4.11  The Comma Operator                  
 4.12  The do Statement                  
 4.13  An Example: Fibonacci Numbers                  
 4.14  The goto Statement                  
 4.15  The break and continue Statements                  
 4.16  The switch Statement                  
 4.17  The Conditional Operator                  
 Summary                  
 Exercises                  
 Chapter 5                  
 Functions                  
 5.1   Function Definition                  
 5.2   The return Statement                  
 5.3   Function Prototypes                  
 Function Prototypes in C++                  
 5.4   An Example: Creating a Table of Powers                  
 5.5   Function Declarations from the Compiler's Viewpoint                  
 Limitations                  
 5.6   An Alternate Style for Function Definition Order                  
 5.7   Function Invocation and Call-by-Value                  
 5.8   Developing a Large Program                  
 What Constitutes a Large Program?                  
 5.9   Using Assertions                  
 5.10  Scope Rules                  
 Parallel and Nested Blocks                  
 Using a Block for Debugging                  
 5.11  Storage Classes                  
 The Storage Class auto                  
 The Storage Class extern                  
 The Storage Class register                  
 The Storage Class static                  
 5.12  Static External Variables                  
 5.13  Default Initialization                  
 5.14  Recu rsion                  
 Efficiency Considerations                  
 5.15  An Example: The Towers of Hanoi                  
 Summary                  
 Exercises                  
 Chapter 6                  
 Arrays, Pointers, and Strings                  
 6.1   One-dimensional Arrays                  
 Initialization                  
 Subscripting                  
 6.2   Pointers                  
 6.3   Call-by-Reference                  
 6.4   The Relationship Between Arrays and Pointers                  
 6.5   Pointer Arithmetic and Element Size                  
 6.6   Arrays as Function Arguments                  
 6.7   An Example: Bubble Sort                  
 6.8   Dynamic Memory Allocation With calloc() and malloc()                  
 Offsetting the Pointer                  
 6.9   An Example: Merge and Merge Sort                  
 6.10  Strings                  
 6.11  String-Handling Functions in the Standard Library                  
 6.12  Multidimensional Arrays                  
 Two-dimensional Arrays                  
 The Storage Mapping Function                  
 Formal Parameter Declarations                  
 Three-dimensional Arrays                  
 Initialization                  
 The Use of typedef                  
 6.13  Arrays of Pointers                  
 6.14  Arguments to main()                  
 6.15  Ragged Arrays                  
 6.16  Functions as Arguments                  
 Functions as Formal Parameters in Function Prototypes                  
 6.17  An Example: Using Bisection to Find the Root of a Function                  
 The Kepler Equation                  
 6.18  Arrays of Pointers to Function                  
 6.19  The Type Qualifiers const and volati 1 e                  
 Summary                  
 Exercises                  
 Chapter 7                  
 Bitwise Operators and Enumeration Types                  
 7.1   Bitwise Operators and Expressions                  
 Bitwise Complement                  
 Two's Complement                  
 Bitwise Binary Logical Operators                  
 Left and Right Shift Operators                  
 7.2   Masks                  
 7.3   Software Tools: Printing an int Bitwise                  
 7.4   Packing and Unpacking                  
 Multibyte Character Constants                  
 7.5   Enumeration Types                  
 7.6   An Example: The Game of Paper, Rock, Scissors                  
 Summary                  
 Exercises                  
 Chapter 8                  
 The Preprocessor                  
 8.1   The Use of #include                  
 8.2   The Use of #define                  
 Syntactic Sugar                  
 8.3   Macros with Arguments                  
 8.4   The Type Definitions and Macros in stddef, h                  
 8.5   An Example: Sorting with qsort()                  
 8.6   An Example: Macros with Arguments                  
 8.7   The Macros in stdio, h and ctype.h                  
 8.8   Conditional Compilation                  
 8.9   The Predefined Macros                  
 8.10  The Operators # and ##                  
 8.11  The assert() Macro                  
 8.1 2  The Use of #error and #pragma                  
 8.1 3  Line Numbers                  
 8.14  Corresponding Functions                  
 8.15  An Example: Quicksort                  
 Summary                  
 Exercises                  
 Chapter 9                  
 Structures and Unions                  
 9.1    Structures                  
 9.2   Accessing Members of a Structure                  
 9.3   Operator Precedence and Associativity: A Final Look                  
 9.4   Using Structures with Functions                  
 9.5   Initialization of Structures                  
 9.6   An Example: Playing Poker                  
 9.7   Unions                  
 9.8   Bit Fields                  
 9.9   An Example: Accessing Bits and Bytes                  
 9.10  The ADT Stack                  
 Summary                  
 Exercises                  
 Chapter 10                  
 Structures and List Processing                  
 10.1  Self-referential Structures                  
 10.2  Linear Linked Lists                  
 Storage Allocation                  
 10.3  List Operations                  
 10.4  Some List Processing Functions                  
 Insertion                  
 Deletion                  
 10.5  Stacks                  
 10.6  An Example: Polish Notation and Stack Evaluation                  
 10.7  Queues                  
 10.8  Binary Trees                  
 Binary Tree Traversal                  
 Creating Trees                  
 10.9  General Linked Lists                  
 Traversal                  
 The Use of calloc() and Building Trees                  
 Summary                  
 Exercises                  
 Chapter 1 1                  
 Input/Output and the Operating System                  
 1 1.1  The Output Function printfO                  
 11.2  The Input FunctionscanfO                  
 11.3  The FunctionsfprintfO, fscanf(),sprintfO,                  
 and sscanf()                  
 11.4  The Functionsfopen() and fcloseO                  
 11.5  An Example: Double Spacing a File                  
 11.6  Using Temporary Files and Graceful Functions                  
 11.7  Accessing a File Randomly                  
 11.8  File Descriptor Input/Output                  
 11.9  File Access Permissions                  
 11.10  Executing Commands from Within a C Program                  
 11.11  Using Pipes from Within a C Program                  
 11.12  Environment Variables                  
 11.13  The C Compiler                  
 11.14  Using the Profiler                  
 11.15  Libraries                  
 11.16  How to TimeCCode                  
 11.17  The Use of make                  
 11.18  The Use of touch                  
 11.19  Other Useful Tools                  
 Summary                  
 Exercises                  
 Chapter 12                  
 Advanced Applications                  
 12.1  Creating a Concurrent Process with fork()                  
 12.2  Overlaying a Process: the exec... () Family                  
 Using the spawn...() Family                  
 12.3  Interprocess Communication Using pi pe()                  
 12.4  Signals                  
 1 2.5  An Example: The Dining Philosophers                  
 1 2.6  Dynamic Allocation of Matrices                  
 Why Arrays of Arrays Are Inadequate                  
 Building Matrices with Arrays of Pointers                  
 Adjusting the Subscript Range                  
 Allocating All the Memory at Once                  
 1 2.7  Returning the Status                  
 Summary                  
 Exercises                  
 Chapter 13                  
 Moving from C to C++                  
 13.1  Output                  
 13.2  Input                  
 13.3  Functions                  
 13.4  Classes and Abstract Data Types                  
 13.5  Overloading                  
 13.6  Constructors and Destructors                  
 13.7  Object-oriented Programming and Inheritance                  
 13.8  Polymorphism                  
 13.9  Templates                  
 13.10  C++ Exceptions                  
 13.11  Benefits of Object-oriented Programming                  
 Summary                  
 Exercises                  
 Chapter 14                  
 Moving from C to Java                  
 14.1  Output                  
 14.2  Variables and Types                  
 14.3  Classes and Abstract Data Types                  
 14.4  Overloading                  
 14.5  Construction and Destruction of Class Types                  
 14.6  Object-oriented Programming and Inheritance                  
 14.7  Polymorphism and Overriding Methods                  
 14.8  Applets                  
 14.9  Java Exceptions                  
 14.10  Benefits of Java and OOP                  
 Summary                  
 Exercises                  
 Appendix A                  
 The Standard Library                  
 A.1   Diagnostics:                   
 A.2   Character Handling:                   
 Testing a Character                  
 Mapping a Character                  
 A.3  Errors:                   
 A.4  Floating Limits:                   
 A.5  Integral Limits:                   
 A.6  Localization:                   
 A.7  Mathematics:                   
 A.8   Nonlocal Jumps:                   
 A.9   Signal Handling:                   
 A. 10  Variable Arguments:                   
 A. 11  Common Definitions:                   
 A. 12  Input/Output:                   
 Opening, Closing, and Conditioning a File                  
 Accessing the File Position Indicator                  
 Error Handling                  
 Character Input/Output                  
 Formatted Input/Output                  
 Direct Input/Output                  
 Removing or Renaming a File                  
 A.13  General Utilities:                  
 Dynamic Allocation of Memory                  
 Searching and Sorting                  
 Pseudo Random-Number Generator                  
 Communicating with the Environment                  
 Integer Arithmetic                  
 String Conversion                  
 Multibyte Character Functions                  
 Multibyte String Functions                  
 Leaving the Program                  
 A.14  Memory and String Handling:                   
 Memory-Handling Functions                  
 String-Handling Functions                  
 A.15  Date and Time:                   
 Accessing the Clock                  
 Accessing the Time                  
 A.16  Miscellaneous                  
 File Access                  
 Using File Descriptors                  
 Creating a Concurrent Process                  
 Overlaying a Process                  
 Interprocess Communication                  
 Suspending Program Execution                  
 Appendix B                  
 Language Syntax                  
 B.1   Prog ram                  
 B.2   Function Definition                  
 B.3   Declaration                  
 B.4   Statement                  
 B.5   Expression                  
 B.6   Constant                  
 B.7   String Literal                  
 B.8   Preprocessor                  
 Appendix C                  
 ANSI C Compared to Traditional C                  
 C.1   Types                  
 C.2   Constants                  
 C.3   Declarations                  
 C.4   Initializations                  
 C.5   Expressions                  
 C.6   Functions                  
 C.7   Conversions                  
 C.8   Array Pointers                  
 C.9   Structures and Unions                  
 C.10  Preprocessor                  
 C.11  Header Files                  
 C.12  Miscellaneous                  
 Appendix D                  
 ASCII Character Codes                  
 Appendix E                  
 Operator Precedence and Associativity                  
 Index                  

本目录推荐