C Primer Plus

Series
Addison-Wesley
Author
Stephen Prata  
Publisher
Addison-Wesley
Cover
Softcover
Edition
6
Language
English
Total pages
1080
Pub.-date
November 2013
ISBN13
9780321928429
ISBN
0321928423
Related Titles


Product detail

Product Price CHF Available  
9780321928429
C Primer Plus
67.70 approx. 7-9 days

Description

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. 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.

Features

  • Solutions to the exercises in the text are available in the IRC.

New to this Edition

This sixth edition contains:

·    New coverage of the C11 standard

·    Updated information about the latest C compilers for Windows, OS X, and Linux

·    New material on C programming for mobile and game development

·    New material on C-based object-oriented programming languages (e.g., Objective-C)

 

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

 

Author

Stephen Prata , now retired, taught 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 as authored or coauthored over a dozen books, including C++ Primer Plus and Unix Primer Plus.