C Primer Plus

by Prata, Stephen

• ISBN13: 9780672326967
• ISBN10: 0672326965
• Edition: 5th
• Format: Paperback
• Copyright: 2004-11-23
• Publisher: Sams Publishing

Summary

A lean revision of a computer industry classic that has sold over 500,000 copies in previous editions.

Author Biography

Stephen Prata teaches astronomy, physics, and programming at the College of Marin in Kentfield, California. He received his B.S. from the California Institute of Technology and his Ph.D. from the University of California, Berkeley. His association with computers began with the computer modeling of star clusters. Stephen has authored or coauthored over a dozen books, including C++ Primer Plus and Unix Primer Plus.

Table of Contents

Getting Ready	1	(22)
Whence C?	1	(1)
Why C?	2	(2)
Design Features	2	(1)
Efficiency	2	(1)
Portability	3	(1)
Power and Flexibility	3	(1)
Programmer Oriented	3	(1)
Shortcomings	4	(1)
Whither C?	4	(1)
What Computers Do	5	(1)
High-level Computer Languages and Compilers	6	(1)
Using C: Seven Steps	7	(3)
Step 1: Define the Program Objectives	8	(1)
Step 2: Design the Program	8	(1)
Step 3: Write the Code	8	(1)
Step 4: Compile	9	(1)
Step 5: Run the Program	9	(1)
Step 6: Test and Debug the Program	9	(1)
Step 7: Maintain and Modify the Program	10	(1)
Commentary	10	(1)
Programming Mechanics	10	(7)
Object Code Files, Executable Files, and Libraries	11	(2)
Unix System	13	(1)
Linux System	14	(1)
Integrated Development Environments (Windows)	15	(1)
DOS Compilers for the IBM PC	16	(1)
C on the Macintosh	17	(1)
Language Standards	17	(2)
The First ANSI/ISO C Standard	17	(1)
The C99 Standard	18	(1)
How This Book Is Organized	19	(1)
Conventions Used in This Book	19	(3)
Typeface	19	(1)
Program Output	20	(1)
Special Elements	21	(1)
Summary	22	(1)
Review Questions	22	(1)
Programming Exercise	22	(1)
Introducing C	23	(26)
A Simple Example of C	23	(1)
The Example Explained	24	(11)
Pass 1: Quick Synopsis	24	(2)
Pass 2: Program Details	26	(9)
The Structure of a Simple Program	35	(1)
Tips on Making Your Programs Readable	36	(1)
Taking Another Step in Using C	37	(1)
Documentation	37	(1)
Multiple Declarations	38	(1)
Multiplication	38	(1)
Printing Multiple Values	38	(1)
While You're at It---Multiple Functions	38	(2)
Introducing Debugging	40	(3)
Syntax Errors	41	(1)
Semantic Errors	41	(1)
Program State	42	(1)
Keywords and Reserved Identifiers	43	(1)
Key Concepts	44	(1)
Summary	45	(1)
Review Questions	45	(2)
Programming Exercises	47	(2)
Data and C	49	(40)
A Sample Program	49	(3)
What's New in This Program?	51	(1)
Data Variables and Constants	52	(1)
Data: Data-Type Keywords	52	(3)
Integer Versus Floating-Point Types	54	(1)
The Integer	54	(1)
The Floating-Point Number	54	(1)
Basic C Data Types	55	(25)
The int Type	55	(4)
Other Integer Types	59	(5)
Using Characters: Type char	64	(6)
The_Bool Type	70	(1)
Portable Types: inttypes.h	70	(2)
Types float, double, and long double	72	(4)
Complex and Imaginary Types	76	(1)
Beyond the Basic Types	77	(2)
Type Sizes	79	(1)
Using Data Types	80	(1)
Arguments and Pitfalls	81	(2)
One More Example: Escape Sequences	83	(2)
What Happens When the Program Runs	83	(1)
Flushing the Output	84	(1)
Key Concepts	85	(1)
Summary	85	(1)
Review Questions	86	(2)
Programming Exercises	88	(1)
Character Strings and Formatted Input/Output	89	(40)
Introductory Program	89	(2)
Character Strings: An Introduction	91	(4)
Type char Arrays and the Null Character	91	(1)
Using Strings	92	(1)
The strlen() Function	93	(2)
Constants and the C Preprocessor	95	(6)
The const Modifier	98	(1)
Manifest Constants on the Job	98	(3)
Exploring and Exploiting printf () and scanf()	101	(22)
The printf() Function	101	(1)
Using printf()	102	(2)
Conversion Specification Modifiers for printf()	104	(6)
What Does a Conversion Specification Convert?	110	(6)
Using scanf()	116	(4)
The * Modifier with printf() and scanf()	120	(2)
Usage Tips for printf()	122	(1)
Key Concepts	123	(1)
Summary	124	(1)
Review Questions	124	(3)
Programming Exercises	127	(2)
Operators, Expressions, and Statements	129	(40)
Introducing Loops	129	(3)
Fundamental Operators	132	(9)
Assignment Operator: =	132	(2)
Addition Operator: +	134	(1)
Subtraction Operator: -	134	(1)
Sign Operators: - and +	134	(1)
Multiplication Operator: *	135	(2)
Division Operator: /	137	(1)
Operator Precedence	138	(2)
Precedence and the Order of Evaluation	140	(1)
Some Additional Operators	141	(9)
The sizeof Operator and the size_t Type	142	(1)
Modulus Operator: %	142	(2)
Increment and Decrement Operators: ++ and - -	144	(4)
Decrementing: - -	148	(1)
Precedence	149	(1)
Don't Be Too Clever	149	(1)
Expressions and Statements	150	(6)
Expressions	150	(1)
Statements	151	(3)
Compound Statements (Blocks)	154	(2)
Type Conversions	156	(3)
The Cast Operator	158	(1)
Function with Arguments	159	(2)
A Sample Program	161	(2)
Key Concepts	163	(1)
Summary	163	(1)
Review Questions	164	(3)
Programming Exercises	167	(2)
C Control Statements: Looping	169	(52)
Revisiting the while Loop	170	(2)
Program Comments	170	(2)
C-Style Reading Loop	172	(1)
The while Statement	172	(4)
Terminating a while Loop	173	(1)
When a Loop Terminates	174	(1)
while: An Entry-Condition Loop	174	(1)
Syntax Points	175	(1)
Which Is Bigger: Using Relational Operators and Expressions	176	(10)
What Is Truth?	178	(1)
What Else Is True?	179	(1)
Troubles with Truth	180	(2)
The New_Bool Type	182	(1)
Precedence of Relational Operators	183	(3)
Indefinite Loops and Counting Loops	186	(1)
The for Loop	187	(6)
Using for for Flexibility	188	(5)
More Assignment Operators: +=, -=, *=, /=, %=	193	(1)
The Comma Operator	193	(5)
Zeno Meets the for Loop	196	(2)
An Exit-Condition Loop: do while	198	(3)
Which Loop?	201	(1)
Nested Loops	201	(2)
Program Discussion	202	(1)
A Nested Variation	202	(1)
Introducing Arrays	203	(4)
Using a for Loop with an Array	205	(2)
A Loop Example Using a Function Return Value	207	(4)
Program Discussion	209	(1)
Using Functions with Return Values	210	(1)
Key Concepts	211	(1)
Summary	211	(1)
Review Questions	212	(5)
Programming Exercises	217	(4)
C Control Statements: Branching and Jumps	221	(50)
The if Statement	222	(2)
Adding else to the if Statement	224	(14)
Another Example: Introducing getchar() and putchar()	225	(3)
The ctype. h Family of Character Functions	228	(2)
Multiple Choice else if	230	(3)
Pairing else with if	233	(1)
More Nested ifs	234	(4)
Let's Get Logical	238	(4)
Alternate Spellings: The iso646.h Header File	239	(1)
Precedence	240	(1)
Order of Evaluation	240	(2)
Ranges	242	(1)
A Word-Count Program	242	(4)
The Conditional Operator: ?:	246	(2)
Loop Aids: continue and break	248	(5)
The continue Statement	248	(3)
The break Statement	251	(2)
Multiple Choice: switch and break	253	(6)
Using the switch Statement	255	(1)
Reading Only the First Character of a Line	256	(1)
Multiple Labels	257	(2)
switch and if else	259	(1)
The goto Statement	259	(4)
Avoiding goto	260	(3)
Key Concepts	263	(1)
Summary	263	(1)
Review Questions	264	(3)
Programming Exercises	267	(4)
Character Input/Output and Input Validation	271	(32)
Single-Character I/O: getchar() and putchar()	272	(1)
Buffers	273	(1)
Terminating Keyboard Input	274	(4)
Files, Streams, and Keyboard Input	274	(1)
The End of File	275	(3)
Redirection and Files	278	(5)
Unix, Linux, and DOS Redirection	279	(4)
Creating a Friendlier User Interface	283	(5)
Working with Buffered Input	283	(2)
Mixing Numeric and Character Input	285	(3)
Input Validation	288	(5)
Analyzing the Program	292	(1)
The Input Stream and Numbers	293	(1)
Menu Browsing	293	(6)
Tasks	294	(1)
Toward a Smoother Execution	294	(2)
Mixing Character and Numeric Input	296	(3)
Key Concepts	299	(1)
Summary	299	(1)
Review Questions	300	(1)
Programming Exercises	301	(2)
Functions	303	(44)
Reviewing Functions	303	(13)
Creating and Using a Simple Function	304	(1)
Analyzing the Program	305	(3)
Function Arguments	308	(1)
Defining a Function with an Argument: Formal Parameters	309	(1)
Prototyping a Function with Arguments	310	(1)
Calling a Function with an Argument: Actual Arguments	311	(1)
The Black-Box Viewpoint	311	(1)
Returning a Value from a Function with return	312	(3)
Function Types	315	(1)
ANSI C Function Prototyping	316	(4)
The Problem	316	(2)
The ANSI Solution	318	(1)
No Arguments and Unspecified Arguments	319	(1)
Hooray for Prototypes	320	(1)
Recursion	320	(8)
Recursion Revealed	320	(2)
Recursion Fundamentals	322	(1)
Tail Recursion	323	(2)
Recursion and Reversal	325	(2)
Recursion Pros and Cons	327	(1)
Compiling Programs with Two or More Source Code Files	328	(5)
Unix	328	(1)
Linux	328	(1)
DOS Command-Line Compilers	329	(1)
Windows and Macintosh Compilers	329	(1)
Using Header Files	329	(4)
Finding Addresses: The & Operator	333	(1)
Altering Variables in the Calling Function	334	(2)
Pointers: A First Look	336	(7)
The Indirection Operator: *	337	(1)
Declaring Pointers	338	(1)
Using Pointers to Communicate Between Functions	339	(4)
Key Concepts	343	(1)
Summary	343	(1)
Review Questions	343	(2)
Programming Exercises	345	(2)
Arrays and Pointers	347	(52)
Arrays	347	(9)
Initialization	348	(4)
Designated Initializers (C99)	352	(1)
Assigning Array Values	353	(1)
Array Bounds	354	(1)
Specifying an Array Size	355	(1)
Multidimensional Arrays	356	(5)
Initializing a Two-Dimensional Array	359	(1)
More Dimensions	360	(1)
Pointers and Arrays	361	(3)
Functions, Arrays, and Pointers	364	(5)
Using Pointer Parameters	366	(3)
Comment: Pointers and Arrays	369	(1)
Pointer Operations	369	(5)
Protecting Array Contents	374	(4)
Using const with Formal Parameters	374	(2)
More About const	376	(2)
Pointers and Multidimensional Arrays	378	(8)
Pointers to Multidimensional Arrays	381	(1)
Pointer Compatibility	382	(1)
Functions and Multidimensional Arrays	383	(3)
Variable-Length Arrays (VLAs)	386	(4)
Compound Literals	390	(3)
Key Concepts	393	(1)
Summary	393	(2)
Review Questions	395	(2)
Programming Exercises	397	(2)
Character Strings and String Functions	399	(54)
Representing Strings and String I/O	399	(10)
Defining Strings Within a Program	401	(6)
Pointers and Strings	407	(2)
String Input	409	(5)
Creating Space	409	(1)
The gets() Function	410	(2)
The fgets() Function	412	(1)
The scanf() Function	413	(1)
String Output	414	(3)
The puts() Function	415	(1)
The fputs() Function	416	(1)
The printf() Function	417	(1)
The Do-It-Yourself Option	417	(3)
String Functions	420	(16)
The strlen() Function	420	(1)
The strcat() Function	421	(1)
The strncat() Function	422	(1)
The strcmp() Function	423	(4)
The strncmp() Variation	427	(1)
The strcpy() and strncpy() Functions	428	(5)
The sprintf() Function	433	(1)
Other String Functions	434	(2)
A String Example: Sorting Strings	436	(3)
Sorting Pointers Instead of Strings	437	(1)
The Selection Sort Algorithm	438	(1)
The ctype.h Character Functions and Strings	439	(2)
Command-Line Arguments	441	(3)
Command-Line Arguments in Integrated Environments	443	(1)
Command-Line Arguments with the Macintosh	443	(1)
String-to-Number Conversions	444	(2)
Key Concepts	446	(1)
Summary	447	(1)
Review Questions	448	(3)
Programming Exercises	451	(2)
Storage Classes, Linkage, and Memory Management	453	(46)
Storage Classes	453	(16)
Scope	454	(1)
Linkage	455	(1)
Storage Duration	456	(1)
Automatic Variables	457	(4)
Register Variables	461	(1)
Static Variables with Block Scope	461	(2)
Static Variables with External Linkage	463	(5)
Static Variables with Internal Linkage	468	(1)
Multiple Files	468	(1)
Storage-Class Specifiers	469	(2)
Storage Classes and Functions	471	(1)
Which Storage Class?	472	(1)
A Random-Number Function and a Static Variable	472	(4)
Roll 'Em	476	(4)
Allocated Memory: malloc() and free()	480	(6)
The Importance of free()	483	(1)
The calloc() Function	484	(1)
Dynamic Memory Allocation and Variable-Length Arrays	485	(1)
Storage Classes and Dynamic Memory Allocation	486	(1)
ANSI C Type Qualifiers	486	(6)
The const Type Qualifier	486	(3)
The volatile Type Qualifier	489	(1)
The restrict Type Qualifier	490	(1)
New Places for Old Keywords	491	(1)
Key Concepts	492	(1)
Summary	492	(1)
Review Questions	493	(2)
Programming Exercises	495	(4)
File Input/Output	499	(36)
Communicating with Files	499	(3)
What Is a File?	500	(1)
The Text View and the Binary View	500	(1)
Levels of I/O	501	(1)
Standard Files	501	(1)
Standard I/O	502	(5)
Checking for Command-Line Arguments	503	(1)
The fopen() Function	504	(1)
The getc() and putc() Functions	505	(1)
End-of-File	505	(2)
The fclose() Function	507	(1)
Pointers to the Standard Files	507	(1)
A Simple-Minded File-Condensing Program	507	(2)
File I/O: fprintf(), fscanf(), fgets(), and fputs()	509	(4)
The fprintf() and fscanf() Functions	509	(2)
The fgets() and fputs() Functions	511	(2)
Commentary: gets() and fgets()	513	(1)
Adventures in Random Access: fseek() and ftell()	513	(4)
How fseek() and ftell() Work	514	(2)
Binary Versus Text Mode	516	(1)
Portability	516	(1)
The fgetpos() and fsetpos() Functions	517	(1)
Behind the Scenes with Standard I/O	517	(1)
Other Standard I/O Functions	518	(9)
The int ungetc(int c, FILE *fp) Function	519	(1)
The int fflush() Function	519	(1)
The int setvbuf() Function	519	(1)
Binary I/O: fread() and fwrite()	520	(1)
The size_t fwrite() Function	521	(1)
The size_t fread() Function	522	(1)
The int feof (FILE *fp) and int ferror(FILE *fp) Functions	522	(1)
An fread() and fwrite() Example	523	(2)
Random Access with Binary I/O	525	(2)
Key Concepts	527	(1)
Summary	528	(1)
Review Questions	529	(1)
Programming Exercises	530	(5)
Structures and Other Data Forms	535	(62)
Sample Problem: Creating an Inventory of Books	535	(2)
Setting Up the Structure Declaration	537	(1)
Defining a Structure Variable	538	(3)
Initializing a Structure	539	(1)
Gaining Access to Structure Members	540	(1)
Designated Initializers for Structures	540	(1)
Arrays of Structures	541	(4)
Declaring an Array of Structures	543	(1)
Identifying Members of an Array of Structures	543	(1)
Program Discussion	544	(1)
Nested Structures	545	(2)
Pointers to Structures	547	(3)
Declaring and Initializing a Structure Pointer	548	(1)
Member Access by Pointer	549	(1)
Telling Functions About Structures	550	(16)
Passing Structure Members	550	(1)
Using the Structure Address	551	(1)
Passing a Structure as an Argument	552	(1)
More on Structure Features	553	(4)
Structures or Pointer to Structures?	557	(1)
Character Arrays or Character Pointers in a Structure	558	(1)
Structure, Pointers, and malloc()	559	(2)
Compound Literals and Structures (C99)	561	(1)
Flexible Array Members (C99)	562	(3)
Functions Using an Array of Structures	565	(1)
Saving the Structure Contents in a File	566	(5)
A Structure-Saving Example	567	(3)
Program Points	570	(1)
Structures: What Next?	571	(1)
Unions: A Quick Look	572	(3)
Enumerated Types	575	(3)
enum Constants	575	(1)
Default Values	576	(1)
Assigned Values	576	(1)
enum Usage	576	(2)
Shared Namespaces	578	(1)
typedef: A Quick Look	578	(2)
Fancy Declarations	580	(2)
Functions and Pointers	582	(7)
Key Concepts	589	(1)
Summary	589	(1)
Review Questions	590	(3)
Programming Exercises	593	(4)
Bit Fiddling	597	(32)
Binary Numbers, Bits, and Bytes	597	(3)
Binary Integers	598	(1)
Signed Integers	599	(1)
Binary Floating Point	599	(1)
Other Number Bases	600	(2)
Octal	600	(1)
Hexadecimal	601	(1)
C's Bitwise Operators	602	(10)
Bitwise Logical Operators	602	(2)
Usage: Masks	604	(1)
Usage: Turning Bits On	605	(1)
Usage: Turning Bits Off	605	(1)
Usage: Toggling Bits	606	(1)
Usage: Checking the Value of a Bit	606	(1)
Bitwise Shift Operators	606	(2)
Programming Example	608	(2)
Another Example	610	(2)
Bit Fields	612	(12)
Bit-Field Example	614	(3)
Bit Fields and Bitwise Operators	617	(7)
Key Concepts	624	(1)
Summary	624	(1)
Review Questions	625	(2)
Programming Exercises	627	(2)
The C Preprocessor and the C Library	629	(52)
First Steps in Translating a Program	630	(1)
Manifest Constants: #define	630	(5)
Tokens	634	(1)
Redefining Constants	635	(1)
Using Arguments with #define	635	(6)
Creating Strings from Macro Arguments: The # Operator	638	(1)
Preprocessor Glue: The ## Operator	639	(1)
Variadic Macros: ... and _ _VA_ARGS_ _	640	(1)
Macro or Function?	641	(1)
File Inclusion: #include	642	(5)
Header Files: An Example	643	(3)
Uses for Header Files	646	(1)
Other Directives	647	(8)
The #undef Directive	647	(1)
Being Defined---The C Preprocessor Perspective	647	(1)
Conditional Compilation	648	(5)
Predefined Macros	653	(1)
#line and #error	654	(1)
#pragma	654	(1)
Inline Functions	655	(3)
The C Library	658	(2)
Gaining Access to the C Library	658	(1)
Using the Library Descriptions	659	(1)
The Math Library	660	(3)
The General Utilities Library	663	(7)
The exit() and atexit () Functions	663	(2)
The qsort() Function	665	(5)
The Assert Library	670	(2)
memcpy() and memmove() from the string.h Library	672	(2)
Variable Arguments: stdarg.h	674	(2)
Key Concepts	676	(1)
Summary	677	(1)
Review Questions	677	(1)
Programming Exercises	678	(3)
Advanced Data Representation	681	(78)
Exploring Data Representation	682	(2)
Beyond the Array to the Linked List	684	(8)
Using a Linked List	687	(4)
Afterthoughts	691	(1)
Abstract Data Types (ADTs)	692	(16)
Getting Abstract	693	(1)
Building an Interface	694	(5)
Using the Interface	699	(2)
Implementing the Interface	701	(7)
Getting Queued with an ADT	708	(13)
Defining the Queue Abstract Data Type	708	(1)
Defining an Interface	709	(1)
Implementing the Interface Data Representation	710	(9)
Testing the Queue	719	(2)
Simulating with a Queue	721	(5)
The Linked List Versus the Array	726	(4)
Binary Search Trees	730	(26)
A Binary Tree ADT	731	(1)
The Binary Search Tree Interface	732	(2)
The Binary Tree Implementation	734	(16)
Trying the Tree	750	(4)
Tree Thoughts	754	(2)
Other Directions	756	(1)
Key Concepts	756	(1)
Summary	757	(1)
Review Questions	757	(1)
Programming Exercises	758	(1)
APPENDIX A Answers to the Review Questions	759	(40)
Answers to Review Questions for Chapter 1	759	(1)
Answers to Review Questions for Chapter 2	760	(1)
Answers to Review Questions for Chapter 3	761	(3)
Answers to Review Questions for Chapter 4	764	(3)
Answers to Review Questions for Chapter 5	767	(3)
Answers to Review Questions for Chapter 6	770	(3)
Answers to Review Questions for Chapter 7	773	(3)
Answers to Review Questions for Chapter 8	776	(1)
Answers to Review Questions for Chapter 9	777	(2)
Answers to Review Questions for Chapter 10	779	(3)
Answers to Review Questions for Chapter 11	782	(3)
Answers to Review Questions for Chapter 12	785	(1)
Answers to Review Questions for Chapter 13	786	(3)
Answers to Review Questions for Chapter 14	789	(3)
Answers to Review Questions for Chapter 15	792	(1)
Answers to Review Questions for Chapter 16	793	(2)
Answers to Review Questions for Chapter 17	795	(4)
APPENDIX B Reference Section	799	(89)
Section I: Additional Reading	799	(3)
Magazine	799	(1)
Online Resources	799	(2)
C Language Books	801	(1)
Programming Books	801	(1)
Reference Books	801	(1)
C++ Books	802	(1)
Section II: C Operators	802	(6)
Arithmetic Operators	803	(1)
Relational Operators	804	(1)
Assignment Operators	804	(1)
Logical Operators	805	(1)
The Conditional Operator	805	(1)
Pointer-Related Operators	806	(1)
Sign Operators	806	(1)
Structure and Union Operators	806	(1)
Bitwise Operators	807	(1)
Miscellaneous Operators	808	(1)
Section III: Basic Types and Storage Classes	808	(5)
Summary: The Basic Data Types	808	(3)
Summary: How to Declare a Simple Variable	811	(1)
Summary: Qualifiers	812	(1)
Section IV: Expressions, Statements, and Program Flow	813	(6)
Summary: Expressions and Statements	813	(1)
Summary: The while Statement	814	(1)
Summary: The for Statement	815	(1)
Summary: The do while Statement	815	(1)
Summary: Using if Statements for Making Choices	816	(1)
Summary: Multiple Choice with switch	817	(1)
Summary: Program Jumps	818	(1)
Section V: The Standard ANSI C Library with C99 Additions	819	(52)
Diagnostics: assert.h	820	(1)
Complex Numbers: complex.h (C99)	820	(2)
Character Handling: ctype.h	822	(1)
Error Reporting: errno.h	823	(1)
Floating-Point Environment: fenv.h (C99)	824	(2)
Format Conversion of Integer Types: inttypes.h (C99)	826	(1)
Localization: locale.h	827	(3)
Math Library: math.h	830	(5)
Non-Local Jumps: setjmp.h	835	(1)
Signal Handling: signal.h	836	(1)
Variable Arguments: stdarg.h	837	(1)
Boolean Support: stdbool.h (C99)	838	(1)
Common Definitions: stddef.h	838	(1)
Integer Types: stdint.h	839	(4)
Standard I/O Library: stdio.h	843	(3)
General Utilities: stdlib.h	846	(7)
String Handling: string.h	853	(4)
Type-Generic Math: tgmath.h (C99)	857	(1)
Date and Time: time.h	857	(4)
Extended Multibyte and Wide-Character Utilities: wchar.h (C99)	861	(7)
Wide Character Classification and Mapping Utilities: wctype.h (C99)	868	(3)
Section VI: Extended Integer Types	871	(4)
Exact-Width Types	872	(1)
Minimum-Width Types	872	(1)
Fastest Minimum-Width Types	873	(1)
Maximum-Width Types	874	(1)
Integers That Can Hold Pointer Values	874	(1)
Extended Integer Constants	874	(1)
Section VII: Expanded Character Support	875	(4)
Trigraph Sequences	875	(1)
Digraphs	876	(1)
Alternative Spellings: iso646.h	876	(1)
Multibyte Characters	877	(1)
Universal Character Names (UCNs)	877	(1)
Wide Characters	878	(1)
Wide Characters and Multibyte Characters	879	(1)
Section VIII: C99 Numeric Computational Enhancements	879	(4)
The IEC Floating-Point Standard	880	(1)
The fenv.h Header File	880	(1)
The STDC FP_Contract Pragma	881	(1)
Additions to the math.h Library	881	(1)
Support for Complex Numbers	882	(1)
Section IX: Differences Between C and C++	883	(5)
Function Prototypes	884	(1)
char Constants	884	(1)
The const Modifier	885	(1)
Structures and Unions	886	(1)
Enumerations	886	(1)
Pointer-to-void	887	(1)
Boolean Types	887	(1)
Alternative Spellings	887	(1)
Wide-Character Support	887	(1)
Complex Types	888	(1)
Inline Functions	888	(1)
C99 Features Not Found in C++	888

