List Of Figures

1. Basics

• 1.1. Software Development Paradigms and Processes
  • Four software development paradigms
  • The procedural paradigm
  • The data-driven paradigm
  • The object-oriented paradigm
• 1.2. Programming Languages and Paradigms
  • The C++ family tree
  • High-level vs. low-level programming languages
  • The relationship between ANSI C and C++
• 1.3. Object-Oriented Programming Review: C++ vs. Java
  • Object-Oriented Paradigm: Concepts and Terms
  • Instantiating an object with a zero-argument constructor
  • Instantiating an object with a one-argument constructor
  • Calling a method or function defined in a class
  • Creating arrays in Java and C++
• 1.4. Machine Code
  • Converting a program from source to machine code
  • Compiling and running a hybrid-language program
  • Running an interpreted-language program
• 1.5. C++ Compiler Operation
  • The C++ compiler system
  • Example #include directives
  • The preprocessor: #define and #include
  • The complete C++ compilation process
• 1.6. Terminology
  • Statements
  • Expression examples
  • An abstract symbol table (1)
  • A variable definition
  • Defining multiple variables
  • Combined variable definition and initialization
  • An abstract symbol table (2)
  • Variable declarations
• 1.7. Program Data
  • C++ fundamental, built-in, primitive data types
  • Constant examples
  • The characteristics of a variable
  • Variable definition examples
  • Context sensitive interpretation
  • Houses on a street as a metaphor for variables in memory
  • Variable scoping rules
  • C++ variable initialization syntax
  • Variable initialization examples
  • Variables analogized as a drinking glass
  • Creating symbolic constants with const
  • Type promotion examples
  • Type deduction examples
  • Identifier Rules
  • 1.7.1. The Swapping Problem (1)
    • The swapping problem visualized as two glasses
    • Swapping the contents of two glasses
    • Swapping the contents of two variables
• 1.8. C++ Console Input / Output
  • The computer console
  • A running program with three console I/O streams
  • Accessing the I/O system
  • An example of C++ I/O
  • An example of the endl manipulator
  • Escape sequences
• 1.9. Comments
  • Two kinds of comments
  • Comments in a simple program
  • Using /*...*/ comments as a debugging and development tool
• 1.10. The First C++ Program
  • 1.10.1. Hello, World!
    • The components of a C++ function
    • Commonplace programming styles
  • 1.10.2. Programming With An IDE
    • Solutions and projects viewed as a Venn diagram
    • A Visual Studio Example
  • 1.10.3. Visual Studio Demonstration
    • VS demonstration video time indexes
    • The steps for creating, compiling, and running a program with VS 2019

2. Core Operations

• 2.1. Operators and Operands
  • Operator and operand examples
  • Unary, binary, and ternary operators: the number of required operands
  • Arithmetic operators
  • Grouping parentheses change operator evaluation order
  • Associativity Evaluation Order
  • C++ operator summary with precedence and associativity
• 2.2. Common Operators
  • Algebraic equals vs. C++ assignment
  • Using variables in statements
  • Assignment chaining
  • Arithmetic operator summary
  • Division outcome by operand type
  • The modular (remainder) operator illustrated
  • Type promotion examples
  • Typecasting examples
  • Automatic C++ type conversions
  • A truncation error example
• 2.3. Common Operator Examples
  • 2.3.1. ftoc.cpp
    • The formula to convert Fahrenheit to Celsius
    • An incorrect program
    • Correcting a truncation error with floating-point constants
    • Correcting a truncation error with the order of operations
    • Correcting a truncation error with casting
  • 2.3.2. money.cpp
    • money.cpp: modular operator and integer division
• 2.4. Program Termination: exit and return
  • Program termination with return
  • Exit status: batch files and shell scripts
  • Terminating a program with the exit function
• 2.5. Math Library: Functions and Constants
  • M_PI
  • Visual Studio and math constants
  • The pow library function
  • The sqrt library function
  • The complete math constant list
• 2.6. Converting Formulas to C++ Statements
  • Formulas and "good" variable names
  • Variable names with subscripts
  • Multiplication
  • Division
  • Integer Division
  • Negation
  • The <cmath> Header File
  • Small, integral exponents
  • The pow function
  • The sqrt function
  • Symbols of inclusion
  • Misusing temporary variables
  • A valid temporary variable
• 2.7. Math Library Examples
  • 2.7.1. circle.cpp
    • The area of a circle
    • Area of a circle: repeated multiplication version
    • Area of a circle: pow version
  • 2.7.2. hypot.cpp
    • The hypotenuse length of a right triangle
    • hypot.cpp
  • 2.7.3. payment.cpp
    • Periodic loan payment
    • mort.cpp
• 2.8. Unusual Operators
  • Understanding the auto-increment and auto-decrement operators
  • Arithmetic operators with assignment
  • The conditional operator
  • Calculating a minimum with the conditional operator
  • Examples of the sizeof operator
  • Binary conversion and output: a sizeof example
  • Illustrating side effects with the assignment operator
  • Using the comma operator in a for-loop
• 2.9. Bugs and Basic Program Debugging
  • Visual Studio error detection and reporting
  • The evolution of error messages
  • A link error caused by a busy file
  • 2.9.1. Logical Errors And Using The Debugger
    • Steps for locating a logical error
    • Step 1: Calculate intermediate values
    • Step 2: Instrument the code
    • Step 3: Trace the calculations
    • Debugging the temperature program
    • Examining expression values with the debugger
    • Examining evaluation order with the debugger
    • Debugger context controls
    • Manually instrumenting code
    • Debugging with a breakpoint
    • Setting a tracepoint
    • Set a tracepoint action
    • Specifying an action
    • Add tracepoints for all variables you wish to examine
    • Clearing the output window
    • Creating and viewing trace messages
  • 2.9.2. Runtime Errors
    • Locating runtime errors
• 2.10 Practice Problems
  • 2.10.1. Practice Problems: Volume Formulas
  • 2.10.2. Complex Formulas
• 2.11. Supplemental: Bitwise Operators
  • Bitwise-AND
  • Bitwise-OR
  • Bitwise XOR (Exclusive-OR)
  • Bitwise Complement
  • Forming bit patterns
  • Masks and bitwise-AND
  • Masks and bitwise-OR
  • Left Shift Operator
  • Right Shift Operator
  • Right Shift Operator with sign extension
  • Operation with assignment with bitwise operators
  • 2.11.1. File Access Control
    • File access control encoded with bits
    • Bitwise operator examples
    • Decoding user's file permissions
    • Decoding the group's file permissions
    • Decoding others's file permissions
  • 2.11.2. Binary Output
    • Printing a number in binary
    • Printing in binary example
  • 2.11.3. Free Space Management
    • Managing free space with a bit map
    • Program setup
    • Finding and allocating a free disk block
    • Deallocating a disk block

