Enhanced descriptions from Syndetics:

For introductory courses in C Programming. Also for courses in Programming for Engineers, Programming for Business, and Programming for Technology.

The Deitels' How to Program series offers unparalleled breadth and depth of object-oriented programming concepts and intermediate-level topics for further study. Using the Deitels' signature "Live-Code(tm) Approach," this complete, authoritative introduction to C programming introduces fundamentals of structured programming, and covers relevant features of C language's C-201X standard. It also includes an updated treatment of C++ for those who want to transition to object-oriented concepts. Finally, new material on security is added to this edition.

Table of contents provided by Syndetics

• Preface(p. xxi)
• 1 Introduction to Computers, the Internet and the Web(p. 1)
• 1.1 Introduction(p. 2)
• 1.2 Computers: Hardware and Software(p. 3)
• 1.3 Computer Organization(p. 4)
• 1.4 Personal, Distributed and Client/Server Computing(p. 5)
• 1.5 The Internet and the World Wide Web(p. 5)
• 1.6 Machine Languages, Assembly Languages and High-Level Languages(p. 6)
• 1.7 History of C(p. 7)
• 1.8 C Standard Library(p. 8)
• 1.9 C++(p. 9)
• 1.10 Java(p. 9)
• 1.11 Fortran, COBOL, Pascal and Ada(p. 10)
• 1.12 BASIC, Visual Basic, Visual C++, C# and .NET(p. 10)
• 1.13 Key Software Trend: Object Technology(p. 11)
• 1.14 Typical C Program Development Environment(p. 12)
• 1.15 Hardware Trends(p. 14)
• 1.16 Notes About C and This Book(p. 15)
• 1.17 Web Resources(p. 16)
• 2 Introduction to C Programming(p. 23)
• 2.1 Introduction(p. 24)
• 2.2 A Simple C Program: Printing a Line of Text(p. 24)
• 2.3 Another Simple C Program: Adding Two Integers(p. 28)
• 2.4 Memory Concepts(p. 33)
• 2.5 Arithmetic in C(p. 34)
• 2.6 Decision Making: Equality and Relational Operators(p. 38)
• 3 Structured Program Development in C(p. 54)
• 3.1 Introduction(p. 55)
• 3.2 Algorithms(p. 55)
• 3.3 Pseudocode(p. 55)
• 3.4 Control Structures(p. 56)
• 3.5 The if Selection Statement(p. 58)
• 3.6 The if...else Selection Statement(p. 59)
• 3.7 The while Repetition Statement(p. 63)
• 3.8 Formulating Algorithms Case Study 1: Counter-Controlled Repetition(p. 64)
• 3.9 Formulating Algorithms with Top-Down, Stepwise Refinement Case Study 2: Sentinel-Controlled Repetition(p. 66)
• 3.10 Formulating Algorithms with Top-Down, Stepwise Refinement Case Study 3: Nested Control Structures(p. 73)
• 3.11 Assignment Operators(p. 77)
• 3.12 Increment and Decrement Operators(p. 78)
• 4 C Program Control(p. 97)
• 4.1 Introduction(p. 98)
• 4.2 Repetition Essentials(p. 98)
• 4.3 Counter-Controlled Repetition(p. 99)
• 4.4 for Repetition Statement(p. 100)
• 4.5 for Statement: Notes and Observations(p. 103)
• 4.6 Examples Using the for Statement(p. 103)
• 4.7 switch Multiple-Selection Statement(p. 107)
• 4.8 do...while Repetition Statement(p. 113)
• 4.9 break and continue Statements(p. 114)
• 4.10 Logical Operators(p. 116)
• 4.11 Confusing Equality (==) and Assignment (=) Operators(p. 119)
• 4.12 Structured Programming Summary(p. 121)
• 5 C Functions(p. 140)
• 5.1 Introduction(p. 141)
• 5.2 Program Modules in C(p. 141)
• 5.3 Math Library Functions(p. 142)
• 5.4 Functions(p. 144)
• 5.5 Function Definitions(p. 144)
• 5.6 Function Prototypes(p. 148)
• 5.7 Function Call Stack and Activation Records(p. 151)
• 5.8 Headers(p. 151)
• 5.9 Calling Functions By Value and By Reference(p. 152)
• 5.10 Random Number Generation(p. 153)
• 5.11 Example: A Game of Chance(p. 158)
• 5.12 Storage Classes(p. 161)
• 5.13 Scope Rules(p. 164)
• 5.14 Recursion(p. 167)
• 5.15 Example Using Recursion: Fibonacci Series(p. 170)
• 5.16 Recursion vs. Iteration(p. 174)
• 6 C Arrays(p. 195)
• 6.1 Introduction(p. 196)
• 6.2 Arrays(p. 196)
• 6.3 Defining Arrays(p. 198)
• 6.4 Array Examples(p. 198)
• 6.5 Passing Arrays to Functions(p. 212)
• 6.6 Sorting Arrays(p. 216)
• 6.7 Case Study: Computing Mean, Median and Mode Using Arrays(p. 218)
• 6.8 Searching Arrays(p. 223)
• 6.9 Multiple-Subscripted Arrays(p. 229)
• 7 C Pointers(p. 253)
• 7.1 Introduction(p. 254)
• 7.2 Pointer Variable Definitions and Initialization(p. 254)
• 7.3 Pointer Operators(p. 255)
• 7.4 Passing Arguments to Functions by Reference(p. 257)
• 7.5 Using the const Qualifier with Pointers(p. 261)
• 7.6 Bubble Sort Using Call-by-Reference(p. 267)
• 7.7 sizeof Operator(p. 270)
• 7.8 Pointer Expressions and Pointer Arithmetic(p. 273)
• 7.9 Relationship between Pointers and Arrays(p. 275)
• 7.10 Arrays of Pointers(p. 280)
• 7.11 Case Study: Card Shuffling and Dealing Simulation(p. 280)
• 7.12 Pointers to Functions(p. 285)
• 8 C Characters and Strings(p. 309)
• 8.1 Introduction(p. 310)
• 8.2 Fundamentals of Strings and Characters(p. 310)
• 8.3 Character-Handling Library(p. 312)
• 8.4 String-Conversion Functions(p. 317)
• 8.5 Standard Input/Output Library Functions(p. 322)
• 8.6 String-Manipulation Functions of the String-Handling Library(p. 326)
• 8.7 Comparison Functions of the String-Handling Library(p. 329)
• 8.8 Search Functions of the String-Handling Library(p. 331)
• 8.9 Memory Functions of the String-Handling Library(p. 337)
• 8.10 Other Functions of the String-Handling Library(p. 341)
• 9 C Formatted Input/Output(p. 356)
• 9.1 Introduction(p. 357)
• 9.2 Streams(p. 357)
• 9.3 Formatting Output with printf(p. 357)
• 9.4 Printing Integers(p. 358)
• 9.5 Printing Floating-Point Numbers(p. 359)
• 9.6 Printing Strings and Characters(p. 361)
• 9.7 Other Conversion Specifiers(p. 362)
• 9.8 Printing with Field Widths and Precision(p. 363)
• 9.9 Using Flags in the printf Format Control String(p. 366)
• 9.10 Printing Literals and Escape Sequences(p. 368)
• 9.11 Reading Formatted Input with scanf(p. 369)
• 10 C Structures, Unions, Bit Manipulations and Enumerations(p. 382)
• 10.1 Introduction(p. 383)
• 10.2 Structure Definitions(p. 383)
• 10.3 Initializing Structures(p. 386)
• 10.4 Accessing Structure Members(p. 386)
• 10.5 Using Structures with Functions(p. 388)
• 10.6 typedef(p. 388)
• 10.7 Example: High-Performance Card Shuffling and Dealing Simulation(p. 389)
• 10.8 Unions(p. 391)
• 10.9 Bitwise Operators(p. 394)
• 10.10 Bit Fields(p. 403)
• 10.11 Enumeration Constants(p. 406)
• 11 C File Processing(p. 417)
• 11.1 Introduction(p. 418)
• 11.2 Data Hierarchy(p. 418)
• 11.3 Files and Streams(p. 420)
• 11.4 Creating a Sequential-Access File(p. 421)
• 11.5 Reading Data from a Sequential-Access File(p. 426)
• 11.6 Random-Access Files(p. 430)
• 11.7 Creating a Random-Access File(p. 431)
• 11.8 Writing Data Randomly to a Random-Access File(p. 433)
• 11.9 Reading Data from a Random-Access File(p. 436)
• 11.10 Case Study: Transaction-Processing Program(p. 437)
• 12 C Data Structures(p. 454)
• 12.1 Introduction(p. 455)
• 12.2 Self-Referential Structures(p. 456)
• 12.3 Dynamic Memory Allocation(p. 456)
• 12.4 Linked Lists(p. 458)
• 12.5 Stacks(p. 466)
• 12.6 Queues(p. 472)
• 12.7 Trees(p. 478)
• 13 C Preprocessor(p. 495)
• 13.1 Introduction(p. 496)
• 13.2 #include Preprocessor Directive(p. 496)
• 13.3 #define Preprocessor Directive: Symbolic Constants(p. 496)
• 13.4 #define Preprocessor Directive: Macros(p. 497)
• 13.5 Conditional Compilation(p. 499)
• 13.6 #error and #pragma Preprocessor Directives(p. 500)
• 13.7 # and ## Operators(p. 500)
• 13.8 Line Numbers(p. 501)
• 13.9 Predefined Symbolic Constants(p. 501)
• 13.10 Assertions(p. 502)
• 14 Other C Topics(p. 507)
• 14.1 Introduction(p. 508)
• 14.2 Redirecting I/O(p. 508)
• 14.3 Variable-Length Argument Lists(p. 509)
• 14.4 Using Command-Line Arguments(p. 511)
• 14.5 Notes on Compiling Multiple-Source-File Programs(p. 512)
• 14.6 Program Termination with exit and atexit(p. 514)
• 14.7 volatile Type Qualifier(p. 515)
• 14.8 Suffixes for Integer and Floating-Point Constants(p. 516)
• 14.9 More on Files(p. 516)
• 14.10 Signal Handling(p. 518)
• 14.11 Dynamic Memory Allocation: Functions calloc and realloc(p. 520)
• 14.12 Unconditional Branching with goto(p. 521)
• 15 C++ as a Better C; Introducing Object Technology(p. 528)
• 15.1 Introduction(p. 529)
• 15.2 C++(p. 529)
• 15.3 A Simple Program: Adding Two Integers(p. 530)
• 15.4 C++ Standard Library(p. 532)
• 15.5 Header Files(p. 533)
• 15.6 Inline Functions(p. 535)
• 15.7 References and Reference Parameters(p. 537)
• 15.8 Empty Parameter Lists(p. 542)
• 15.9 Default Arguments(p. 542)
• 15.10 Unary Scope Resolution Operator(p. 544)
• 15.11 Function Overloading(p. 545)
• 15.12 Function Templates(p. 548)
• 15.13 Introduction to Object Technology and the UML(p. 551)
• 15.14 Wrap-Up(p. 554)
• 16 Introduction to Classes and Objects(p. 560)
• 16.1 Introduction(p. 561)
• 16.2 Classes, Objects, Member Functions and Data Members(p. 561)
• 16.3 Defining a Class with a Member Function(p. 562)
• 16.4 Defining a Member Function with a Parameter(p. 566)
• 16.5 Data Members, set Functions and get Functions(p. 569)
• 16.6 Initializing Objects with Constructors(p. 576)
• 16.7 Placing a Class in a Separate File for Reusability(p. 579)
• 16.8 Separating Interface from Implementation(p. 583)
• 16.9 Validating Data with set Functions(p. 589)
• 16.10 Wrap-Up(p. 594)
• 17 Classes: A Deeper Look, Part 1(p. 601)
• 17.1 Introduction(p. 602)
• 17.2 Time Class Case Study(p. 603)
• 17.3 Class Scope and Accessing Class Members(p. 609)
• 17.4 Separating Interface from Implementation(p. 611)
• 17.5 Access Functions and Utility Functions(p. 612)
• 17.6 Time Class Case Study: Constructors with Default Arguments(p. 615)
• 17.7 Destructors(p. 620)
• 17.8 When Constructors and Destructors are Called(p. 621)
• 17.9 Time Class Case Study: A Subtle Trap-Returning a Reference to a private Data Member(p. 624)
• 17.10 Default Memberwise Assignment(p. 627)
• 17.11 Wrap-Up(p. 629)
• 18 Classes: A Deeper Look, Part 2(p. 635)
• 18.1 Introduction(p. 636)
• 18.2 const (Constant) Objects and const Member Functions(p. 636)
• 18.3 Composition: Objects as Members of Classes(p. 645)
• 18.4 friend Functions and friend Classes(p. 651)
• 18.5 Using the this Pointer(p. 654)
• 18.6 static Class Members(p. 659)
• 18.7 Data Abstraction and Information Hiding(p. 664)
• 18.8 Wrap-Up(p. 666)
• 19 Operator Overloading(p. 672)
• 19.1 Introduction(p. 673)
• 19.2 Fundamentals of Operator Overloading(p. 674)
• 19.3 Restrictions on Operator Overloading(p. 675)
• 19.4 Operator Functions as Class Members vs. Global Function(p. 676)
• 19.5 Overloading Stream Insertion and Stream Extraction Operators(p. 678)
• 19.6 Overloading Unary Operators(p. 681)
• 19.7 Overloading Binary Operators(p. 682)
• 19.8 Dynamic Memory Management(p. 682)
• 19.9 Case Study: Array Class(p. 684)
• 19.10 Converting between Types(p. 696)
• 19.11 Building a String Class(p. 697)
• 19.12 Overloading ++ and --(p. 698)
• 19.13 Case Study: A Date Class(p. 700)
• 19.14 Standard Library Class string(p. 704)
• 19.15 explicit Constructors(p. 708)
• 19.16 Proxy Classes(p. 711)
• 19.17 Wrap-Up(p. 715)
• 20 Object-Oriented Programming: Inheritance(p. 727)
• 20.1 Introduction(p. 728)
• 20.2 Base Classes and Derived Classes(p. 729)
• 20.3 protected Members(p. 732)
• 20.4 Relationship between Base Classes and Derived Classes(p. 732)
• 20.4.1 Creating and Using a CommissionEmployee Class(p. 733)
• 20.4.2 Creating a BasePlusCommissionEmployee Class Without Using Inheritance(p. 738)
• 20.4.3 Creating a CommissionEmployee-BasePlusCommissionEmployee Inheritance Hierarchy(p. 743)
• 20.4.4 CommissionEmployee-BasePlusCommissionEmployee Inheritance Hierarchy Using protected Data(p. 748)
• 20.4.5 CommissionEmployee-BasePlusCommissionEmployee Inheritance Hierarchy Using private Data(p. 755)
• 20.5 Constructors and Destructors in Derived Classes(p. 762)
• 20.6 public, protected and private Inheritance(p. 770)
• 20.7 Software Engineering with Inheritance(p. 771)
• 20.8 Wrap-Up(p. 772)
• 21 Object-Oriented Programming: Polymorphism(p. 778)
• 21.1 Introduction(p. 779)
• 21.2 Polymorphism Examples(p. 780)