Excerpts

C Primer Plus C Primer Plus PrefaceC was a relatively little-known language when the first edition ofC Primer Pluswas written in 1984. Since then, the language has boomed, and many people have learned C with the help of this book. In fact, over 500,000 people have purchasedC Primer Plusthroughout its various editions.As the language has grown from the early informal K&R standard through the 1990 ISO/ANSI standard to the 1999 ISO/ANSI standard, so has this book matured through this, the fifth edition. As with all the editions, my aim has been to create an introduction to C that is instructive, clear, and helpful. Approach and GoalsMy goal is for this book to serve as a friendly, easy-to-use, self-study guide. To accomplish that objective,C Primer Plusemploys the following strategies:Programming concepts are explained, along with details of the C language; the book doesnotassume that you are a professional programmer.Many short, easily typed examples illustrate just one or two concepts at a time, because learning by doing is one of the most effective ways to master new information.Figures and illustrations clarify concepts that are difficult to grasp in words alone.Highlight boxes summarize the main features of C for easy reference and review.Review questions and programming exercises at the end of each chapter allow you to test and improve your understanding of C.To gain the greatest benefit, you should take as active a role as possible in studying the topics in this book. Don't just read the examples, enter them into your system, and try them. C is a very portable language, but you may find differences between how a program works on your system and how it works on ours. Experiment--change part of a program to see what the effect is. Modify a program to do something slightly different. Ignore the occasional warnings and see what happens when you do the wrong thing. Try the questions and exercises. The more you do yourself, the more you will learn and remember.I hope that you'll find this newest edition an enjoyable and effective introduction to the C language. Copyright Pearson Education. All rights reserved.