3. Control Statements

• 3.1. Basic Flow Of Control
  • Classifying control statements
  • Control statements keywords and symbols
  • Sequential statements
• 3.2. Block Structure and Scope
  • Indentation reflects statement logic
  • Partial C++ grammar
  • Uncommon blocks
  • Statements and blocks
  • Block scope example
  • C++ named scopes
  • Local scope versus global scope
• 3.3. Logical Expressions
  • C++ relational operators
  • Examples of simple relational expressions
  • C++ logical operators
  • Simple logical expressions
  • Truth tables for the logical operators
  • Short circuit evaluation
  • Short circuit examples
  • Alternate representations of Boolean values
  • Confusing the assignment and equality operators
• 3.4. Branching Overview
  • Branches in a computer program
  • 3.4.1. If-Statements
    • A logic diagram of a simple if-statement
    • if-Statement variations
    • Simple if-statement behavior
    • A logic diagram of an if-else statement
    • if-else statement variations
    • Logic diagram of an if-else ladder
    • if-else ladder variations
    • Diagonal if-else ladder
    • Complex if-else behavior
    • The dangling-else problem
    • Understanding the dangling-else code
    • The correcting the dangling-else problem
  • 3.4.2. temp.cpp (if Version)
    • temp.cpp
  • 3.4.3. switch Statements
    • Required switch elements
    • A basic switch statement
    • A case fall through
    • An implied logical-OR
    • Defining variables in a case (part 1)
    • Defining variables in a case (part 2)
    • Defining variables in a case (part 3)
    • switch-statement examples
  • 3.4.4. temp.cpp (switch Version)
    • switch example: temp.cpp
  • 3.4.5. Switches vs. If-Else Ladders
    • Simple multi-way branch options
    • The expressive power and flexibility of switches vs. if-else ladders
• 3.5. Looping Overview
  • C++ loop overview
  • 3.5.1. For-Loops
    • Loop control variables
    • Basic for-loop behavior
    • An infinite loop
    • The comma operator
    • Comma operator errors
    • Basic for-loop examples
    • Variations on counting
    • Nested for-loops
    • For-range loops
    • For-range loops with string data
    • For-range loops with arrays
  • 3.5.2. multtab.cpp
    • Calculating and displaying table elements
    • Aligning table output with setw
    • multtab.cpp program and output
  • 3.5.3. While-Loops
    • Basic while-loop behavior
    • Infinite while-loops
    • For-loop and while-loop equivalence
    • Simple while-loop examples
  • 3.5.4. gcd.cpp
    • gcd.cpp (loop version)
  • 3.5.5. Do-While-Loops
    • Basic do-while-loop behavior
    • do-while-loop formatting and scope
    • Simple do-while-loop examples
    • Data availability determines loop organization
  • 3.5.6. calc.cpp
    • do-while example: calc.cpp
    • A calc.cpp variation
  • 3.5.7. Understanding Loops
    • A simple for-loop
    • A longer-running for loop
  • 3.5.8. The Fence Post Problem
    • The off by one problem
    • The fence post problem
    • Solving the fence post problem: attempt 1
    • Solving the fence post problem: attempt 2
  • 3.5.9. Loops And The Debugger
    • Demonstrating the debugger with multtab.cpp
    • The "Run To Cursor" operation
    • Examining variable contents
    • Watching variables
    • The "Watch" window
    • Watch a second variable
    • Updating the watch window
    • The single-step button
    • Single-Stepping
    • Single-Stepping through nested loops
    • Stepping through the inner loop
    • Ending the inner loop
    • The second iteration of the outer loop
    • Ending the debug session
    • Clearing watches
• 3.6. Loop Interruption: break And continue
  • Organizing loops with break and continue operators
  • Loops and the break operator
  • Loops and the continue operator
  • Simplifying logic
  • Single loop interruption
  • Nested loops: interrupting the outer loop
  • Nested loops: interrupting the inner loop
• 3.7. Null Statements: Tricky Behavior Examined
  • Benign null statements
  • Malignant null statements
  • A beneficial null statement
  • Common null statement errors
• 3.8. More I/O Functions And Manipulators
  • Inserting newlines with endl
  • I/O stream flag functions
  • Configuring stream objects
  • Some useful manipulators
  • A partial but useful list of stream (istream and ostream) member functions
  • Left and right alignment
  • Columnar formatting: setw, left, and right
  • Formatting output with manipulators
  • Data and manipulator order
  • Formatting floating-point numbers
  • Formatting numbers with manipulators
  • get function examples
  • ignore function options
  • The newline problem
  • Reading single characters
  • Non-standard input functions
  • A _getch example
• 3.9. Character Classification and Conversion Functions
  • cctype: the character classification functions
  • cctype function examples
• 3.10. Programming Examples
  • 3.10.1. Special Variables: Flags And Accumulators
    • State diagram and code for a stopwatch
    • Using accumulators to gather data over time
  • 3.10.2. temp2.cpp
    • temp2.cpp: infinite loop with a menu
  • 3.10.3. temp3.cpp
    • temp3.cpp: infinite loop with a menu
  • 3.10.4. mortgage.cpp
    • Compound interest payment and amortization table: mortgage.cpp
    • mortgage.cpp output: An amortization table
  • 3.10.5. pyramid.cpp
    • The pyramid problem
    • Problem solving with pictures
    • Nested for-loops: pyramid.cpp
  • 3.10.6. wc.cpp
    • Word count program test case
    • Counting words separated by white-space characters
    • wc.cpp
    • Files in a Visual Studio project
    • Adding a text file to a project
    • Output from the wc program
• 3.12. Supplemental: Legitimate Uses For goto
  • Basic goto statements
  • Interrupting loops with break and continue
  • Interrupting nested loops with goto
  • UML states and transitions
  • State machine separating comments and code
  • A state machine implemented with goto

4. Pointers

• 4.1. Introduction To Pointers
  • Pointers cartoon
  • Files and Shortcuts
  • Instantiating an object in a Java program
  • Two ways to instantiate an object in a C++ program
• 4.2 Variables And Memory Addresses
  • Viewing main memory as an array of bytes
  • Houses as a metaphor for variables
  • Three characteristics of a variable
  • An abstract representation of a pointer
• 4.3. Pointer Operators
  • Three pointer operators and their contextual meaning
  • Understanding pointer operator behavior
  • Pointers and general operators
• 4.4. Dereferencing A Pointer: The Indirection Operator
  • Dereferencing a pointer variable
  • A dereference analogy
  • Summarizing the dereference operation
