Tài liệu Practical C Programming P1 doc

0
　
　
　







Ｐｒａｃｔｉｃａｌ　Ｃ　Ｐｒｏｇｒａｍｍｉｎｇ，　３ｒｄ　Ｅｄｉｔｉｏｎ　　
Ｂｙ　Ｓｔｅｖｅ　Ｏｕａｌｌｉｎｅ　
３ｒｄ　Ｅｄｉｔｉｏｎ　Ａｕｇｕｓｔ　１９９７　
ＩＳＢＮ：　１－５６５９２－３０６－５　
This new edition of "Practical C Programming" teaches users not only the mechanics or
programming, but also how to create programs that are easy to read, maintain, and
debug. It features more extensive examples and an introduction to graphical
development environments. Programs conform to ANSI C.

TEAM FLY PRESENTS
1
Table of Contents
Preface
How This Book is Organized
Chapter by Chapter
Notes on the Third Edition
Font Conventions

Obtaining Source Code
Comments and Questions
Acknowledgments
Acknowledgments to the Third Edition
I. Basics
1. What Is C?
How Programming Works
Brief History of C
How C Works
How to Learn C
2. Basics of Program Writing
Programs from Conception to Execution
Creating a Real Program
Creating a Program Using a Command-Line Compiler
Creating a Program Using an Integrated Development Environment
Getting Help on UNIX
Getting Help in an Integrated Development Environment
IDE Cookbooks
Programming Exercises
3. Style
Common Coding Practices
Coding Religion
Indentation and Code Format
Clarity
Simplicity
Summary
4. Basic Declarations and Expressions
Elements of a Program
Basic Program Structure
Simple Expressions

Variables and Storage

TEAM FLY PRESENTS
2
Variable Declarations
Integers
Assignment Statements
printf Function
Floating Point
Floating Point Versus Integer Divide
Characters
Answers
Programming Exercises
5. Arrays, Qualifiers, and Reading Numbers
Arrays
Strings
Reading Strings
Multidimensional Arrays
Reading Numbers
Initializing Variables
Types of Integers
Types of Floats
Constant Declarations
Hexadecimal and Octal Constants
Operators for Performing Shortcuts
Side Effects
++x or x++

More Side-Effect Problems
Answers
Programming Exercises
6. Decision and Control Statements

if Statement
else Statement
How Not to Use strcmp
Looping Statements
while Statement
break Statement
continue Statement
Assignment Anywhere Side Effect
Answer
Programming Exercises
7. Programming Process
Setting Up
Specification

TEAM FLY PRESENTS
3
Code Design
Prototype
Makefile
Testing
Debugging
Maintenance

Revisions
Electronic Archaeology
Marking Up the Program
Using the Debugger
Text Editor as a Browser
Add Comments
Programming Exercises
II. Simple Programming
8. More Control Statements
for Statement
switch Statement
switch, break, and continue
Answers
Programming Exercises
9. Variable Scope and Functions
Scope and Class
Functions
Functions with No Parameters
Structured Programming
Recursion
Answers
Programming Exercises
10. C Preprocessor
#define Statement
Conditional Compilation
include Files
Parameterized Macros
Advanced Features
Summary
Answers

Programming Exercises
11. Bit Operations
Bit Operators
The and Operator (&)

TEAM FLY PRESENTS
4
Bitwise or (|)
The Bitwise Exclusive or (^)
The Ones Complement Operator (Not) (~)
The Left- and Right-Shift Operators (<<, >>)
Setting, Clearing, and Testing Bits
Bitmapped Graphics
Answers
Programming Exercises
12. Advanced Types
Structures
Unions
typedef
enum Type
Casting
Bit Fields or Packed Structures
Arrays of Structures
Summary
Programming Exercises
13. Simple Pointers
Pointers as Function Arguments

const Pointers
Pointers and Arrays
How Not to Use Pointers
Using Pointers to Split a String
Pointers and Structures
Command-Line Arguments
Programming Exercises
Answers
14. File Input/Output
Conversion Routines
Binary and ASCII Files
The End-of-Line Puzzle
Binary I/O
Buffering Problems
Unbuffered I/O
Designing File Formats
Answers
Programming Exercises
15. Debugging and Optimization
Debugging
Interactive Debuggers

