Thinking in C++ - Volume 1

0. Preface
0.1. What’s new in the second edition
0.1.1. What’s in Volume 2 of this book
0.1.2. How to get Volume 2
0.2. Prerequisites
0.3. Learning C++
0.4. Goals
0.5. Chapters
0.6. Exercises
0.6.1. Exercise solutions
0.7. Source code
0.8. Language standards
0.8.1. Language support
0.9. The book’s CD ROM
0.10. CD ROMs, seminars,and consulting
0.11. Errors
0.12. About the cover
0.13. Book design and production
0.14. Acknowledgements

1. Introduction to Objects
1.1. The progress of abstraction
1.2. An object has an interface
1.3. The hidden implementation
1.4. Reusing the implementation
1.5. Inheritance:reusing the interface
1.5.1. Is-a vs. is-like-a relationships
1.6. Interchangeable objects with polymorphism
1.7. Creating and destroying objects
1.8. Exception handling: dealing with errors
1.9. Analysis and design
1.9.1. Phase 0: Make a plan
1.9.2. Phase 1: What are we making?
1.9.3. Phase 2: How will we build it?
1.9.4. Phase 3: Build the core
1.9.5. Phase 4: Iterate the use cases
1.9.6. Phase 5: Evolution
1.9.7. Plans pay off
1.10. Extreme programming
1.10.1. Write tests first
1.10.2. Pair programming
1.11. Why C++ succeeds
1.11.1. A better C
1.11.2. You’re already on the learning curve
1.11.3. Efficiency
1.11.4. Systems are easier to express and understand
1.11.5. Maximal leverage with libraries
1.11.6. Source-code reuse with templates
1.11.7. Error handling
1.11.8. Programming in the large
1.12. Strategies for transition
1.12.1. Guidelines
1.12.2. Management obstacles
1.13. Summary

2. Making & Using Objects
2.1. The process of language translation
2.1.1. Interpreters
2.1.2. Compilers
2.1.3. The compilation process
2.2. Tools for separate compilation
2.2.1. Declarations vs. definitions
2.2.2. Linking
2.2.3. Using libraries
2.3. Your first C++ program
2.3.1. Using the iostreams class
2.3.2. Namespaces
2.3.3. Fundamentals of program structure
2.3.4. "Hello, world!"
2.3.5. Running the compiler
2.4. More about iostreams
2.4.1. Character array concatenation
2.4.2. Reading input
2.4.3. Calling other programs
2.5. Introducing strings
2.6. Reading and writing files
2.7. Introducing vector
2.8. Summary
2.9. Exercises

3. The C in C++
3.1. Creating functions
3.1.1. Function return values
3.1.2. Using the C function library
3.1.3. Creating your own libraries with the librarian
3.2. Controlling execution
3.2.1. True and false
3.2.2. if-else
3.2.3. while
3.2.4. do-while
3.2.5. for
3.2.6. The break and continue keywords
3.2.7. switch
3.2.8. Using and misusing goto
3.2.9. Recursion
3.3. Introduction to operators
3.3.1. Precedence
3.3.2. Auto increment and decrement
3.4. Introduction to data types
3.4.1. Basic built-in types
3.4.2. bool, true, & false
3.4.3. Specifiers
3.4.4. Introduction to pointers
3.4.5. Modifying the outside object
3.4.6. Introduction to C++ references
3.4.7. Pointers and references as modifiers
3.5. Scoping
3.5.1. Defining variables on the fly
3.6. Specifying storage allocation
3.6.1. Global variables
3.6.2. Local variables
3.6.3. static
3.6.4. extern
3.6.5. Constants
3.6.6. volatile
3.7. Operators and their use
3.7.1. Assignment
3.7.2. Mathematical operators
3.7.3. Relational operators
3.7.4. Logical operators
3.7.5. Bitwise operators
3.7.6. Shift operators
3.7.7. Unary operators
3.7.8. The ternary operator
3.7.9. The comma operator
3.7.10. Common pitfalls when using operators
3.7.11. Casting operators
3.7.12. C++ explicit casts
3.7.13. sizeof – an operator by itself
3.7.14. The asm keyword
3.7.15. Explicit operators
3.8. Composite type creation
3.8.1. Aliasing names with typedef
3.8.2. Combining variables with struct
3.8.3. Clarifying programs with enum
3.8.4. Saving memory with union
3.8.5. Arrays
3.9. Debugging hints
3.9.1. Debugging flags
3.9.2. Turning variables and expressions into strings
3.9.3. The C assert( ) macro
3.10. Function addresses
3.10.1. Defining a function pointer
3.10.2. Complicated declarations & definitions
3.10.3. Using a function pointer
3.10.4. Arrays of pointers to functions
3.11. Make: managing separate compilation
3.11.1. Make activities
3.11.2. Makefiles in this book
3.11.3. An example makefile
3.12. Summary
3.13. Exercises

