Thinking in C++ - Volume 2

0. Introduction
0.1. Goals
0.2. Chapters
0.3. Exercises
0.3.1. Exercise solutions
0.4. Source code
0.5. Compilers
0.6. Language standards
0.7. Seminars, CD–ROMs & consulting
0.8. Errors
0.9. About the cover
0.10. Acknowledgements

1.0. Introduction

1.1. Exception Handling
1.1.1. Traditional error handling
1.1.2. Throwing an exception
1.1.3. Catching an exception
1.1.3.1. The try block
1.1.3.2. Exception handlers
1.1.3.3. Termination and resumption
1.1.4. Exception matching
1.1.4.1. Catching any exception
1.1.4.2. Rethrowing an exception
1.1.4.3. Uncaught exceptions
1.1.5. Cleaning up
1.1.5.1. Resource management
1.1.5.2. Making everything an object
1.1.5.3. auto_ptr
1.1.5.4. Function–level try blocks
1.1.6. Standard exceptions
1.1.7. Exception specifications
1.1.7.1. Better exception specifications?
1.1.7.2. Exception specifications and inheritance
1.1.7.3. When not to use exception specifications
1.1.8. Exception safety
1.1.9. Programming with exceptions
1.1.9.1. When to avoid exceptions
1.1.9.2. Typical uses of exceptions
1.1.10. Overhead
1.1.11. Summary
1.1.12. Exercises

1.2. Defensive Programming
1.2.1. Assertions
1.2.2. A simple unit test framework
1.2.2.1. Automated testing
1.2.2.2. The TestSuite Framework
1.2.2.3. Test suites
1.2.2.4. The test framework code
1.2.3. Debugging techniques
1.2.3.1. Trace macros
1.2.3.2. Trace file
1.2.3.3. Finding memory leaks
1.2.4. Summary
1.2.5. Exercises

2.0. Introduction

2.1. Strings in Depth
2.1.1. What's in a string?
  2.1.2. Creating and initializing C++ strings
2.1.3. Operating on strings
2.1.3.1. Appending, inserting, and concatenating strings
2.1.3.2. Replacing string characters
2.1.3.3. Concatenation using nonmember overloaded operators
2.1.4. Searching in strings
2.1.4.1. Finding in reverse
2.1.4.2. Finding first/last of a set of characters
2.1.4.3. Removing characters from strings
2.1.4.4. Comparing strings
2.1.4.5. Strings and character traits
2.1.5. A string application
2.1.6. Summary
2.1.7. Exercises

2.2. Iostreams
2.2.1. Why iostreams?
2.2.2. Iostreams to the rescue
2.2.2.1. Inserters and extractors
2.2.2.2. Common usage
2.2.2.3. Line–oriented input
2.2.3. Handling stream errors
2.2.4. File iostreams
2.2.4.1. A File–Processing Example
2.2.4.2. Open modes
2.2.5. Iostream buffering
2.2.6. Seeking in iostreams
2.2.7. String iostreams
2.2.7.1. Input string streams
2.2.7.2. Output string streams
2.2.8. Output stream formatting
2.2.8.1. Format flags
  2.2.8.2. Format fields
2.2.8.3. Width, fill, and precision
2.2.8.4. An exhaustive example
2.2.9. Manipulators
2.2.9.1. Manipulators with arguments
2.2.9.2. Creating manipulators
2.2.9.3. Effectors
2.2.10. Iostream examples
2.2.10.1. Maintaining class library source code
2.2.10.2. Detecting compiler errors
2.2.10.3. A simple data logger
2.2.11. Internationalization
2.2.11.1. Wide Streams
2.2.11.2. Locales
2.2.12. Summary
2.2.13. Exercises

2.3. Templates in Depth
2.3.1. Template parameters
2.3.1.1. Non–type template parameters
2.3.1.2. Default template arguments
2.3.1.3. Template template parameters
2.3.1.4. The typename keyword
2.3.1.5. Using the template keyword as a hint
2.3.1.6. Member Templates
2.3.2. Function template issues
  2.3.2.1. Type deduction of function template arguments
2.3.2.2. Function template overloading
2.3.2.3. Taking the address of a generated function template
2.3.2.4. Applying a function to an STL sequence
2.3.2.5. Partial ordering of function templates
2.3.3. Template specialization
2.3.3.1. Explicit specialization
2.3.3.2. Partial Specialization
2.3.3.3. A practical example
2.3.3.4. Preventing template code bloat
2.3.4. Name lookup issues
2.3.4.1. Names in templates
2.3.4.2. Templates and friends
2.3.5. Template programming idioms
2.3.5.1. Traits
2.3.5.2. Policies
2.3.5.3. The curiously recurring template pattern
2.3.6. Template metaprogramming
2.3.6.1. Compile–time programming
2.3.6.2. Expression templates
2.3.7. Template compilation models
2.3.7.1. The inclusion model
2.3.7.2. Explicit instantiation
2.3.7.3. The separation model
2.3.8. Summary
2.3.9. Exercises

