C Primer Plus
Addison-Wesley Educational Publishers (Verlag)
978-0-321-92842-9 (ISBN)
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.
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
| Erscheint lt. Verlag | 19.12.2013 |
|---|---|
| Reihe/Serie | Developer's Library |
| Verlagsort | New Jersey |
| Sprache | englisch |
| Maße | 179 x 228 mm |
| Gewicht | 1664 g |
| Einbandart | kartoniert |
| Themenwelt | Informatik ► Programmiersprachen / -werkzeuge ► C / C++ |
| ISBN-10 | 0-321-92842-3 / 0321928423 |
| ISBN-13 | 978-0-321-92842-9 / 9780321928429 |
| Zustand | Neuware |
| Haben Sie eine Frage zum Produkt? |
aus dem Bereich
