注冊 | 登錄讀書好,好讀書,讀好書!
讀書網-DuShu.com
當前位置: 首頁出版圖書科學技術計算機/網絡軟件與程序設計C/C++及其相關C語言教程:英文版

C語言教程:英文版

C語言教程:英文版

定 價:¥65.00

作 者: (美)Al Kelley,(美)Ira Pohl著
出版社: 機械工業(yè)出版社
叢編項: 經典原版書庫
標 簽: C

ISBN: 9787111134145 出版時間: 2004-01-01 包裝: 膠版紙
開本: 24cm 頁數: 726 字數:  

內容簡介

  本書是ANSIC程序設計語言的最暢銷的教材和參考書之一。第4版繼承了前幾版的許多優(yōu)點,改進、更新和擴展了C的范圍,并包含了如何從C過渡到Java和C++的相關知識。初學者和專業(yè)程序員都可以借助本書提供的大量示例和練習深入理解書中講解的每個概念。作者通過循序漸進地解析程序代碼,闡明了C語言結構的正確使用和語法,并揭示出其應用的基礎邏輯。全書闡述清晰、層次分明,是一本全面論述C語言的權威著作。本書特色新增和更新了編程示例和相關解析——這是本書作者用來說明和講授語言概念的標志性的技巧。正文論述和練習經過反復推敲,突出了遞歸的重要性。對多文件編程給予更大的關注,因為這是關系到正確性和類型安全的一些問題。對函數模型的使用貫穿全書。詳細論述了抽象數據類型,這是對于理解對象來說必不可少的關鍵概念。更新了相關資料,講述如何從C過渡到C++以及Java,其中包括面向對象程序設計的重要概念。以簡單表格的形式列出C的關鍵函數和特征,供讀者參考。

作者簡介

  IraPohl是美國加州大學圣克魯茲分校計算機科學技術系教授,具有20多年軟件教學經驗,是C和C++語言程序設計的國際權威,著有多部與C和C++語言有關的經典著作(其中,《C++精粹》和《C語言解析教程》已經由機械工業(yè)出版社翻譯出版)。他曾為多家機構提供技術咨詢服務,包括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                  

本目錄推薦

掃描二維碼
Copyright ? 讀書網 m.ranfinancial.com 2005-2020, All Rights Reserved.
鄂ICP備15019699號 鄂公網安備 42010302001612號