2.4. Generic Algorithms
2.4.1. A first look
2.4.1.1. Predicates
2.4.1.2. Stream iterators
2.4.1.3. Algorithm complexity
2.4.2. Function objects
2.4.2.1. Classification of function objects
2.4.2.2. Automatic creation of function objects
2.4.2.3. Adaptable function objects
2.4.2.4. More function object examples
2.4.2.5. Function pointer adaptors
2.4.2.6. Writing your own function object adaptors
2.4.3. A catalog of STL algorithms
2.4.3.1. Support tools for example creation
2.4.3.2. Filling and generating
2.4.3.3. Counting
2.4.3.4. Manipulating sequences
2.4.3.5. Searching and replacing
2.4.3.6. Comparing ranges
2.4.3.7. Removing elements
2.4.3.8. Sorting and operations on sorted ranges
2.4.3.9. Heap operations
2.4.3.10. Applying an operation to each element in a range
2.4.3.11. Numeric algorithms
2.4.3.12. General utilities
2.4.4. Creating your own STL–style algorithms
2.4.5. Summary
2.4.6. Exercises

2.5. Generic Containers
2.5.1. Containers and iterators
2.5.1.1. STL reference documentation
2.5.2. A first look
2.5.2.1. Containers of strings
2.5.2.2. Inheriting from STL containers
2.5.3. A plethora of iterators
2.5.3.1. Iterators in reversible containers
2.5.3.2. Iterator categories
2.5.3.3. Predefined iterators
2.5.4. The basic sequences: vector, list, deque
2.5.4.1. Basic sequence operations
2.5.4.2. vector
2.5.4.3. deque
2.5.4.4. Converting between sequences
2.5.4.5. Checked random–access
2.5.4.6. list
2.5.4.7. Swapping sequences
2.5.5. set
2.5.5.1. A completely reusable tokenizer
2.5.6. stack
2.5.7. queue
2.5.8. Priority queues
2.5.9. Holding bits
2.5.9.1. bitset<n>
2.5.9.2. vector<bool>
2.5.10. Associative containers
2.5.10.1. Generators and fillers for associative containers
2.5.10.2. The magic of maps
2.5.10.3. Multimaps and duplicate keys
2.5.10.4. Multisets
2.5.11. Combining STL containers
2.5.12. Cleaning up containers of pointers
2.5.13. Creating your own containers
2.5.14. STL extensions
2.5.15. Non–STL containers
  2.5.16. Summary
2.5.17. Exercises

3.0. Introduction

3.1. Runtime Type Identification
3.1.1. Runtime casts
3.1.2. The typeid operator
3.1.2.1. Casting to intermediate levels
3.1.2.2. void pointers
3.1.2.3. Using RTTI with templates
3.1.3. Multiple inheritance
  3.1.4. Sensible uses for RTTI
3.1.4.1. A trash recycler
3.1.5. Mechanism and overhead of RTTI
3.1.6. Summary
3.1.7. Exercises

3.2. Multiple Inheritance
3.2.1. Perspective
3.2.2. Interface inheritance
3.2.3. Implementation inheritance
3.2.4. Duplicate subobjects
3.2.5. Virtual base classes
3.2.6. Name lookup issues
3.2.7. Avoiding MI
3.2.8. Extending an interface
3.2.9. Summary

3.3. Design Patterns
3.3.1. The pattern concept
3.3.1.1. Prefer composition to inheritance
3.3.2. Classifying patterns
3.3.2.1. Features, idioms, patterns
3.3.3. Simplifying Idioms
3.3.3.1. Messenger
3.3.3.2. Collecting Parameter
3.3.4. Singleton
3.3.4.1. Variations on Singleton
3.3.5. Command: choosing the operation
3.3.5.1. Decoupling event handling with Command
3.3.6. Object decoupling
3.3.6.1. Proxy: fronting for another object
3.3.6.2. State: changing object behavior
3.3.7. Adapter
3.3.8. Template Method
3.3.9. Strategy: choosing the algorithm at runtime
3.3.10. Chain of Responsibility: trying a sequence of strategies
3.3.11. Factories: encapsulating object creation
3.3.11.1. Polymorphic factories
3.3.11.2. Abstract factories
3.3.11.3. Virtual constructors
3.3.12. Builder: creating complex objects
3.3.13. Observer
3.3.13.1. The “inner class” idiom
3.3.13.2. The observer example
3.3.14. Multiple dispatching
3.3.14.1. Multiple dispatching with Visitor
3.3.15. Summary
3.3.16. Exercises

3.4. Concurrency
3.4.1. Motivation
3.4.2. Concurrency in C++
3.4.2.1. Installing ZThreads
3.4.3. Defining Tasks
3.4.4. Using Threads
3.4.4.1. Creating responsive user interfaces
3.4.4.2. Simplifying with Executors
3.4.4.3. Yielding
3.4.4.4. Sleeping
3.4.4.5. Priority
3.4.5. Sharing limited resources
3.4.5.1. Ensuring the existence of objects
3.4.5.2. Improperly accessing resources
3.4.5.3. Controlling access
3.4.5.4. Simplified coding with Guards
3.4.5.5. Thread local storage
3.4.6. Terminating tasks
3.4.6.1. Preventing iostream collision
3.4.6.2. The ornamental garden
3.4.6.3. Terminating when blocked
3.4.6.4. Interruption
3.4.7. Cooperation between threads
3.4.7.1. Wait and signal
3.4.7.2. Producer–consumer relationships
3.4.7.3. Solving threading problems with queues
3.4.7.4. Broadcast
3.4.8. Deadlock
3.4.9. Summary
3.4.10. Exercises

4. A: Recommended Reading
4.1. General C++
4.1.1. Bruce's books
4.1.2. Chuck's books
4.2. In–depth C++
4.3. Design Patterns

5. B: Etc