Enhanced descriptions from Syndetics:

C++ From Scratch: An Object-Oriented Approach is designed to walk novice programmers through the analysis, design and implementation of a functioning object-oriented application using C++. You will learn all the critical programming concepts and techniques associated with the language in the context of creating a functioning application. Best selling C++ author Jesse Liberty shows you how to create Decryptix, a game of decoding a hidden pattern as quickly as possible, using nothing but successive guesses and the application of logic. Every example and technique is put into the context of achieving a goal and accomplishing an end.

Table of contents provided by Syndetics

• Introduction (p. 1)
• Learning C++ Doesn't Have to Be Difficult (p. 1)
• Compiling the Code (p. 2)
• Conventions Used in this Book (p. 2)
• Breaking the Code (p. 3)
• Chapter 1 An Introduction to C++ (p. 5)
• Programs (p. 6)
• Solving Problems (p. 6)
• Procedural, Structured, and Object-Oriented Programming (p. 7)
• Why C++? (p. 8)
• Why Object-Oriented Programming? (p. 9)
• Managing Complexity (p. 9)
• Objects (p. 10)
• Encapsulation (p. 10)
• Delegation (p. 11)
• Specialization (p. 12)
• Generalization and Polymorphism (p. 13)
• The Three Pillars (p. 13)
• How Object-Oriented Analysis and Design Is Done (p. 14)
• Object-Oriented Analysis and Design for Small Projects (p. 15)
• The Vision (p. 16)
• Requirements Analysis (p. 17)
• Quick and Dirty Design (p. 18)
• Implementation (p. 19)
• Your Development Environment (p. 20)
• Text Editor (p. 21)
• Compiling the Source Code (p. 21)
• Creating an Executable File with the Linker (p. 22)
• The Development Cycle (p. 22)
• Decryptix.cpp: Your First C++ Program (p. 23)
• Compile Errors (p. 24)
• Rollout (p. 25)
• Next Steps (p. 25)
• Chapter 2 Getting Started (p. 27)
• How Big Is a Small Project? (p. 27)
• Why Teach a Process that Is Only Good for Smaller Projects? (p. 27)
• Bootstrapping Your Knowledge (p. 28)
• Creating the Project (p. 28)
• Examining the Code (p. 29)
• Analyzing the Code (p. 31)
• Namespaces (p. 32)
• Using namespace std (p. 33)
• Code Spelunking (p. 34)
• Returning a Value (p. 36)
• Main() Is More Equal than Others (p. 36)
• Using cout to Print to the Screen (p. 37)
• Variables (p. 38)
• Constants (p. 47)
• Chapter 3 Program Flow (p. 53)
• Building Robustness (p. 53)
• What Are You Trying to Accomplish? (p. 55)
• Solving the Problem with Loops (p. 56)
• Relational Operators (p. 57)
• Blocks and Compound Statements (p. 57)
• Logical Operators (p. 58)
• The if Statement (p. 60)
• Short Circuit Evaluation (p. 62)
• Relational Precedence (p. 62)
• Putting It All Together (p. 63)
• Do while (p. 63)
• Enumerated Constants (p. 64)
• Returning to the Code (p. 65)
• Getting a Boolean Answer from the User (p. 66)
• Equality Operator == (p. 67)
• Else (p. 67)
• The Conditional (or ternary) Operator (p. 67)
• Putting It All Together (p. 69)
• Chapter 4 Creating Classes (p. 71)
• Why Classes? (p. 71)
• Creating New Types: Class (p. 72)
• Interface Versus Implementation (p. 72)
• Clients (p. 72)
• Looking at the Code (p. 73)
• Declaring the Class (p. 74)
• Classes and Objects (p. 74)
• Member Variables (p. 74)
• Member Methods or Functions (p. 75)
• The Size of Objects (p. 75)
• Files (p. 75)
• Constructors (p. 76)
• Destructors (p. 76)
• Implementing the Methods (p. 77)
• Including the Header (p. 79)
• Implementing the Constructor (p. 79)
• Initialization (p. 80)
• Using the Debugger (p. 82)
• Examining the Constructor (p. 83)
• The Other Methods (p. 83)
• Storing the Pattern (p. 83)
• What Is an Array? (p. 84)
• Initializing Arrays (p. 84)
• Array Elements (p. 86)
• Writing Past the End of an Array (p. 86)
• Generating the Solution (p. 88)
• Examining the Defined Values File (p. 92)
• Chapter 5 Playing The Game (p. 95)
• Inline Implementation (p. 96)
• Constant Member Methods (p. 98)
• The Signature (p. 98)
• Passing by Reference and by Value (p. 99)
• References and Passing by Reference (p. 104)
• Pointers (p. 105)
• What is a pointer? (p. 105)
• Memory Addresses (p. 105)
• Dereferencing (p. 110)
• Getting the Operators Straight (p. 111)
• Arrays (p. 111)
• Arrays as Pointers (p. 113)
• Passing the Array as a Pointer (p. 115)
• Using ASSERT (p. 118)
• How ASSERT Works (p. 119)
• Through the Program Once, by the Numbers (p. 124)
• Chapter 6 Using Linked Lists (p. 137)
• Dynamic Data Structures (p. 138)
• The Standard Template Library (p. 138)
• Linked Lists (p. 139)
• Understanding Linked Lists (p. 140)
• A Simple Driver Program (p. 143)
• The HowMany() Method (p. 145)
• Insert() in Detail (p. 147)
• Using new (p. 153)
• new and delete (p. 153)
• Using Our Simple Linked List in Decryptix! (p. 160)
• Run it! (p. 163)
• Playing the Game (p. 166)
• Solving the Problem with a Member Method (p. 167)
• Operator Overloading (p. 169)
• How You Accomplish Operator Overloading (p. 169)
• Passing Objects by Value (p. 170)
• Why Is It a Reference? (p. 171)
• Chapter 7 The Canonical Methods (p. 173)
• Method Overloading (p. 173)
• The Shape Classes (p. 173)
• Overloading Constructors (p. 174)
• The Miranda Methods (p. 175)
• The Default Constructor (p. 175)
• When Do You Get a Compiler-Supplied Constructor? (p. 178)
• The Default Destructor (p. 178)
• The Copy Constructor (p. 179)
• Why Isn't the Default Copy Constructor Sufficient? (p. 187)
• Writing Your Own Copy Constructor (p. 193)
• The Assignment Operator (p. 194)
• When It Looks Like Assignment But Isn't (p. 200)
• Back to Linked Lists (p. 200)
• Chapter 8 Using Polymorphism (p. 203)
• Specialization (p. 203)
• Benefits from Specialization (p. 205)
• Polymorphism (p. 205)
• Abstract Data Types (p. 205)
• How This Is Implemented in C++ (p. 206)
• The Syntax of Inheritance (p. 206)
• Overriding Functions (p. 206)
• Virtual Methods (p. 207)
• How Virtual Functions Work (p. 208)
• Virtual Destructors (p. 209)
• Implementing Polymorphism (p. 213)
• Adding a Second Letter (p. 225)
• Examining operator[] (p. 226)
• Chapter 9 Implementing Templates (p. 229)
• Creating the History (p. 229)
• Overloaded Operators (p. 231)
• Writing Class Data to cout (p. 231)
• Definition in the Header (p. 238)
• Create the Non-Parameterized Type First (p. 242)
• Instantiating the Template (p. 242)
• Using the History Object (p. 243)
• Using the History (p. 251)
• Getting It Right (p. 252)
• Chapter 10 Leveraging the Standard Template Library (p. 253)
• Converting Decryptix! to STL (p. 253)
• Collection Classes (p. 254)
• Working with Vectors (p. 254)
• Examining the Output (p. 264)
• Initializing the Game (p. 265)
• The Play() Method (p. 266)
• Displaying the Contents of a Vector (p. 266)
• Scoring the Guess (p. 267)
• Creating the History (p. 268)
• ShowHistory (p. 268)
• Examining the Hints (p. 269)
• Chapter 11 The Computer Guesses (p. 271)
• Teaching the Computer to Guess (p. 271)
• Capturing the Rules (p. 272)
• Decrypter Classes (p. 272)
• Implementing Game (p. 275)
• Human Guesses (p. 281)
• Computer Guesses (p. 290)
• Creating the Computer Object (p. 293)
• Chapter 12 Delegating Responsibility (p. 299)
• Assigning Responsibility (p. 299)
• Understanding the Default Parameter (p. 307)
• SmartChar in Detail (p. 308)
• Watching it Work (p. 309)
• The Computer Plays (p. 310)
• Creating a Smart String (p. 310)
• Computer::Play() (p. 312)
• Generating Guesses: An Overview (p. 314)
• Generating a Guess, Details (p. 316)
• The Logic of CanEliminateCharacters (p. 317)
• CanEliminateCharacters in Detail (p. 317)
• GenerateAGuess (p. 321)
• IsConsistent in Detail (p. 322)
• The Effect of Static (p. 326)
• Resuming the Analysis (p. 326)
• Eliminating Characters in Position (p. 328)
• Chapter 13 Persistence (p. 331)
• Object Persistence (p. 331)
• Flavors of Persistence (p. 331)
• Designing Persistence (p. 332)
• The Reader and the Writer (p. 333)
• User Interface Issues (p. 336)
• Writing out the Game (p. 353)
• Writing the Game, Step by Step (p. 353)
• Writing Polymorphic Objects (p. 354)
• Chapter 14 Introducing Exceptions (p. 373)
• When Something Exceptional Happens (p. 373)
• Unwinding the Stack (p. 380)
• Reading the Object from Disk (p. 382)
• Restoring a Human (p. 390)
• Chapter 15 Next Steps (p. 391)
• Read Another Primer? (p. 391)
• Advanced Topics in C++ (p. 392)
• Object-oriented Analysis, Design, and Patterns (p. 393)
• Design Patterns (p. 393)
• Magazines (p. 394)
• Support Newsgroups (p. 394)
• Staying in Touch (p. 394)
• Appendix A Binary and Hexadecimal (p. 395)
• Other Bases (p. 396)
• Around the Bases (p. 396)
• Binary (p. 398)
• Why Base 2? (p. 398)
• Bits, Bytes, and Nybbles (p. 399)
• What's a KB? (p. 399)
• Binary Numbers (p. 399)
• Hexadecimal (p. 400)
• Appendix B Operator Precedence (p. 405)
• Index (p. 407)

Author notes provided by Syndetics