TEAM FLY PRESENTS
5
Debugging a Binary Search
Runtime Errors
The Confessional Method of Debugging

Optimization
Answers
Programming Exercises
16. Floating Point
Floating-Point Format
Floating Addition/Subtraction
Multiplication
Division
Overflow and Underflow
Roundoff Error
Accuracy
Minimizing Roundoff Error
Determining Accuracy
Precision and Speed
Power Series
Programming Exercises
III. Advanced Programming Concepts
17. Advanced Pointers
Pointers and Structures
free Function
Linked List
Structure Pointer Operator
Ordered Linked Lists
Double-Linked Lists
Trees
Printing a Tree
Rest of Program
Data Structures for a Chess Program
Answers
Programming Exercises

18. Modular Programming
Modules
Public and Private
The extern Modifier
Headers
The Body of the Module
A Program to Use Infinite Arrays

TEAM FLY PRESENTS
6
The Makefile for Multiple Files
Using the Infinite Array
Dividing a Task into Modules
Module Division Example: Text Editor
Compiler
Spreadsheet
Module Design Guidelines
Programming Exercises
19. Ancient Compilers
K&R-Style Functions
Library Changes
Missing Features
Free/Malloc Changes
lint
Answers
20. Portability Problems
Modularity

Word Size
Byte Order Problem
Alignment Problem
NULL Pointer Problem
Filename Problems
File Types
Summary
Answers
21. C's Dustier Corners
do/while
goto
The ?: Construct
The , Operator
volatile Qualifier
Answer
22. Putting It All Together
Requirements
Specification
Code Design
Coding
Functional Description

TEAM FLY PRESENTS
7

Expandability
Testing

Revisions
A Final Warning
Program Files
Programming Exercises
23. Programming Adages
General
Design
Declarations
switch Statement
Preprocessor
Style
Compiling
Final Note
Answer
IV. Other Language Features
A. ASCII Table
B. Ranges and Parameter Passing Conversions
C. Operator Precedence Rules
D. A Program to Compute a Sine Using a Power Series
Glossary
Index

TEAM FLY PRESENTS
8

Preface
This book is devoted to practical C programming. C is currently the

premier language for software developers. That's because it's widely
distributed and standard. Newer languages are available, such as
C++, but these are still evolving. C is still the language of choice for
robust, portable programming.
This book emphasizes the skills you will need to do real-world
programming. It teaches you not only the mechanics of the C
language, but the entire life cycle of a C program as well (including the
program's conception, design, code, methods, debugging, release,
documentation, maintenance, and revision).
Good style is emphasized. To create a good program yo u must do
more than just type in code. It is an art in which writing and
programming skills blend themselves together to form a masterpiece.
True art can be created. A well-written program not only functions
correctly, but is simple and easy to understand. Comments allow the
programmer to include descriptive text inside the program. When
clearly written, a commented program is highly prized.
A program should be as simple as possible. A programmer should
avoid clever tricks. This book stresses simple, practical rules. For
example, there are 15 operator precedence rules in C. These can be
simplified into two rules:
1. Multiply and divide come before add and subtract.
2. Put parentheses around everything else.
Consider two programs. One was written by a clever programmer
using all the tricks. The program contains no comments, but it works.
The other program is well commented and nicely structured, but it
doesn't work. Which program is more useful? In the long run, the
broken one. It can be fixed. Although the clever program works now,
sooner or later all programs have to be modified. The worst thing that
you will ever have to do is to modify a cleverly written program.
This handbook is written for people with no previous programming

experience or programmers who already know C and want to improve
their style and reliability. You should have access to a computer and

TEAM FLY PRESENTS
9
know how to use the basic functions such as a text editor and the
filesystem.
Specific instructions are given for producing and running programs
using the UNIX operating system with a generic cc compiler or the
Free Software Foundation's gcc compiler. For MS-DOS/Windows users,
instructions are included for Borland C++, Turbo C++, and Microsoft
Visual C++. (These compilers compile both C and C++ code.) The
book also gives examples of using the programming utility make for
automated program production.
How This Book is Organized
You must crawl before you walk. In Part I we teach you how to crawl.
These chapters enable you to write very simple programs. We start
with the mechanics of programming and programming style. Next,
you learn how to use variables and very simple decision and control
statements. In Chapter 7, we take you on a complete tour of the
software life cycle to show you how real programs are created.
Part II describes all of the other simple statements and operators that
are used in programming. You'll also learn how to organize these
statements into simple functions.
In Part III we take our basic declarations and statements and learn
how they can be used in the construction of advanced types such as
structures, unions, and classes. We'll also introduce the concept of