• 4.5. pointers.cpp
  • pointers.cpp
• 4.6. Memory Management: Stack And Heap
  • Demonstrations of stack behavior
  • Demonstration of heap behavior
• 4.7. Dynamic Memory: new And delete
  • Allocating memory with the new operator
  • Automatic variables on the stack pointing to dynamically allocated data on the heap
  • Returning allocated memory to the heap
• 4.8. Member Selection: Dot And Arrow
  • Creating an object in Java and accessing its features
  • Creating an object in C++ and accessing its features
  • Alternate member access syntax
• 4.9. Arithmetic Operations With Pointers
  • Comparing pointers
  • Using the null pointer
  • Steps for writing secure pointer programs
  • Arithmetic with 1-byte data elements
  • Arithmetic with multi-byte data elements
• 4.10. Uses For Pointers: Dynamic Data Structures
  • Two node options
  • A linked list
  • A binary tree
  • Inserting data into an array
  • Inserting data into a linked list
  • Appending a new node at the end of a list
  • The memory layout of the list created in Figure 6
  • Displaying all the data in a list
• 4.11. Pointers Summary
  • Automatic (stack) pointer variables and operators
  • Allocating, using, and deallocating dynamic memory

5. Structures

• 5.1. Introduction To Structures
  • Aggregate data examples
  • Fundamental type specifier examples
  • Programmer-created data types
• 5.2. Enumerations (enum)
  • Methods of creating symbolic constants
  • Benefits of symbolic constants
  • The enumeration syntax
  • Basic enumerations
  • The enumeration list
  • The enumeration tag (name)
  • The variable list
  • Eliminating "magic numbers"
  • Special value names
• 5.3. Structures
  • Defining structure variables
  • A structure Specification
  • Defining structure variables and objects
  • Aggregate initialization
  • Default field initialization
  • Designated initializers
  • The dot operator
  • The dot operator
  • The assignment operator works with structures
  • Passing a structure argument to a function
  • Returning a structure object from a function
• 5.4. Structures And Pointers
  • The dot and the arrow operators
  • Structures and indirection - dereferencing a structure pointer
  • Passing a struct as an argument
  • Passing a pointer to a structure
  • "Returning" values through pointer parameters
• 5.5. Structures and Multi-File Programs
  • A struct is a template that partitions memory contents into distinct variables
  • The problem with inconsistent structure specifications
  • The effect of changing struct specifications
  • Header files and multi-file programs
• 5.6. Creating Multi-File Programs With Visual Studio
  • Visual Studio: creating new program files
  • Visual Studio file indicators
• 5.7. Worked Examples
  • 5.7.1. The Time Structure Example (1)
    • The Time example architecture
    • Time.h
    • Time.cpp
    • driver.cpp
    • Formatted output: print revisited
  • 5.7.2. The American Structure Example
    • U.S. customary system volume measures
    • Converting tablespoons and teaspoons to fluid onces
    • Converting fluid onces and tablespoons to teaspoons
    • American.h
    • American.cpp
    • driver.cpp
  • 5.7.3. The Swapping Problem (2)
    • The swapping problem with structures
• 5.8. Supplemental
  • 5.8.1 Enumerations And Scope
    • Enumeration conflict example
    • Embedding an enumeration in a structure
    • Scoped and unscoped enumeration example
  • 5.8.2 Unions And Bit-Fields
    • A bit-field representing Unix file permissions
    • Structure vs. union
    • A union syntax example
    • Data packing and unpacking example
  • 5.8.3 typedef Statements
    • typedef syntax and example
    • C vs. C++
    • The stdio.h FILE type: A data hiding example

6. Functions

• 6.1. Functions
  • Visualizing function calls
  • An abstract representation of a functional decomposition
  • Bottom-up implementation
  • Stub functions in a top down implementation
• 6.2. Function Basics
  • A function as a black box
  • The parts of a function
  • Function call examples
  • 6.2.1. Function Definitions and Declarations
    • The relationship between a function definition and a prototype
    • Examples of simple and complex function definitions
    • Function definition, declaration, and prototype examples
    • Situations requiring prototypes
  • 6.2.2. Functions and Variable Scope
    • Defining and initializing a local variable
    • The relationship between a function call and a stack frame
    • Function-call vs. function-definition scope
    • Using a static variable
    • auto vs. static variables
    • Using global variables to eliminate function arguments
    • Variable name confusion and resolution
    • Controlling scope with the extern and static keywords
    • An abstract representation of function coupling
  • 6.2.3. Function Return, Part 1
    • Returning from a function
    • Returning a value
• 6.3. Function Arguments and Parameters
  • Argument vs. parameter
  • Passing arguments to parameters
  • 6.3.1. Pass-By-Value
    • Pass by value with simple data
    • Pass-by-value with structured data
    • Pass-by-value advantages and disadvantages
  • 6.3.2. Pass-By-Pointer
    • Pass-by-pointer with simple data
    • Pass-by-pointer with structured data
    • Advantages and disadvantages of pass-by-pointer
  • 6.3.3. Pass-By-Reference
    • Pass by reference with simple data
    • Pass by reference with structured data
    • Advantages and disadvantages of pass-by-reference
    • Programming examples: references vs. pointers
  • 6.3.4. Function Argument Passing Summary
    • Pass-by-value or pass-by-copy
    • Pass-by-pointer or pass by address
    • Pass-by-reference
    • Direction of data vs. passing technique
  • 6.3.5. Function Return Part 2
    • Return-by-value
    • Incorrect return-by-pointer
    • Correct return-by-pointer
    • Incorrect return-by-reference
    • Correct return-by-reference
    • Returning non-local data
• 6.4. Overloaded Functions
  • Overloaded functions: different parameter types
  • Overloaded functions: different number of parameters
  • Overloaded functions: one unique parameter
  • Unable to overload on return types
  • Unable to overload on pass-by-value vs. pass-by-reference
• 6.5. Default Arguments
  • Overloaded functions: simplicity vs. flexibility
  • Default arguments: simplicity vs. flexibility
  • Rule 1: creating functions
  • Rule 2: calling functions
  • Rule 3: separate prototypes and definitions
  • Rule 4: function calls may not be ambiguous
  • Calling a function with default arguments
• 6.6. Functions and the const Keyword
  • Pass-by-value "protects" function arguments
  • Pass-by-reference with a const parameter
  • Pass-by-pointer with a const parameter
  • Returning const references from a function
  • Returning const pointers from a function
  • Constant member functions
• 6.7. Macros and Inline Functions
  • Typical function call
  • Macro vs. inline function
  • Parameterized macro example
  • Correctable macro errors
  • Uncorrectable macro errors
  • Inline function example
  • Functions vs. inline functions