4. Data Abstraction
4.1. A tiny C-like library
4.1.1. Dynamic storage allocation
4.1.2. Bad guesses
4.2. What's wrong?
4.3. The basic object
4.4. What's an object?
4.5. Abstract data typing
4.6. Object details
4.7. Header file etiquette
4.7.1. Importance of header files
4.7.2. The multiple-declaration problem
4.7.3. The preprocessor directives #define, #ifdef, and #endif
4.7.4. A standard for header files
4.7.5. Namespaces in headers
4.7.6. Using headers in projects
4.8. Nested structures
4.8.1. Global scope resolution
4.9. Summary
4.10. Exercises

5. Hiding the Implementation
5.1. Setting limits
5.2. C++ access control
5.2.1. protected
5.3. Friends
5.3.1. Nested friends
5.3.2. Is it pure?
5.4. Object layout
5.5. The class
5.5.1. Modifying Stash to use access control
5.5.2. Modifying Stack to use access control
5.6. Handle classes
5.6.1. Hiding the implementation
5.6.2. Reducing recompilation
5.7. Summary
5.8. Exercises

6. Initialization & Cleanup
6.1. Guaranteed initialization with the constructor
6.2. Guaranteed cleanup with the destructor
6.3. Elimination of the definition block
6.3.1. for loops
6.3.2. Storage allocation
6.4. Stash with constructors and destructors
6.5. Stack with constructors & destructors
6.6. Aggregate initialization
6.7. Default constructors
6.8. Summary
6.9. Exercises

7. Function Overloading & Default Arguments
7.1. More name decoration
7.1.1. Overloading on return values
7.1.2. Type-safe linkage
7.2. Overloading example
7.3. unions
7.4. Default arguments
7.4.1. Placeholder arguments
7.5. Choosing overloading vs. default arguments
7.6. Summary
7.7. Exercises

8. Constants
8.1. Value substitution
8.1.1. const in header files
8.1.2. Safety consts
8.1.3. Aggregates
8.1.4. Differences with C
8.2. Pointers
8.2.1. Pointer to const
8.2.2. const pointer
8.2.3. Assignment and type checking
8.3. Function arguments & return values
8.3.1. Passing by const value
8.3.2. Returning by const value
8.3.3. Passing and returning addresses
8.4. Classes
8.4.1. const in classes
8.4.2. Compile-time constants in classes
8.4.3. const objects & member functions
8.5. volatile
8.6. Summary
8.7. Exercises

9. Inline Functions
9.1. Preprocessor pitfalls
9.1.1. Macros and access
9.2. Inline functions
9.2.1. Inlines inside classes
9.2.2. Access functions
9.3. Stash & Stack with inlines
9.4. Inlines & the compiler
9.4.1. Limitations
9.4.2. Forward references
9.4.3. Hidden activities in constructors & destructors
9.5. Reducing clutter
9.6. More preprocessor features
9.6.1. Token pasting
9.7. Improved error checking
9.8. Summary
9.9. Exercises

10. Name Control
10.1. Static elements from C
10.1.1. static variables inside functions
10.1.2. Controlling linkage
10.1.3. Other storage class specifiers
10.2. Namespaces
10.2.1. Creating a namespace
10.2.2. Using a namespace
10.2.3. The use of namespaces
10.3. Static members in C++
10.3.1. Defining storage for static data members
10.3.2. Nested and local classes
10.3.3. static member functions
10.4. Static initialization dependency
10.4.1. What to do
10.5. Alternate linkage specifications
10.6. Summary
10.7. Exercises

11. References & the Copy-Constructor
11.1. Pointers in C++
11.2. References in C++
11.2.1. References in functions
11.2.2. Argument-passing guidelines
11.3. The copy-constructor
11.3.1. Passing & returning by value
11.3.2. Copy-construction
11.3.3. Default copy-constructor
11.3.4. Alternatives to copy-construction
11.4. Pointers to members
11.4.1. Functions
11.5. Summary
11.6. Exercises