pointers. Finally, a number of miscellaneous features are described
Part IV .
Chapter by Chapter
Chapter 1 gives a brief description of the C language and its use. This chapter
includes some background on the history of the language.
Chapter 2 explains the basic programming process and gives you enough
information to write a very simple program.
Chapter 3 discusses programming style. Commenting a program is covered, as well
as writing clear and simple code.

TEAM FLY PRESENTS
10
Chapter 4 introduces you to simple C statements. Basic variables and the
assignment statement are covered in detail, along with arithmetic operators +, -, *,
/, and %.
Chapter 5 covers arrays and more complex variables. Shorthand operators such as
++ and %= are also described.
Chapter 6 explains simple decision statements including if, else, and for. A
discussion of == versus = is presented.
Chapter 7 takes you through all the necessary steps to create a simple program
from specification through release. Structured programming, fast prototyping, and
debugging are also discussed.
Chapter 8 describes additional control statements. Included are while, break, and
continue. The switch statement is discussed in detail.
Chapter 9 introduces local variables, functions, and parameters.
Chapter 10 describes the C preprocessor, which gives the programmer tremendous
flexibility in writing code. The chapter also provides the programmer with a

tremendous number of ways to mess up. Simple rules that help keep the
preprocessor from becoming a problem are described.
Chapter 11 discusses the logical C operators that work on bits.
Chapter 12 explains structures and other advanced types. The sizeof operator and
the enum type are included.
Chapter 13 introduces C pointer variables and shows some of their uses.
Chapter 14 describes both buffered and unbuffered input/output. ASCII and binary
files are discussed, and you are shown how to construct a simple file.
Chapter 15 describes how to debug a program, as well as how to use an interactive
debugger. You are shown not only how to debug a program, but also how to write a
program so that it is easy to debug. This chapter also describes many optimization
techniques for making your program run faster and more efficiently.
Chapter 16 uses a simple decimal floating-point format to introduce you to the
problems inherent in floating point, such as roundoff error, precision loss, overflow,
and underflow.
Chapter 17 describes advanced uses of pointers for constructing dynamic structures
such as linked lists and trees.

TEAM FLY PRESENTS
11
Chapter 18 shows how to split a program into several files and use modular
programming techniques. The make utility is explained in more detail.
Chapter 19 describes the old, pre-ANSI C language and associated compilers.
Although such compilers are rare today, a lot of code was written for them and there
are still a large number of programs out there that use the old syntax.
Chapter 20 describes the problems that can occur when you port a program (move
it from one machine to another).

Chapter 21 describes the do/while statement, the , operator, and the ? and :
operators.
Chapter 22 details the steps necessary to take a complex program from conception
to completion. Information-hiding and modular programming techniques are
emphasized.
Chapter 23 lists some programming adages that will help you construct good C
programs.
Appendix A lists the octal, hexadecimal, and decimal representations of the ASCII
character set that is now in almost universal use.
Appendix B lists the limits you can expect to come up against in handling numbers
with various sizes of memory allocation.
Appendix C lists those impossible-to-remember rules, to help you when you
encounter code written by rude people who didn't use enough parentheses.
Appendix D, illustrates the manipulation of floating-point (real) numbers, which did
not receive complete attention in the rest of the book.
The Appendix A defines many of the technical terms used throughout the book.
Computer languages are best learned by writing and debugging programs.
Sweating over a broken program at 2:00 in the morning only to find you typed "="
where you should have typed "= =" is a very effective learning experience. There
are many programming examples used throughout this book. Some examples don't
work as expected and are posed as questions for the reader to solve. You are
encouraged to enter each into your computer, run the program, and debug it. These
exercises will introduce you to common errors in short programs so that you will
know how to spot and correct them in larger programs of your own. You will find
answers to questions at the end of each chapter. Also, at the end of many chapters,
you will find a section called "Programming Exercises." These sections contain

TEAM FLY PRESENTS