• 6.8. Recursion
  • Direct and indirect recursion
  • Simple recursion examples
  • Recursive function calls and stack frames
  • 6.8.1. Recursion Examples
    • A function to calculate n!
    • A function to find the n^th number in the Fibonacci sequence
    • A binary tree example
    • Recursive binary tree traversal functions
    • One function, three traversal orders
  • 6.8.2. Recursion V. Iteration
    • Euclid's Algorithm
    • Summary of recursion versus iteration
• 6.9. From Documentation To Programs
  • Features commonly found in C++ documentation
  • Detecting and reporting errors with errno and perror
  • The pow function: prototype and program
  • The ftime system call
  • A common documentation-to-code error
  • ftime: Windows pointer example
  • ftime: Unix / Linux / macOS pointer example
• 6.10. Functions And Link Errors
  • Syntax error diagnostic output
  • Basic syntax debugging
  • Argument and parameter counts don't match
  • Misspelled function name
  • Detecting link errors with header files
• 6.11. Avoiding Runtime Errors
  • The quadratic formula demonstrates detecting and responding to runtime errors
  • NaN and Inf: The IEEE 754 floating-point standard
  • System calls and error status
  • Application functions returning an error status
  • Using errno to detect and report errors
  • Reporting errors with perror
  • Assertion system examples
• 6.12. Worked Examples
  • 6.12.1. The Time Structure Example (2)
    • Updated version of Time.h
    • Building Time objects with the "make" functions
    • Adding two Time objects
    • Updated version of Time.cpp
    • Testing the Time structure and functions with a driver
  • 6.12.2. The Swapping Problem (3)
    • The swap function: pass-by-reference
    • The swap function: pass-by-pointer (1)
    • The swap function: pass-by-pointer (2)
• 6.13. Functions And The Debugger
  • Stepping buttons
• 6.14. Practice Problems
  • 6.14.1. Functions With Loops
    • Problems 4 - 6 Hints: Average or Mean
      • Calculating the average or mean of a sequence of numbers
    • Problem 1 Solution: Maximum Number With A For-Loop
      • max1 version 1: for-loop finding the largest entered number - first entered number version
      • max1 version 2: for-loop finding the largest entered number - smallest representable integer solution
    • Problem 2 Solution: Maximum Number With A While Loop
      • max2: while-loop finding the largest entered number
    • Problem 3 Solution: Maximum Number With A Do-While Loop
      • max3: do-while-loop finding the largest entered number
    • Problem 4 Solution: Average With A For-Loop
      • ave1: for-loop based function calculating a mean or average
    • Problem 5 Solution: Average With A While-Loop
      • ave2 version 1: while-loop based function calculating a mean or average
      • ave2 version 2: while-loop based function calculating a mean or average
    • Problem 6 Solution: Average With A Do-While-Loop
      • ave3: do-while-loop based function calculating a mean or average
• 6.15. Supplemental
  • 6.15.1. Storage Modifiers
    • auto
    • static
    • register
    • volatile
  • 6.15.2. Variable Argument Lists
    • Function calls with a variable number of arguments
    • The variable argument list macros
    • Defining and calling a function with a variable number of arguments
    • Defining and calling a function with a string-encoded variable argument list
  • 6.15.3. Pointers To Functions: Callback Functions
    • Function pointers: the first three steps of using callback functions
    • Example: atexit
    • Function pointers and callback functions

7. Arrays

• 7.1. Introduction To Arrays
  • Creating and using arrays
  • Array elements are variables
  • Aggregate data: arrays vs. structures
• 7.2. Visualizing Arrays
  • Array definitions and dimensions
  • A one-dimensional array
  • A two-dimensional array
  • A three-dimensional array
  • 7.2.1. Test Yourself
    • Two-dimensional array syntax
• 7.3. Creating Arrays
  • The name of an array is an address
  • Allocating memory for an array
  • Arrays created automatically and dynamically
  • A partially filled array
• 7.4. Initializing Arrays
  • Compile-time array initialization
  • Zeroing array elements
  • Array initialization: Days per month example
  • Initializing two-dimensional Arrays
  • Counting array elements
  • Understanding sizeof
• 7.5. Arrays: C++ vs. Java
  • Java arrays
  • Array indexes
  • Indexing C++ arrays out of bounds
  • Creating an array of objects in Java
  • Creating an array of objects in C++
• 7.6. Arrays And Loops
  • Processing arrays with for-loops
  • Arrays and indeterminate loops
  • Arrays and counting loops
  • Copying an array
• 7.7. Arrays And Functions
  • An array as a function argument
  • Passing arrays as function arguments
  • A function returning an array: A frequent error
  • Make the array static
  • A potential problem with the static solution
  • Define the array in the function caller's scope
  • One function but multiple array arguments
  • Allocate the array with the new operator
  • The dynamic array solution is flexible
  • Returning the number of used or filled elements in an array
  • Array of arrays: Creating and returning a two-dimensional array
• 7.8. Worked Examples
  • 7.8.1. average.cpp
    • average 1: Single function version
    • average 2: average function version
    • average 3: Console input and flexible average version
  • 7.8.2. multtab.cpp
    • multtab: Single function version
    • multtab: Multiple function version
  • 7.8.3. The Chi-Squared Statistic
    • The expected frequency
    • The chi-squared statistic
    • The chi-squared solution as a single function
    • Client-supplier chi-squared solution
  • 7.8.4. rms.cpp: Arrays, Functions, And Data Input
    • Translating the root mean square to C++
    • C++ RMS Function
    • The RMS program
• 7.9. Index Order
  • Array definitions and memory allocation
  • Mathematical matrices
  • Two-dimensional initializer list order
  • Extracting individual rows from two-dimensional arrays
  • Command-line arguments implemented as an array of strings
  • Java arrays
• 7.10. Row-Major Ordering
  • Mapping a two-dimensional array to one dimension
  • Two-dimensional array with row-major indexing
  • The multtab example with row-major indexing
  • Generalizing array functions with row-major ordering
  • Index function: dynamic and automatic arrays
• 7.11. Arrays And Security
  • Array out-of-bounds error
  • Validating user input
  • Guarding indeterminate loops
  • Validating index calculations
  • Arrays as function arguments
• 7.12. Stacks And Stack Operations
  • The primary stack operations
  • Implementing a stack as an array
  • The push operation illustrated
  • The pop operation illustrated
  • 7.12.1. Automatic Stack Implementation
    • stack.h (automatic structure version)
    • stack.cpp (automatic structure version)
    • test.cpp (automatic structure version)
  • 7.12.2. Dynamic Stack Implementation
    • dstack.h (dynamic structure version)
    • dstack.cpp (dynamic structure version)
    • dtest.cpp (dynamic structure version)
