C Primer Plus, 6th edition

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