C Primer Plus, 6th Edition
- By Stephen Prata
- Published Nov 25, 2013 by Addison-Wesley Professional.
eBook
- Your Price: $53.59
- List Price: $66.99
- Includes EPUB and PDF
- About eBook Formats
This eBook includes the following formats, accessible from your Account page after purchase:
EPUB
The open industry format known for its reflowable content and usability on supported mobile devices.
PDF
The popular standard, used most often with the free Acrobat® Reader® software.
This eBook requires no passwords or activation to read. We customize your eBook by discreetly watermarking it with your name, making it uniquely yours.
Also available in other formats.
Register your product to gain access to bonus material or receive a coupon.
Description
- Copyright 2014
- Dimensions: 7" x 9"
- Edition: 6th
- eBook
- ISBN-10: 0-13-343240-8
- ISBN-13: 978-0-13-343240-4
C Primer Plus is a carefully tested, well-crafted, and complete tutorial on a subject core to programmers and developers. This computer science classic teaches principles of programming, including structured code and top-down design.
Author and educator Stephen Prata has created an introduction to C that is instructive, clear, and insightful. Fundamental programming concepts are explained along with details of the C language. Many short, practical examples illustrate just one or two concepts at a time, encouraging readers to master new topics by immediately putting them to use.
Review questions and programming exercises at the end of each chapter bring out the most critical pieces of information and help readers understand and digest the most difficult concepts. A friendly and easy-to-use self-study guide, this book is appropriate for serious students of programming, as well as developers proficient in other languages with a desire to better understand the fundamentals of this core language.
The sixth edition of this book has been updated and expanded to cover the latest developments in C as well as to take a detailed look at the new C11 standard. In C Primer Plus you’ll find depth, breadth, and a variety of teaching techniques and tools to enhance your learning:
- Complete, integrated discussion of both C language fundamentals and additional features
- Clear guidance about when and why to use different parts of the language
- Hands-on learning with concise and simple examples that develop your understanding of a concept or two at a time
- Hundreds of practical sample programs
- Review questions and programming exercises at the end of each chapter to test your understanding
- Coverage of generic C to give you the greatest flexibility
Sample Content
Table of Contents
Preface xxvii
1 Getting Ready 1
Whence C? 1
Why C? 2
Design Features 2
Efficiency 3
Portability 3
Power and Flexibility 3
Programmer Oriented 3
Shortcomings 4
Whither C? 4
What Computers Do 5
High-level Computer Languages and Compilers 6
Language Standards 7
The First ANSI/ISO C Standard 8
The C99 Standard 8
The C11 Standard 9
Using C: Seven Steps 9
Step 1: Define the Program Objectives 10
Step 2: Design the Program 10
Step 3: Write the Code 11
Step 4: Compile 11
Step 5: Run the Program 12
Step 6: Test and Debug the Program 12
Step 7: Maintain and Modify the Program 13
Commentary 13
Programming Mechanics 13
Object Code Files, Executable Files, and Libraries 14
Unix System 16
The GNU Compiler Collection and the LLVM Project 18
Linux Systems 18
Command-Line Compilers for the PC 19
Integrated Development Environments (Windows) 19
The Windows/Linux Option 21
C on the Macintosh 21
How This Book Is Organized 22
Conventions Used in This Book 22
Typeface 22
Program Output 23
Special Elements 24
Summary 24
Review Questions 25
Programming Exercise 25
2 Introducing C 27
A Simple Example of C 27
The Example Explained 28
Pass 1: Quick Synopsis 30
Pass 2: Program Details 31
The Structure of a Simple Program 40
Tips on Making Your Programs Readable 41
Taking Another Step in Using C 42
Documentation 43
Multiple Declarations 43
Multiplication 43
Printing Multiple Values 43
While You’re at It–Multiple Functions 44
Introducing Debugging 46
Syntax Errors 46
Semantic Errors 47
Program State 49
Keywords and Reserved Identifiers 49
Key Concepts 50
Summary 51
Review Questions 51
Programming Exercises 53
3 Data and C 55
A Sample Program 55
What’s New in This Program? 57
Data Variables and Constants 59
Data: Data-Type Keywords 59
Integer Versus Floating-Point Types 60
The Integer 61
The Floating-Point Number 61
Basic C Data Types 62
The int Type 62
Other Integer Types 66
Using Characters: Type char 71
The _Bool Type 77
Portable Types: stdint.h and inttypes.h 77
Types float, double, and long double 79
Complex and Imaginary Types 85
Beyond the Basic Types 85
Type Sizes 87
Using Data Types 88
Arguments and Pitfalls 89
One More Example: Escape Sequences 91
What Happens When the Program Runs 91
Flushing the Output 92
Key Concepts 93
Summary 93
Review Questions 94
Programming Exercises 97
4 Character Strings and Formatted Input/Output 99
Introductory Program 99
Character Strings: An Introduction 101
Type char Arrays and the Null Character 101
Using Strings 102
The strlen() Function 103
Constants and the C Preprocessor 106
The const Modifier 109
Manifest Constants on the Job 109
Exploring and Exploiting printf() and scanf() 112
The printf() Function 112
Using printf() 113
Conversion Specification Modifiers for printf() 115
What Does a Conversion Specification Convert? 122
Using scanf() 128
The * Modifier with printf() and scanf() 133
Usage Tips for printf() 135
Key Concepts 136
Summary 137
Review Questions 138
Programming Exercises 140
5 Operators, Expressions, and Statements 143
Introducing Loops 144
Fundamental Operators 146
Assignment Operator: = 146
Addition Operator: + 149
Subtraction Operator: — 149
Sign Operators: — and + 150
Multiplication Operator: * 151
Division Operator: / 153
Operator Precedence 154
Precedence and the Order of Evaluation 156
Some Additional Operators 157
The sizeof Operator and the size_t Type 158
Modulus Operator: % 159
Increment and Decrement Operators: ++ and -- 160
Decrementing: -- 164
Precedence 165
Don’t Be Too Clever 166
Expressions and Statements 167
Expressions 167
Statements 168
Compound Statements (Blocks) 171
Type Conversions 174
The Cast Operator 176
Function with Arguments 177
A Sample Program 180
Key Concepts 182
Summary 182
Review Questions 183
Programming Exercises 187
6 C Control Statements: Looping 189
Revisiting the while Loop 190
Program Comments 191
C-Style Reading Loop 192
The while Statement 193
Terminating a while Loop 194
When a Loop Terminates 194
while: An Entry-Condition Loop 195
Syntax Points 195
Which Is Bigger: Using Relational Operators and Expressions 197
What Is Truth? 199
What Else Is True? 200
Troubles with Truth 201
The New _Bool Type 203
Precedence of Relational Operators 205
Indefinite Loops and Counting Loops 207
The for Loop 208
Using for for Flexibility 210
More Assignment Operators: +=, -=, *=, /=, %= 215
The Comma Operator 215
Zeno Meets the for Loop 218
An Exit-Condition Loop: do while 220
Which Loop? 223
Nested Loops 224
Program Discussion 225
A Nested Variation 225
Introducing Arrays 226
Using a for Loop with an Array 228
A Loop Example Using a Function Return Value 230
Program Discussion 232
Using Functions with Return Values 233
Key Concepts 234
Summary 235
Review Questions 236
Programming Exercises 241
7 C Control Statements: Branching and Jumps 245
The if Statement 246
Adding else to the if Statement 248
Another Example: Introducing getchar() and putchar() 250
The ctype.h Family of Character Functions 252
Multiple Choice else if 254
Pairing else with if 257
More Nested ifs 259
Let’s Get Logical 263
Alternate Spellings: The iso646.h Header File 265
Precedence 265
Order of Evaluation 266
Ranges 267
A Word-Count Program 268
The Conditional Operator: ?: 271
Loop Aids: continue and break 274
The continue Statement 274
The break Statement 277
Multiple Choice: switch and break 280
Using the switch Statement 281
Reading Only the First Character of a Line 283
Multiple Labels 284
switch and if else 286
The goto Statement 287
Avoiding goto 287
Key Concepts 291
Summary 291
Review Questions 292
Programming Exercises 296
8 Character Input/Output and Input Validation 299
Single-Character I/O: getchar() and putchar() 300
Buffers 301
Terminating Keyboard Input 302
Files, Streams, and Keyboard Input 303
The End of File 304
Redirection and Files 307
Unix, Linux, and Windows Command Prompt Redirection 307
Creating a Friendlier User Interface 312
Working with Buffered Input 312
Mixing Numeric and Character Input 314
Input Validation 317
Analyzing the Program 322
The Input Stream and Numbers 323
Menu Browsing 324
Tasks 324
Toward a Smoother Execution 325
Mixing Character and Numeric Input 327
Key Concepts 330
Summary 331
Review Questions 331
Programming Exercises 332
9 Functions 335
Reviewing Functions 335
Creating and Using a Simple Function 337
Analyzing the Program 338
Function Arguments 340
Defining a Function with an Argument: Formal Parameters 342
Prototyping a Function with Arguments 343
Calling a Function with an Argument: Actual Arguments 343
The Black-Box Viewpoint 345
Returning a Value from a Function with return 345
Function Types 348
ANSI C Function Prototyping 349
The Problem 350
The ANSI C Solution 351
No Arguments and Unspecified Arguments 352
Hooray for Prototypes 353
Recursion 353
Recursion Revealed 354
Recursion Fundamentals 355
Tail Recursion 356
Recursion and Reversal 358
Recursion Pros and Cons 360
Compiling Programs with Two or More Source Code Files 361
Unix 362
Linux 362
DOS Command-Line Compilers 362
Windows and Apple IDE Compilers 362
Using Header Files 363
Finding Addresses: The & Operator 367
Altering Variables in the Calling Function 369
Pointers: A First Look 371
The Indirection Operator: * 371
Declaring Pointers 372
Using Pointers to Communicate Between Functions 373
Key Concepts 378
Summary 378
Review Questions 379
Programming Exercises 380
10 Arrays and Pointers 383
Arrays 383
Initialization 384
Designated Initializers (C99) 388
Assigning Array Values 390
Array Bounds 390
Specifying an Array Size 392
Multidimensional Arrays 393
Initializing a Two-Dimensional Array 397
More Dimensions 398
Pointers and Arrays 398
Functions, Arrays, and Pointers 401
Using Pointer Parameters 404
Comment: Pointers and Arrays 407
Pointer Operations 407
Protecting Array Contents 412
Using const with Formal Parameters 413
More About const 415
Pointers and Multidimensional Arrays 417
Pointers to Multidimensional Arrays 420
Pointer Compatibility 421
Functions and Multidimensional Arrays 423
Variable-Length Arrays (VLAs) 427
Compound Literals 431
Key Concepts 434
Summary 435
Review Questions 436
Programming Exercises 439
11 Character Strings and String Functions 441
Representing Strings and String I/O 441
Defining Strings Within a Program 442
Pointers and Strings 451
String Input 453
Creating Space 453
The Unfortunate gets() Function 453
The Alternatives to gets() 455
The scanf() Function 462
String Output 464
The puts() Function 464
The fputs() Function 465
The printf() Function 466
The Do-It-Yourself Option 466
String Functions 469
The strlen() Function 469
The strcat() Function 471
The strncat() Function 473
The strcmp() Function 475
The strcpy() and strncpy() Functions 482
The sprintf() Function 487
Other String Functions 489
A String Example: Sorting Strings 491
Sorting Pointers Instead of Strings 493
The Selection Sort Algorithm 494
The ctype.h Character Functions and Strings 495
Command-Line Arguments 497
Command-Line Arguments in Integrated Environments 500
Command-Line Arguments with the Macintosh 500
String-to-Number Conversions 500
Key Concepts 504
Summary 504
Review Questions 505
Programming Exercises 508
12 Storage Classes, Linkage, and Memory Management 511
Storage Classes 511
Scope 513
Linkage 515
Storage Duration 516
Automatic Variables 518
Register Variables 522
Static Variables with Block Scope 522
Static Variables with External Linkage 524
Static Variables with Internal Linkage 529
Multiple Files 530
Storage-Class Specifier Roundup 530
Storage Classes and Functions 533
Which Storage Class? 534
A Random-Number Function and a Static Variable 534
Roll ’Em 538
Allocated Memory: malloc() and free() 543
The Importance of free() 547
The calloc() Function 548
Dynamic Memory Allocation and Variable-Length Arrays 548
Storage Classes and Dynamic Memory Allocation 549
ANSI C Type Qualifiers 551
The const Type Qualifier 552
The volatile Type Qualifier 554
The restrict Type Qualifier 555
The _Atomic Type Qualifier (C11) 556
New Places for Old Keywords 557
Key Concepts 558
Summary 558
Review Questions 559
Programming Exercises 561
13 File Input/Output 565
Communicating with Files 565
What Is a File? 566
The Text Mode and the Binary Mode 566
Levels of I/O 568
Standard Files 568
Standard I/O 568
Checking for Command-Line Arguments 569
The fopen() Function 570
The getc() and putc() Functions 572
End-of-File 572
The fclose() Function 574
Pointers to the Standard Files 574
A Simple-Minded File-Condensing Program 574
File I/O: fprintf(), fscanf(), fgets(), and fputs() 576
The fprintf() and fscanf() Functions 576
The fgets() and fputs() Functions 578
Adventures in Random Access: fseek() and ftell() 579
How fseek() and ftell() Work 580
Binary Versus Text Mode 582
Portability 582
The fgetpos() and fsetpos() Functions 583
Behind the Scenes with Standard I/O 583
Other Standard I/O Functions 584
The int ungetc(int c, FILE *fp) Function 585
The int fflush() Function 585
The int setvbuf() Function 585
Binary I/O: fread() and fwrite() 586
The size_t fwrite() Function 588
The size_t fread() Function 588
The int feof(FILE *fp) and int ferror(FILE *fp) Functions 589
An fread() and fwrite() Example 589
Random Access with Binary I/O 593
Key Concepts 594
Summary 595
Review Questions 596
Programming Exercises 598
14 Structures and Other Data Forms 601
Sample Problem: Creating an Inventory of Books 601
Setting Up the Structure Declaration 604
Defining a Structure Variable 604
Initializing a Structure 606
Gaining Access to Structure Members 607
Initializers for Structures 607
Arrays of Structures 608
Declaring an Array of Structures 611
Identifying Members of an Array of Structures 612
Program Discussion 612
Nested Structures 613
Pointers to Structures 615
Declaring and Initializing a Structure Pointer 617
Member Access by Pointer 617
Telling Functions About Structures 618
Passing Structure Members 618
Using the Structure Address 619
Passing a Structure as an Argument 621
More on Structure Features 622
Structures or Pointer to Structures? 626
Character Arrays or Character Pointers in a Structure 627
Structure, Pointers, and malloc() 628
Compound Literals and Structures (C99) 631
Flexible Array Members (C99) 633
Anonymous Structures (C11) 636
Functions Using an Array of Structures 637
Saving the Structure Contents in a File 639
A Structure-Saving Example 640
Program Points 643
Structures: What Next? 644
Unions: A Quick Look 645
Using Unions 646
Anonymous Unions (C11) 647
Enumerated Types 649
enum Constants 649
Default Values 650
Assigned Values 650
enum Usage 650
Shared Namespaces 652
typedef: A Quick Look 653
Fancy Declarations 655
Functions and Pointers 657
Key Concepts 665
Summary 665
Review Questions 666
Programming Exercises 669
15 Bit Fiddling 673
Binary Numbers, Bits, and Bytes 674
Binary Integers 674
Signed Integers 675
Binary Floating Point 676
Other Number Bases 676
Octal 677
Hexadecimal 677
C’s Bitwise Operators 678
Bitwise Logical Operators 678
Usage: Masks 680
Usage: Turning Bits On (Setting Bits) 681
Usage: Turning Bits Off (Clearing Bits) 682
Usage: Toggling Bits 683
Usage: Checking the Value of a Bit 683
Bitwise Shift Operators 684
Programming Example 685
Another Example 688
Bit Fields 690
Bit-Field Example 692
Bit Fields and Bitwise Operators 696
Alignment Features (C11) 703
Key Concepts 705
Summary 706
Review Questions 706
Programming Exercises 708
16 The C Preprocessor and the C Library 711
First Steps in Translating a Program 712
Manifest Constants: #define 713
Tokens 717
Redefining Constants 717
Using Arguments with #define 718
Creating Strings from Macro Arguments: The # Operator 721
Preprocessor Glue: The ## Operator 722
Variadic Macros: ... and __VA_ARGS__ 723
Macro or Function? 725
File Inclusion: #include 726
Header Files: An Example 727
Uses for Header Files 729
Other Directives 730
The #undef Directive 731
Being Defined–The C Preprocessor Perspective 731
Conditional Compilation 731
Predefined Macros 737
#line and #error 738
#pragma 739
Generic Selection (C11) 740
Inline Functions (C99) 741
_Noreturn Functions (C11) 744
The C Library 744
Gaining Access to the C Library 745
Using the Library Descriptions 746
The Math Library 747
A Little Trigonometry 748
Type Variants 750
The tgmath.h Library (C99) 752
The General Utilities Library 753
The exit() and atexit() Functions 753
The qsort() Function 755
The Assert Library 760
Using assert 760
_Static_assert (C11) 762
memcpy() and memmove() from the string.h Library 763
Variable Arguments: stdarg.h 765
Key Concepts 768
Summary 768
Review Questions 768
Programming Exercises 770
17 Advanced Data Representation 773
Exploring Data Representation 774
Beyond the Array to the Linked List 777
Using a Linked List 781
Afterthoughts 786
Abstract Data Types (ADTs) 786
Getting Abstract 788
Building an Interface 789
Using the Interface 793
Implementing the Interface 796
Getting Queued with an ADT 804
Defining the Queue Abstract Data Type 804
Defining an Interface 805
Implementing the Interface Data Representation 806
Testing the Queue 815
Simulating with a Queue 818
The Linked List Versus the Array 824
Binary Search Trees 828
A Binary Tree ADT 829
The Binary Search Tree Interface 830
The Binary Tree Implementation 833
Trying the Tree 849
Tree Thoughts 854
Other Directions 856
Key Concepts 856
Summary 857
Review Questions 857
Programming Exercises 858
A Answers to the Review Questions 861
B Reference Section 905
9780321928429, TOC, 11/5/2013