• 7.13. Dynamic And Multi-Dimensional Arrays
  • Automatic vs. dynamic array allocation
  • auto detecting a two-dimensional array type
  • The multtab example implemented as an array of arrays
  • 3D array: initialization order
  • Dynamic 3D array and row-major ordering
  • 3D array: row × column × layer order
  • 3D array: row × column × layer indexing
• 7.14. More Array Examples
  • 7.14.1. Selection Sort
    • Swapping the smallest and top elements
    • A selection sort testing driver
    • ssort function (1)
    • ssort function (2) swap
    • ssort function (3) with swap
    • Testing ssort with an array of structures
    • sort orders the structures by student ID
    • Implementing ssort with a swap function
    • Passing an array to the swap function
  • 7.14.2. Binary Search
    • Binary search
    • A driver to test and demonstrate binary search
    • A C++ implementation of binary search
    • Searching for objects based on one field
  • 7.14.3. Tic-Tac-Toe
    • Functional decomposition for the tic-tac-toe program
    • Drawing the tic-tac-toe game board
    • Options for representing the moves and the game board
    • Pseudo code solutions for the tic-tac-toe display function

8. Strings And C-Strings

• 8.1. Introduction To Strings And C-Strings
  • Fundamental string characteristics
• 8.2. C-Strings
  • Defining and initializing C-strings
  • Uninitialized character arrays
  • 8.2.1. C-string I/O
    • C-string output to the console
    • Printing string literals to the console
    • C-string input: failed version
    • C-string input: correct version
    • Revisiting the newline problem with C-strings
  • 8.2.2. C-String Documentation And Functions
    • The C-String header files
    • Null vs. empty C-Strings
    • Example C-string function documentation
    • Reading C-string documentation: A common error
    • 8.2.2.1. strlen
      • Getting the length of a C-string
      • Common strlen error
      • The strlen function
      • Implementing strlen
    • 8.2.2.2. strcpy
      • Copying C-Strings
      • Common strcpy errors
      • The strcpy function
      • Implementations of the standard strcpy function
    • 8.2.2.3. strcat
      • Concatenating C-Strings
      • Common strcat errors
      • The strcat function
      • Creating an empty C-string
      • Two implementations of the standard strcat function
    • 8.2.2.4. strcmp
      • String class vs. C-strings
      • Comparing C-Strings
      • strcmp return values
      • Equal strings
      • Ordering Strings with different content
      • Ordering strings with different lengths
      • Two implementations of strcmp
    • 8.2.2.5. More C-String Functions
      • Searching for a character in a C-String
      • Searching for a sub-string in a C-Strings
      • The strtok function
      • Parsing illustrated
      • Implementing strtok
      • Standard strtok function example
      • strtok_s and strtok_r examples
    • 8.2.2.6. C-Strings And Number Conversions
      • ASCII to number conversion functions
      • Advanced C-string to number conversion functions
      • The endptr parameter
      • Numbers to C-string functions
  • 8.2.3. name_box.cpp, Version 1
    • The first name-box problem
    • name_box1.cpp
  • 8.2.4. Command Line Arguments
    • Command line windows
    • Processing command line input
    • Accessing command line arguments
  • 8.2.5. name_box.cpp, Version 2
    • Entering the user's name on the command line
    • name_box2.cpp (version 1)
    • name_box2.cpp (version 2)
    • Entering command line arguments in Visual Studio
  • 8.2.6. The Palindrome-Number Problem
    • Identifying a palindrome by looking at pairs of characters
    • Identifying a non-palindrome string
    • Identifying a palindrome by reversing and comparing strings
    • Identifying a non-palindrome string
    • Palindrome-number problem logic diagram
  • 8.2.7. cpalnumber.cpp
    • The "finger" version of cpalnumber.cpp
    • C++ itoa function
    • The reverse version of cplanumber.cpp
    • A C-string reverse function
    • A general palindrome checker
• 8.3. The C++ string Class
  • The string class header file
  • string class constructors
  • string class constructors
  • string class operators
  • string operator examples
  • 8.3.1. string Class I/O
    • string object I/O example
    • C-string getline vs. string class getline
    • Revisiting the newline problem with string objects
  • 8.3.2. string Functions: Documentation And Examples
    • string length and capacity
    • Character access
    • The string assignment and concatenation operators
    • The string constant npos
    • The find and rfind functions
    • Converting numbers to strings
    • Converting string objects to numbers
    • The index argument
  • 8.3.3. name_box.cpp, Version 3
    • name_box3.cpp
  • 8.3.4. palnumber.cpp
    • The "finger" solution with the string class
    • The my_to_string function converts an integer to a string
    • Solving the palindrome-number problem by reversing a string
    • The string reverse function
  • 8.3.5. ipalnumber.cpp With string Iterators
    • A C++ container analogized as a basket
    • Iterator functions and operators
    • Iterator-based string reverse function using reverse iterators
    • Iterator-based string reverse function using forward iterators
• 8.4. A Comparison of the string Class and C-Strings
• 8.5. C-Strings and Scope
  • A logical scope error
  • static data
  • Consequences of static data
  • Dynamic data
  • Consequences of dynamic data
  • Calling-scope data
  • Combining calling-scope and dynamic data
• 8.6. Bulletproof Code: Strings → Numbers
  • A data input error
  • Validating integer input
  • Bulletproof input: Converting a string to an int
  • String conversion functions
  • Advanced string conversion function examples
  • C-string conversion functions
  • C-string conversion functions examples
• 8.7. Worked Examples
  • 8.7.1. pyramid.cpp, Version 2
    • Converting a C-string to an integer
    • Detecting the presence of command-line data
    • Converting a string object to an integer
  • 8.7.2. cube.cpp and ccube.cpp
    • cube.cpp
    • ccube.cpp (1)
    • ccube.cpp (2)
  • 8.7.3. Software Development: The Anagram Problem
    • The anagram normalization algorithm
    • Algorithm for counting the number of occurrences of each letter
    • Algorithm for detecting an anagram
    • Intermediate array-based algorithms
    • Mapping letters to indexes
    • Reading the input and printing the result
    • Program input
    • Converting a string to a normal form
    • Counting letter occurrences
    • C++ implementations of the detection algorithm
    • For-range loop syntax
    • For-range versions of two anagram algorithms
• 8.8. Searching and Sorting: bsearch And qsort
  • Ordering functions
  • Using void pointers
  • Prototypes for the qsort and bsearch library functions
  • An array of integers
  • demo1.cpp
  • C-string arrays
  • demo2.cpp
  • demo3.cpp
  • An array of structure objects
  • demo4.cpp prototypes
  • Searching and sorting objects by "name"
  • Searching and sorting objects by "id"
  • Searching and sorting objects by "gpa"

