ISBN-10:
0805331409
ISBN-13:
9780805331400
Pub. Date:
01/30/1992
Publisher:
Addison-Wesley
C by Dissection: The Essentials of C Programming / Edition 2

C by Dissection: The Essentials of C Programming / Edition 2

by Al Kelley

Paperback

Current price is , Original price is $44.95. You

Temporarily Out of Stock Online

Please check back later for updated availability.

This item is available online through Marketplace sellers.

Overview

B> C by Dissection presents a thorough introduction to the programming process by carefully developing working programs to illuminate key features of the C programming language. This book presents the concepts of the programming process using the "dissection" method. Dissection is a unique tool first developed by the authors to point out key features of program code. It is similar to a structured walk-through of the code, with the intention of explaining newly encountered programming elements and idioms as found in working code. Each chapter presents a number of carefully explained programs, which lead the reader in a holistic manner to ever-improving programming skills. Right from the start, the reader is introduced to complete programs, and at an early point in the book is introduced to writing functions as a major feature of structured programming. This edition features expanded treatment of pointers, memory management, and recursion. It also takes into account the fact that many people are learning Java as a first language and then going to C, or vice-versa, and calls out those topics that present a challenge when making such transitions (e.g. i/o, data types). This book assumes no programming background and can be used by first-time computer users or by experienced programmers who are transitioning to C.

Product Details

ISBN-13: 9780805331400
Publisher: Addison-Wesley
Publication date: 01/30/1992
Edition description: Older Edition
Pages: 656

Table of Contents

1. Writing an ANSI C Program.
Getting Ready to Program.
A First Program.
Variables, Expressions, and Assignments.
Initialization.
The Use of #define and #include.
The Use of printf() and scanf().
The Use of printf().
The Use of scanf().
The while Statement.
Problem Solving: Computing Sums.
Style.
Common Programming Errors.
System Considerations.
Writing and Running a C Program.
Interrupting a Program.
Typing an End-of-File Signal.
Redirection of the Input and the Output.
Moving to C++.
Summary.
Exercises.

2. Lexical Elements, Operators, and the C System.
Characters and Lexical Elements.
Comments.
Keywords.
Identifiers.
Constants.
String Constants.
Operators and Punctuators.
Precedence and Associativity of Operators.
Increment and Decrement Operators.
Assignment Operators.
An Example: Computing Powers of 2.
The C System.
The Preprocessor.
The Standard Library.
Style.
Common Programming Errors.
System Considerations.
Moving to C++.
Summary.
Exercises.

3. Flow of Control.
Relational, Equality, and Logical Operators.
Relational Operators and Expressions.
Equality Operators and Expressions.
Logical Operators and Expressions.
Short-Circuit Evaluation.
The Compound Statement.
The Empty Statement.
The if and if-else Statements.
The while Statement.
Problem Solving: Finding Maximum Values.
The for Statement.
Problem Solving: Combinatorics.
Problem Solving: Boolean Variables.
The Comma Operator.
The do Statement.
The goto Statement.
The break and continue Statements.
The switch Statement.
Nested Flow of Control.
The Conditional Operator.
Style.
Common Programming Errors.
System Considerations.
Moving to C++.
Summary.
Exercises.

4. Functions and Structured Programming.
Function Invocation.
Function Definition.
The return Statement.
Function Prototypes.
Top-Down Design.
Program Correctness: The assert() Macro.
Function Declarations from the Compiler's Viewpoint.
Limitations.
Problem Solving: Random Numbers.
An Alternate Style for Function Definition Order.
Developing a Large Program.
What Constitutes a Large Program?
A Simulation: The Game of Heads or Tails.
Invocation and Call-by-Value.
Recursion.
Style.
Common Programming Errors.
System Considerations.
Moving to C++.
Function Prototypes in C++.
Summary.
Exercises.

5. Character Processing.
The Data Type char.
The Use of getchar() and putchar().
An Example: Capitalize.
The Macros in ctype.h.
Problem Solving: Repeating Characters.
Problem Solving: Counting Words.
Style.
Common Programming Errors.
System Considerations.
Moving to C++.
Summary.
Exercises.

6. The Fundamental Data Types.
Declarations and Expressions.
The Fundamental Data Types.
Characters and the Data Type char.
The Data Type int.
The Integral Types short, long, and unsigned.
The Floating Types.
The sizeof Operator.
Mathematical Functions.
Conversions and Casts.
The Integral Promotions.
The Usual Arithmetic Conversions.
Casts.
Problem Solving: Computing Interest.
Style.
Common Programming Errors.
System Considerations.
Moving to C++.
Summary.
Exercises.

7. Enumeration Types and typedef.
Enumeration Types.
The Use of typedef.
An Example: The Game of Paper, Rock, Scissors.
Style.
Common Programming Errors.
System Considerations.
Moving to C++.
Summary.
Exercises.

8. Functions, Pointers, and Storage Classes.
Pointer Declaration and Assignment.
Addressing and Dereferencing.
Pointers to void.
Call-by-Reference.
Scope Rules.
Storage Classes.
The Storage Class auto.
The Storage Class extern.
The Storage Class register.
The Storage Class static.
Static External Variables.
Default Initialization.
An Example: Processing Characters.
Function Declarations and Definitions.
The Type Qualifiers const and volatile.
Style.
Common Programming Errors.
System Considerations.
Moving to C++.
Summary.
Exercises.

