Teach Yourself More C++ in 21 Days

Jesse Liberty

• Understanding Object-Oriented Programming
  • Encapsulation
  • Polymorphism
  • Inheritance
  • The Fundamentals
• Understanding Memory
• The Stack and Functions
• Using Classes and Structures
• Using Pointers
• Using new and delete
• Using References
• Using const
• Using Arrays
• Examining Inheritance in Detail
  • Using Abstract Data Types
  • Using Multiple Inheritance
  • Understanding Private Inheritance and Containment
• Defining Operator Overloading
• Using Static Data and Functions
• Using Friend Functions and Classes
• Using Streams
• Using Exceptions
• Writing Large Programs
  • Looking At Style Guidelines
  • Indenting
  • Braces
  • Long Lines
  • Switch Statements
  • Program Text
  • Identifier Names
  • Spelling and Capitalization of Names
  • Comments
  • Access
  • Constants
• The Project
  • Understanding How ROBIN Works
  • Reinventing the Wheel
  • Relating ROBIN to Your Own Projects
• Summary
• Q&A
• Workshop
  • Quiz
  • Exercises

Day 2: Templates

• The Fundamentals
  • Template Instances
  • Template Definition
  • Using the Name
  • Implementing the Template
• Template Functions
  • Using Template Items
  • Specialized Functions
• Summary
• Q&A
• Workshop
  • Quiz
  • Exercises

• The String Class
• Lists
  • Linked Lists
  • Creating Your First Linked List
• Parameterizing the List
• Summary
• Q&A
• Workshop
  • Quiz
  • Exercises

• A Practical View
• Selection Sort
• Improving Efficiency
• Did the Optimization Help?
• Insertion Sort
• Bubble Sort
  • Improving the Bubble Sort
• QuickSort()
• Sorting Pointers Rather Than Records
• Parameterizing the Sort
  • Limitations of the QuickSort() Routine
• Summary
• Q&A
• Workshop
  • Quiz
  • Exercises

• The Specification
  • The Functional Specification
  • Storing Data
  • Searching for Data
  • Displaying Found Data
  • Database Management
  • Getting Help
  • A Moving Target
• The Technical Specification
  • Iterative Design
• Where Do I Start?
  • What Are the Initial Classes?
  • Event-Driven Programming
  • Object Orientation
  • Getting Started
• Abstract Data Types
  • Searching
  • The Collections
• Getting Started
  • The rWord Class
• Reviewing a Technical Specification
• Next Steps
• Other Designs: CLiDE
• CLiDE's Functional Specifications
  • Portability Issues
  • The User Interface
  • The Technical Specification
  • What Are the Objects?
• Prototyping
• Sorting, Filtering, and Displaying
• CLiDE's First Steps
• Q&A
• Workshop
  • Quiz
  • Exercises

• Command-Line Processing
• Command-Line Flags
• An Alternative to Flags
• Sorting Command-Line Arguments
  • Command-Line Arguments and Linked Lists
• Using the Environment Variables
  • Using getenv
  • Using putenv
• Summary
• Q&A
• Workshop
  • Quiz
  • Exercises

• Laying the Groundwork
  • Standard Definitions
  • The List Class
  • Strings and Notes
  • Testing the Building Blocks
• Using Hash Tables
• Deciding When To Use Hash Tables
• Using Trees and Other Powerful Data Structures
  • Using Trees
  • Using Binary Trees
  • Finding a Node
  • Inserting Nodes
  • Deleting a Node
  • Creating an rWord Object
  • Using the Demonstration Program
• Rewriting the Binary Tree
• Summary
• Q&A
• Workshop
  • Quiz
  • Exercises

• Printing a Tree
• Using FIFO Queues
  • Using the Queue Class to Print
  • Problems with This Approach
  • Using Recursion to Print
• Using Balanced Binary Trees
  • Using AVL Trees
  • Writing the AVL Tree
• Looking At Other Binary Trees
• Summary
• Q&A
• Workshop
  • Quiz
  • Exercises