9. Classes And Objects

• 9.1. Classes And Objects
  • C++ feature visibility conceptualized as a Venn diagram
  • A C++ class specification
  • Creating objects and accessing their features
• 9.2. UML Class Diagrams
  • Mapping UML attributes to C++ member fields (aka member variables)
  • Mapping UML operations into C++ member functions
  • A UML class diagram and corresponding C++ class
• 9.3. Test Yourself: Translating Basic UML to C++
  • Translating a UML class diagram to C++
  • 9.3.1. C++ Class Self Test Answers
    • Version 1: Variables and functions separate
    • Version 2: Private and public members together
• 9.4. Class Development
  • The classes in an object-oriented program are conceptualized as a hierarchy or tree
  • Lego blocks as a metaphor for a public interface
  • An abstract representation of an object's public interface
• 9.5. Member Functions and Program Organization
  • Member function calls are bound to objects
  • The structure version of the add function
  • Member function options
  • Member variable access
  • Implicit and explicit arguments
  • The add function defined outside the class
  • Member function definitions: inside vs. outside the class
• 9.6. Constructors And Initializer Lists
  • Overloaded constructors
  • Default constructor examples
  • Conversion constructors
  • Copy constructor example
  • A special case for returning objects
  • A general constructor
  • Argument list notation
  • Initializer list vs. assignment: Member initialization
  • Constructor data flow
  • Using separate header and source code files
  • A common error: Braces form a function body
  • Converting UML to C++
  • Locating default arguments and initializer lists
  • Alternate member initialization
  • Constructor chaining (aka constructor delegation)
  • Using a helper function to implement common constructor code
• 9.7. student Class Example
  • The student UML class diagram
  • The student example
• 9.8. Creating And Destroying Objects: new And delete
  • Instantiating objects with the new operator
  • Creating object arrays with the new operator
  • Deallocating dynamic objects with C++'s delete operator
  • Creating partially filled arrays of object pointers
  • Arrays and feature access
• 9.9. Access Functions: Getters and Setters
  • Access function examples
  • Setters and getters: Creating a stable public interface
• 9.10. The this Pointer: class stack
  • A stack implemented as a structure
  • A stack implemented as a class
  • The C++ compiler automatically generates the function/object binding
  • The stack member functions
  • this binds objects to member functions
• 9.11. const And Classes
  • const parameters
  • Return-by-value getter functions
  • The problem of a return-by-pointer getter function
  • Returning a constant pointer
• 9.12. Namespaces And The Scope Resolution Operator
  • Namespaces and the scope resolution operator
  • Clarifying ambiguous scope with the scope resolution operator
• 9.13. static Variables And Functions
  • Denoting static features in a UML class diagram
  • static example
  • Class constants
• 9.14. An Introduction To Exception Handling
  • The four keywords for robust exception handling
  • An unignorable exception example
  • Exceptions and flow of control
  • Fundamental-type exceptions
  • stack class with exceptions: Version 1
  • stack class with exceptions: Version 2
• 9.15. Worked Examples
  • 9.15.1. Time Example (Class Version)
    • The Time UML class diagram
    • Time.h (class version)
    • Time.cpp (class version)
    • driver.cpp (class version)
  • 9.15.2. fraction 1 Example
    • The fraction class
    • The fraction constructor
    • The fraction arithmetic formulas
    • Converting the fraction formulas into C++ code
    • Implementing the fraction arithmetic functions
    • The fraction input and output (I/O) functions
    • Throwing and catching an exception
    • Using the fraction class
  • 9.15.3 Software Development With Objects: The Pouring Puzzle
    • The Pouring Puzzle
    • The roles and attributes of glasses in the pouring puzzle
    • Glass UML class diagram
    • Calculating how much water to pour
    • Glass objects and their interactions
    • Selection logic with six separate variables
    • A more elegant solution based on an array of Glass objects
    • Defining the glasses array and calling the pour function
    • The pouring puzzle problem logic diagram
    • 9.15.3.1. Pouring Puzzle: Pass-by-Reference
      • Glass UML diagram: Pass-by-reference version
      • Glass.h
      • Glass.cpp: Initialize glasses & implement pour as pass-by-reference
      • game.cpp: Implementing the game logic
    • 9.15.3.2. Pouring Puzzle: Pass-by-Pointer
      • Glass UML diagram: Pass-by-pointer version
      • Glass.h
      • Glass.cpp: Initialize glasses & implement pour as pass-by-pointer
      • game.cpp
  • 9.15.4. Problem Solving: Strings
    • String elements
    • String abstract data type
    • 9.15.4.1. Length-Prefixed String Example
      • Length-prefixed string
      • The LPString class
      • The LPString default constructor
      • The LPString(char*) conversion constructor
      • The LPString(char) conversion constructor
      • The LPString copy constructor
      • The LPString length function
      • The LPString at function
      • The LPString static print function
      • The LPString print and println member functions
      • The LPString readln function
      • The LPString clear function
      • The LPString append function
      • The LPString copy function
      • The LPString substring function
      • The LPString equals function
      • The LPString order function
      • The LPString concat function
      • The LPString insert function
      • LPString concat Solution
        • concat validation
        • concat steps 2 and 3: create and initialize local
        • concat steps 4 and 5: append s to local and update its length
        • Complete versions of the concat function
      • LPString insert Solution
        • The insert starting point
        • Step 3: shifting text
        • Step 4: copying the characters
        • Step 5: update this string's length
        • The complete LPString insert function
    • 9.15.4.2. CString Class Example
      • CString: A C-string based class
      • The CString class specification
      • CString constructors and destructor: building and destroying objects
      • CString access functions
      • CString I/O functions
      • The CString readln() function
      • The CString append and clear functions
      • The CString insert function
      • The CString copy and concat functions
      • The CString substring function
      • The CString equals and order functions
      • The CString grow function
    • 9.15.4.3. String Class Example
      • The String class
      • String constructors and destructor: building and destroying objects
      • String access functions
      • I/O system calls
      • String I/O functions
      • String functions that modify this object
      • Functions that create, fill, and return a new String object
      • The String equals and order functions
      • The String grow and set_capacity function
  • 9.15.5. Stopwatch Example
    • A stopwatch modeling example
    • The Stopwatch UML class diagram
    • The Stopwatch state machine
    • Getting the time since the epoch
    • The Stopwatch class
    • The Stopwatch stime function
    • main: The Stopwatch client

10. Multi-Class Programs & The UML

• 10.1. Multi-Class Programs And The UML
  • UML class relationships
  • Sending a message in a whole-part relationship
  • Relationship properties: A categorization system
  • A dichotomous key for identifying UML class relationships