12. Operator Overloading
12.1. Warning & reassurance
12.2. Syntax
12.3. Overloadable operators
12.3.1. Unary operators
12.3.2. Binary operators
12.3.3. Arguments & return values
12.3.4. Unusual operators
12.3.5. Operators you can’t overload
12.4. Non-member operators
12.4.1. Basic guidelines
12.5. Overloading assignment
12.5.1. Behavior of operator=
12.6. Automatic type conversion
12.6.1. Constructor conversion
12.6.2. Operator conversion
12.6.3. Type conversion example
12.6.4. Pitfalls in automatic type conversion
12.7. Summary
12.8. Exercises

13. Dynamic Object Creation
13.1. Object creation
13.1.1. C’s approach to the heap
13.1.2. operator new
13.1.3. operator delete
13.1.4. A simple example
13.1.5. Memory manager overhead
13.2. Early examples redesigned
13.2.1. delete void* is probably a bug
13.2.2. Cleanup responsibility with pointers
13.2.3. Stash for pointers
13.3. new & delete for arrays
13.3.1. Making a pointer more like an array
13.4. Running out of storage
13.5. Overloading new & delete
13.5.1. Overloading global new & delete
13.5.2. Overloading new & delete for a class
13.5.3. Overloading new & delete for arrays
13.5.4. Constructor calls
13.5.5. placement new & delete
13.6. Summary
13.7. Exercises

14. Inheritance & Composition
14.1. Composition syntax
14.2. Inheritance syntax
14.3. The constructor initializer list
14.3.1. Member object initialization
14.3.2. Built-in types in the initializer list
14.4. Combining composition & inheritance
14.4.1. Order of constructor & destructor calls
14.5. Name hiding
14.6. Functions that don’t automatically inherit
14.6.1. Inheritance and static member functions
14.7. Choosing composition vs. inheritance
14.7.1. Subtyping
14.7.2. private inheritance
14.8. protected
14.8.1. protected inheritance
14.9. Operator overloading & inheritance
14.10. Multiple inheritance
14.11. Incremental development
14.12. Upcasting
14.12.1. Why “upcasting?”
14.12.2. Upcasting and the copy-constructor
14.12.3. Composition vs. inheritance (revisited)
14.12.4. Pointer & reference upcasting
14.12.5. A crisis
14.13. Summary
14.14. Exercises

15. Polymorphism & Virtual Functions
15.1. Evolution of C++ programmers
15.2. Upcasting
15.3. The problem
15.3.1. Function call binding
15.4. virtual functions
15.4.1. Extensibility
15.5. How C++ implements late binding
15.5.1. Storing type information
15.5.2. Picturing virtual functions
15.5.3. Under the hood
15.5.4. Installing the vpointer
15.5.5. Objects are different
15.6. Why virtual functions?
15.7. Abstract base classes and pure virtual functions
15.7.1. Pure virtual definitions
15.8. Inheritance and the VTABLE
15.8.1. Object slicing
15.9. Overloading & overriding
15.9.1. Variant return type
15.10. virtual functions & constructors
15.10.1. Order of constructor calls
15.10.2. Behavior of virtual functions inside constructors
15.11. Destructors and virtual destructors
15.11.1. Pure virtual destructors
15.11.2. Virtuals in destructors
15.11.3. Creating an object-based hierarchy
15.12. Operator overloading
15.13. Downcasting
15.14. Summary
15.15. Exercises

16. Introduction to Templates
16.1. Containers
16.1.1. The need for containers
16.2. Overview of templates
16.2.1. The template solution
16.3. Template syntax
16.3.1. Non-inline function definitions
16.3.2. IntStack as a template
16.3.3. Constants in templates
16.4. Stack and Stashas templates
16.4.1. Templatized pointer Stash
16.5. Turning ownership on and off
16.6. Holding objects by value
16.7. Introducing iterators
16.7.1. Stack with iterators
16.7.2. PStash with iterators
16.8. Why iterators?
16.8.1. Function templates
16.9. Summary
16.10. Exercises

17. A: Coding Style

18. B: Programming Guidelines

19. C: Recommended Reading
19.1. C
19.2. General C++
19.2.1. My own list of books
19.3. Depth & dark corners
19.4. Analysis & design