• Writing Objects to Disk
• Writing Data from an Object
  • Object Persistence versus Data Persistence
  • Storing Objects to Disk
• Creating Classes to Handle Storage
• What Have We Gained?
• From Here to an Object Store
• Summary
• Q&A
• Workshop
  • Quiz
  • Exercises

• Collection Classes
  • Sets
  • Dictionaries
• Creating the Sparse Array Class
  • Implementation Issues
• Tree Structures and Object Persistence
• B-Trees
  • Deleting a Node
  • Implementing the B-Tree
• Writing Pages To Disk (Not Yet)
• Summary
• Q&A
• Workshop
  • Quiz
  • Exercises

• Keeping It in Perspective
• Real-World Considerations
• Knowing What You Are Building
• Using Disk-Based B-Trees
• Caching
  • Swapping Out
  • Determining How Big Each Page Should Be
  • Determining How Many Pages Can Be in Memory at Once
• Swapping to Disk
• Implementing the Tree
• Connecting Nodes to Data
• Deleting Notes
• Implementing Performance Enhancements
• Summary
• Q&A
• Workshop
  • Quiz
  • Exercises

• Putting the Notes into a Data File
  • Storing the Notes
• Improving the Code
  • Recording Length and Data
  • Case Insensitivity
  • Very Small Words
  • Statistics
• The Final Preliminary Version
• Summary
• Q&A
• Workshop
  • Quiz
  • Exercises

• Testing Your Program
• Finishing ROBIN, V.1
• Locking the Pages
• Displaying Results
• Exercising the Program
• Getting It Out the Door
• Looking At What You Didn't Fix
• What's Ahead
• Summary
• Q&A
• Workshop
  • Quiz
  • Exercises

• Bit Twiddling
  • Operator AND
  • Operator OR
  • Operator Exclusive OR
  • The Complement Operator
  • Setting Bits
  • Clearing Bits
  • Flipping Bits
  • Bit Fields
• Learning How Memory Works
  • Examining the Levels of Abstraction
  • Partitioning RAM
  • Using Registers and the Instruction Pointer
  • Using the Stack
• Understanding How the Stack Works with Functions
• Using the Heap
• Working with Binary and Hexadecimal Values
  • What Are These Strange Numbers?
• Using Other Bases
• Working with Binary Values
  • Why Base 2?
  • Bits and Bytes
  • What Is a K?
  • Binary Numbers
• Working with Hexadecimal Values
• Summary
• Q&A
• Workshop
  • Quiz
  • Exercises

• Using an Iterator
  • Understanding How the Iterator Works
  • Illustrating an Iterator over a B-Tree
• Extending the Iterator
• Examining Issues with Iterators
• Summary
• Q&A
• Workshop
  • Quiz
  • Exercises

• Maintainable and Extensible Code
• How Synonyms Work
• Summary
• Q&A
• Workshop
  • Quiz
  • Exercises

• Optimizing Your Code
  • Programming Optimization
  • Compiler Optimization
• Using Profilers
• Profiling Your Program
• Profiling Function Count
• Examining Time versus Occurrence
• Profiling by Line
• Using Coverage Profiling
• Putting the Profile to Use
• False Optimizations
• Applying the Lessons
• Summary
• Q&A
• Workshop
  • Quiz
  • Exercises

• Reviewing Exceptions
  • Seeing How Exceptions Are Used
  • Using Try Blocks and Catch Blocks
  • Catching Exceptions
  • Using More Than One Catch Specification
  • Using Exception Hierarchies
• Exception Objects
• Using Exceptions with Templates
• Using Exceptions without Errors
• Q&A
• Workshop
  • Quiz
  • Exercises

• Writing It Isn't the Hard Part
• Robustness
• Extensibility
• Maintainability
• Using Asserts
  • Leave the Assert in There
  • Beware of Side Effects
• Class Invariants
• Test the Return Value from New
• Make Destructors Virtual
• Initialize Pointers to Zero
• Use Const Wherever You Can
• Managing Object Creation
• Initialize in the Order You Declare Your Member Variables
• Never, Ever, Return a Reference to a Local Object. Ever.
• Create a Consistent Style
  • Braces
  • Long Lines
  • Switch Statements
  • Program Text
  • Identifier Names
  • Spelling and Capitalization of Names
  • Comments
  • Access
  • Class Definitions
  • Include Files
  • Evolve Your Own Rules and Write Them Down