• 10.2. Inheritance
  • Inheritance
  • Inheritance as generalization
  • Inheriting functions and variables
  • Class similarities and differences
  • Instantiating a subclass: An abstract representation
  • Substitutability
  • Inheritance property values
  • 10.2.1. Building Inheritance
    • A simple inheritance hierarchy
    • Implementing inheritance in C++
    • Calling a superclass default constructor
    • Constructor call chains
    • Inheritance vs. initializer lists
    • Constructor parameter names
    • Data flow in chained constructor calls
  • 10.2.2. Using Inheritance
    • An inheritance hierarchy
    • Overloaded vs. overridden functions
    • Chaining overridden function calls
    • Examining inheritance
  • 10.2.3. Inheritance Example: Actor 1
    • A three-class inheritance example
    • Actor1.cpp: multi-level inheritance
  • 10.2.4. #pragma and #ifndef: Actor 2
    • Alternate class specifications: prototypes vs. inline
    • The #include guard directives
    • Robust vs. error-prone header files
    • Actor2: Person.h
    • Actor2: Actor.h
    • Actor2: Star.h
    • Actor2: driver.cpp
  • 10.2.5. Multiple Inheritance
    • Multiple Inheritance
    • Using multiple inheritance
    • The deadly diamond
• 10.3. Constructive Relationships
  • Constructive or "has-a" relationships
  • Modeling with library classes
• 10.4. Composition: Embedded Objects
  • The Time class and object
  • Building a whole-part object with composition
  • Composition property values
  • 10.4.1. Building Composition
    • Constructing or initializing a part-object with a default constructor
    • Constructing a part-object with a parameterized constructor
    • Combining inheritance and composition (example 1)
    • Combining inheritance with a whole-part (example 2)
  • 10.4.2. Using Composition
    • Using simple composition
    • Using inheritance and composition (example 1)
    • Using inheritance and composition (example 2)
• 10.5. Aggregation: Pointer Member Variables
  • A class with a pointer member variable
  • Building a whole-part object with aggregation
  • Aggregation property values
  • 10.5.1. Building Aggregation
    • Aggregation: a whole-part or "Has A" relationship
    • Aggregation with the Person class
    • Constructor options and examples
    • Managing an aggregation relationship with a setter function
    • Sharing objects through pointers
    • Inheritance and aggregation example 1
    • Inheritance and aggregation example 2
  • 10.5.2. Destructors
    • Allocating and deallocating heap memory
    • Memory leak examples
    • Constructors vs. destructors
    • A simple destructor example
    • Preventing memory leaks with destructors
  • 10.5.3. Using Aggregation
    • Using simple aggregation
    • Using inheritance and aggregation (example 1)
    • Using inheritance and aggregation (example 2)
  • 10.5.4. Overriding The Copy Constructor
    • Operations copying objects
    • Copying a "simple" object with the compiler-created copy constructor
    • Copying a "complex" object with the compiler-created copy constructor
    • Overriding the copy constructor
• 10.6. Inheritance And Whole-Part: Actor 3
  • UML class diagram with inheritance, composition, and aggregation
  • The Actor 3 Address and Date classes
  • Actor 3 Person.h file
  • Aggregation setter function options
  • The Actor 3 Actor class
  • The Actor 3 Star class
• 10.7. Multiplicity
  • The Hand, Deck, and Card classes: An introduction to multiplicity
  • UML multiplicity operators
  • Relationship names vs. multiplicity operators
  • Shuffling the deck
  • Implementing multiple aggregation: array version
  • Deck shuffle and swap member functions: array versions
  • Aggregation driver
  • The Deck class: vector version
  • The Deck deal function: vector version
  • Overloaded swap functions
  • The Deck shuffle functions: vector versions
• 10.8. Association
  • Building objects related by association
  • Clarifying the association reading direction
  • Solving association's cross reference problem with forward declarations
  • Association restricts some inline functions
  • Association property values
  • 10.8.1. Building Association
    • Creating association with setter functions
    • Creating association with constructors
  • 10.8.2. Using Association
    • A typical association example
    • Association Scenario 1: Illegal move
    • Association Scenario 2: Valid move
    • Association Scenario 3: Remote move
    • Message passing in association relationships
    • Incorrect use of association
    • Correctly calling the member functions of associated classes
  • 10.8.3. Multiple Association
    • Association with multiplicity operators
    • Link classes in a many-to-many association
    • An example of many-to-many objects connected by links
• 10.9. Dependency
  • Implementing a dependency relationship
  • Message forwarding
  • Dependency property values
• 10.10. Vet 1 Example
  • Vet 1 class diagram
  • vet.cpp
  • The vet association classes
  • The vet subclasses
  • The vet part classes
• Relationships: Categories And Properties
  • From property values to relationship categories
  • Summary of relationship property values

11. Overloaded Operators

• 11.1. Overloaded Operators and friend Functions
  • Declaring a function as a friend
  • The relationship between operator operands and function arguments
• 11.2. Overloaded Operators As Member Functions
  • The fraction constructor with default arguments
  • Overloaded operators are implemented with member functions
  • A simple driver to test the overloaded fraction operators
  • Two ways of calling an overloaded binary operator
  • The relationship between operands and member-function arguments
  • Adding a fraction and an integer
• 11.3. Overloaded Operators As friend Functions
  • Commutativity and overloaded operators
  • Non-member overloaded operators
  • A single friend overloaded operator+
• 11.4. Conversion Operations
  • The fraction conversion constructor
  • The Time add function
  • Overloaded Time conversion operator
  • Overloaded conversion operator example
  • Conversion operator applications
  • Conversion conflicts
• 11.5. operator<< And operator>>
  • Overloaded functions
  • The inserter and extractor operator prototypes in <iostram>
  • 11.5.1. Overloading operator<< and operator>>
    • Patterns in operator<< and operator>>
    • Abridged version of the fraction class
  • 11.5.2. operator<< And operator>>With Inheritance
    • Chaining inserter calls from subclasses to superclasses
    • Chaining extractor calls from subclasses to superclasses
  • 11.5.3. operator<< And operator>> With Whole-Part
    • Chaining the I/O operators in composition
    • Chaining the I/O operations in aggregation
  • 11.5.4. Actor 4: Chaining Operators And Function Calls
    • Program architecture: The Actor 4 UML class diagram
    • Actor 4 support functions: Constructors, destructor, and setter functions
    • Actor 4: Chaining general constructors
    • Actor 4: Chaining member functions
    • Actor 4: Part classes I/O functions
    • Actor 4: Person overloaded I/O operators
    • Actor 4: Actor and Star overloaded I/O operators
    • Actor 4: main
    • Actor 4 output
