C Primer Plus

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