• Reviewing Your Code
  • Design Reviews
  • Code Reviews
  • Documentation Reviews
• Planning for Change
• Summary
• Q&A
• Workshop
  • Quiz
  • Exercises

• Examining Bugs, Errors, and Design Problems
• Looking At the Cost of Bugs
  • Writing a Good Specification
  • Writing the Design Document
  • Considering Reality and Schedules
• Using Debuggers
  • Use the Source, Luke
  • Use TRACE Macros
  • Use Logs
• Using the Debugger
  • Using Symbolic Debuggers
  • Using Break Points
  • Using Watch Points
  • Examining Memory
  • Using a Call Stack
  • Turning Off Optimization
• Zen Mind, Debugging Mind
• Defining the Problem
  • Locating, Isolating, and Destroying the Problem
  • Knowing What to Look For
• Questioning Your Assumptions
• Looking At Logic Flaws
• Finding Bugs That Only Show Up in Release Code
• Watching for Some Common Bugs
  • Making Fence-Post Errors
  • Deleting Memory Twice, or Not at All
  • Wrapping around an Integer
  • Returning a Reference to a Local Variable
• Memory Checking
• A Word about Rest
• Looking At Some Debugging Examples
• Summary
• Q&A
• Workshop
  • Quiz
  • Exercises

• Using Version Control
  • Learning How Version Control Works
  • Managing More Than One Programmer
  • Understanding Branches and Trunks
  • Understanding Release Branches
  • Creating Dynamic Names
• Making Enhancements
• Using Shareware
• Writing Commercial Software
  • Finding Help and Advice
  • Required Reading
  • Getting More Information about Object-Oriented Analysis and Design
  • Writing for Windows or the Macintosh
  • Writing Solid Code
  • Getting More Information from Magazines
  • Staying in Touch
• Summary
• Q&A
• Workshop
  • Quiz

• Answers for Day 1, "Getting Started"
  • Quiz
  • Exercises
• Answers for Day 2, "Templates"
  • Quiz
  • Exercises
• Answers to Day 3, "Strings and Lists"
  • Quiz
  • Exercises
• Answers to Day 4, "Sorting"
  • Quiz
  • Exercises
• Answers to Chapter 5, "Design"
  • Quiz
  • Exercises
• Answers to Day 6, "Command-Line Processing and the Environment"
  • Quiz
  • Exercises
• Answers to Day 7, "Complex Data Structures"
  • Quiz
  • Exercises
• Answers to Day 8, "Advanced Data Structures"
  • Quiz
  • Exercises
• Answers to Day 9, "Writing to Disk"
  • Quiz
  • Exercises
• Answers to Day 10, " Collection Classes and B-Trees"
  • Quiz
  • Exercises
• Answers for Day 11, "Building Indexes on Disk"
  • Quiz
  • Exercises
• Answers for Day 12, "Records and Parsing"
  • Quiz
  • Exercises
• Answers for Day 13, " ROBIN, V.1"
  • Quiz
  • Exercises
• Answers for Day 14, " Advanced Data Manipulation"
  • Quiz
  • Exercises
• Answers for Day 15, " Iterators"
  • Quiz
  • Exercises
• Answers for Day 16, "Synonyms"
  • Quiz
  • Exercises
• Answers for Day 17, " Profiling and Optimization"
  • Quiz
  • Exercises
• Answers for Day 18, " Advanced Exceptions and Error Handling"
  • Quiz
  • Exercises
• Answers for Day 19, "Writing Solid Code"
  • Quiz
  • Exercises
• Answers for Day 20, "Debugging"
  • Quiz
  • Exercises
• Answers for Day 21, " Next Steps"
  • Quiz

• Conditional Compilation
• Make Variables
• Built-In Variables
• Suffix Rules
• Next Steps