• 11.6. operator=
  • The compiler-generated assignment operator
  • The compiler-created assignment operator function
  • Overloaded assignment operator for complex objects
  • 11.6.1. Person.cpp: Copy Constructor and Assignment Operator
    • Person class specification
    • Person copy constructor
    • Person assignment operator
    • Person extractor
    • Support functions
    • main
• 11.7. operator[]
  • The fundamental or original index operator
  • Overloading operator[]
  • Fundamental vs. overloaded index operators
  • 11.7.1. Array 1: Overloaded operator[]
    • Array class
    • The relationship between logical and physical index values
    • The Array class constructor
    • The Array class overloaded index operator
    • Testing the Array class
• 11.8. Practice Problems / Worked Examples
  • Overloaded operators problem with the Time class
  • Overloaded operators problem with the fraction class
  • 11.8.1. Time Example (Overloaded Operators Version)
    • The Time UML class diagram with overloaded operators
    • Time.h (operator version)
    • Time.cpp (operator version)
    • Alternate operator>>
    • driver.cpp
    • The Time UML class diagram with a friend (non-member) operator+
    • Time.h
    • friend operator+
  • 11.8.2. fraction 2 Example (Overloaded Operators Version)
    • fraction.h: fraction 2 example
    • fraction.cpp: constructor
    • fraction.cpp: fraction arithmetic operators
    • fraction.cpp: fraction I/O operators
    • fraction.cpp: helper functions
    • calc.cpp: fraction 2 version
    • calc.cpp: fraction 2, do-while loop

12. Polymorphism

• 12.1. An Introduction To Polymorphism
  • Specifying shape classes
  • Instantiating a specific shape object
  • Drawing the shape
  • Adding a new Shape class
• 12.2. Casting Objects
  • Upcasting in the inserter operator
  • Upcasting options
  • Upcasting with assignment
  • Upcasting by calling a function
  • Downcast example
  • 12.2.1. Casting And Member Variables
    • Locating a house with an offset
    • Calculating offsets: Locating data in a Person object
    • Accessing member variables in classes related by inheritance
    • Downcasting to reach subclass member variables
  • 12.2.2. Safe Casting
    • Employee is a subclass of Person
    • Upcasting vs. downcasting
    • A superclass with many subclasses
    • Upcasting with automatic or local variables results in slicing
  • 12.2.3. Casting And Member Functions
    • Member functions in an inheritance relationship
    • Selecting which function runs
• 12.3. Polymorphism In Depth
  • UML class diagram of the Shape classes
  • Making functions virtual
  • Instantiating a Shape object
  • Drawing the shape polymorphically
  • Example vs. typical Upcasting
  • Different kinds of employees
  • Overridden calc_pay functions
  • Safe downcasting with typeid or dynamic_cast
• 12.4. Actor 5: A Polymorphism Example
  • Enabling polymorphism
  • The client's contribution to polymorphism
  • Polymorphic behavior
  • A circularly-linked list
  • CList member functions
  • Inserting data (instances of Person and its subclasses) into a list
• 12.5. Pure Virtual Functions and Abstract Classes
  • UML class diagram of the Shape classes
  • The Shape draw function: Creating an abstract class
  • The role of pure virtual functions
  • Virtual functions in an inheritance hierarchy
  • Chaining overridden functions
  • Chaining to pure virtual functions
• 12.6. Implementing Polymorphism
  • Inheritance and constructors
  • The Shape inheritance hierarchy
  • Implementing polymorphism
  • Dynamic dispatch: calling a polymorphic function
• 12.7. Mahjong Tiles: Outlining A Polymorphic Solution
  • Mahjong tiles UML class diagram
  • The Tile class
  • The RankTile class
  • The CircleTile and BambooTile classes
  • The CharacterTile class
  • The WhiteDragon class
  • The PictureTile classes

13. Templates

• 13.1. Introduction To Templates
  • The evolution of the sqrt function
  • The ANSI C++98 and C++11 standards
• 13.2. Template Functions
  • Defining and calling a template-based swap function
  • <algorithm> min template functions
  • The min template function and fundamental data types
  • The min template function and "natural" ordering (operator<)
  • The min template function and comparator functions
  • The min template function and comparator objects
• 13.3. Template Classes
  • stack.h: a template version of the stack class
  • Using a template class
  • Creating and using template constants
  • Stack size specified by a template argument
  • Creating an instance of a class with constant value expressions
• 13.4. Binary Trees: Template Examples
  • Standard dynamic data structure operations
  • A binary tree and the operational pointers
  • Descending the tree: searching and inserting
  • The remove operation: Leaf (no subtrees)
  • The remove operation: One subtree
  • The remove operation: Two subtrees
  • 13.4.1. Tree Example 1: One Template Variable
    • Employee.h: The Employee class specification
    • Tree.h: The Tree class specification
    • Tree.h: The Tree destructor
    • Tree.h: The Tree insert function
    • Tree.h: The Tree search function
    • Three.h: The public Tree remove function
    • Tree.h: The private Tree remove function
    • Tree.h: The private Tree _list function
    • Tree.h: The Tree tree_view function
    • Tree.h: The private subtrees function
    • Using a template class
  • 13.4.2. Tree Example 2: Two Template Variables
    • Two template-variable binary tree class
    • insert and other member functions
    • Modified Employee class
    • A simple driver validating the KVTree and its functions
    • The two-template variable Employee example
    • Specifying a nested class
    • KVTree members supporting iterators
    • The iterator class and functions
    • The complete WordCount program
• 13.5. Array 2: Flexible Arrays
  • The Array class
  • array2.cpp: Another anagram solution
• 13.6. The Standard Template Library (STL)
  • 13.6.1. STL Examples: map, list, pair, and iterator
    • The pair structure specification
    • An STL list storing a client structure
    • An STL list storing a pair object
    • WordCount_tree: KVTree with an STL list and iterator
    • WordCount_tree: KVTree with list, pair, and iterator
    • WordCount_map: STL map solution
• 13.7. An Introduction To Smart Pointers
  • Smart pointer summary
  • Basic smart pointer behavior
  • Components in common with all smart pointer examples
  • Creating and using a unique_ptr
  • Creating and using shared_ptr objects
  • Making and using a weak_ptr objects
  • 13.7.1. Aggregation With Smart Pointers
    • Aggregation without smart pointers
    • Implementing simple aggregation with smart pointers
    • Implementing shared aggregation with smart pointers
    • The part classes
    • The whole classes
    • Implementing shared aggregation with smart pointers
    • The one-to-many Warehouse class
    • The one-to-many driver and its output

14. Streams (File I/O)