9. Arrays and Pointers.
One-Dimensional Arrays.
Initialization.
Subscripting.
An Example: Counting Each Letter Separately.
The Relationship Between Arrays and Pointers.
Pointer Arithmetic and Element Size.
Passing Arrays to Functions.
A Sorting Algorithm: Bubble Sort.
Two-Dimensional Arrays.
Multidimensional Arrays.
Dynamic Memory Allocation.
Style.
Common Programming Errors.
System Considerations.
Moving to C++.
Summary.
Exercises.

10. Strings and Pointers.
The End-of-String Sentinel \0.
Initialization of Strings.
An Example: Have a Nice Day.
Using Pointers to Process a String.
Problem Solving: Counting Words.
Passing Arguments to main().
String Handling Functions in the Standard Library.
Style.
Common Programming Errors.
System Considerations.
Moving to C++.
Summary.
Exercises.

11. Recursion.
Recursive Problem Solving.
An Example: Drawing Patterns on the Screen.
String Handling Using Recursion.
The Divide-and-Conquer Methodology.
Style.
Common Programming Errors.
System Considerations.
Moving to C++.
Summary.
Exercises.

12. Structures and ADTs.
Declaring Structures.
Accessing a Member.
Operator Precedence and Associativity: A Final Look.
Structures, Functions, and Assignment.
Problem Solving: Student Records.
Initialization of Structures.
The Use of typedef.
Self-Referential Structures.
Linear Linked Lists.
Dynamic Storage Allocation.
List Operations.
Counting and Lookup.
Insertion and Deletion.
Style.
Common Programming Errors.
System Considerations.
Moving to C++.
Classes.
Summary.
Exercises.

13. Input/Output and Files.
The Output Function printf().
The Input Function scanf().
Directives in the Control String.
Ordinary Characters.
White Space Characters.
Conversion Specifications.
Floating Numbers in the Input Stream.
Using the Scan Set.
The Return Value.
A scanf() Example.
The functions sprintf() and sscanf().
The functions fprintf() and fscanf().
Accessing Files.
An Example: Double-Spacing a File.
Using Temporary Files and Graceful Functions.
Accessing a File Randomly.
Style.
Common Programming Errors.
The Function sscanf() Is Different.
System Considerations.
Moving to C++.
Summary.
Exercises.

14. Software Tools.
Executing Commands From Within a C Program.
Environment Variables.
The C Compiler.
Creating a Library.
Using the Profiler.
How to Time C Code.
The Use of dbx.
The Use of make.
The Use of touch.
Other Useful Tools.
Style.
Common Programming Errors.
System Considerations.
Summary.
Exercises.

15. From C to C++.
Object-Oriented Programming.
Why Switch to C++?
Classes and Abstract Data Types.
Overloading.
Constructors and Destructors.
Inheritance.
Polymorphism.
Templates.
C++ Exceptions.
Benefits Of Object-Oriented Programming.
Style.
Common Programming Errors.
System Considerations.
Summary.
Exercises.

15. From C To C++.
Output.
Input.
Classes and Abstract Data Types.
Overloading.
Constructors and Destructors.
Object-oriented Programming and Inheritance.
Style.
Common Programming Errors.
System Considerations.
Summary.
Exercises.

Appendix A: The Standard Library.
A.1. Diagnostics: assert.h.
A.2. Character Handling: ype.h.
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 Definition: <>.
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.
Using File Descriptors.
Creating a Concurrent Process.
Overlaying a Process.
Interprocess Communication.
Suspending Program Execution.

Appendix B: The Preprocessor.
B.1. The Use of #include.
B.2. The Use of #define.
Syntactic Sugar.
B.3. Macros With Arguments.
B.4. The Use of #undef.
B.5. Conditional Compilation.
B.6. Predefined Macros.
B.7. The Operators # and ##.
B.8. The assert() Macro.
B.9. The Use of #error and #pragma.
B.10. Line Numbers.
B.11. Corresponding Functions.

Appendix C: Bitwise Operators.
C.1. Bitwise Operators and Expressions.
Bitwise Complement.
Two's Complement.
Bitwise Binary Logical Operators.
Left- and Right-Shift Operators.
C.2. Masks.
C.3. Printing an int Bitwise.
C.4. Packing and Unpacking.
C.5. Common Programming Errors.
C.6. System Considerations.
Summary.
Exercises.

Appendix D: ANSI C Compared To Traditional C.
D.1. Types.
D.2. Constants.
D.3. Declarations.
D.4. Initializations.
D.5. Expressions.
D.6. Functions.
D.7. Conversions.
D.8. Array Pointers.
D.9. Structures and Unions.
D.10. Preprocessor.
D.11. Header Files.
D.12. Miscellaneous.

Appendix E: ASCII Character Codes.
Appendix F: Operator Precedence and Associativity.

Customer Reviews

Most Helpful Customer Reviews

See All Customer Reviews