Ruminations on C++
by Andrew Koenig
Addison-Wesley, 1997
ISBN 0-201-42339-1
Contents
Preface
Chapter 0 Prelude
0.1 First try
0.2 Doing it without classes
0.3 Why was it easier in C++?
0.4 A bigger example
0.5 Conclusion
Part I Motivation
Chapter 1 Why I use C++
1.1 The problem
1.2 History and context
1.3 Automatic software distribution
1.4 Enter C++
1.5 Recycled software
1.6 Postscript
Chapter 2 Why I work on C++
2.1 The success of small projects
2.2 Abstraction
2.3 Machines should work for people
Chapter 3 Living in the real world
Part II Classes and inheritance
Chapter 4 Checklist for class authors
Chapter 5 Surrogate classes
5.1 The problem
5.2 The classical solution
5.3 Virtual copy functions
5.4 Defining a surrogate class
5.5 Summary
Chapter 6 Handles: Part 1
6.1 The problem
6.2 A simple class
6.3 Attaching a handle
6.4 Getting at the object
6.5 Simple implementation
6.6 Use-counted handles
6.7 Copy on write
6.8 Discussion
Chapter 7 Handles: Part 2
7.1 Review
7.2 Separating the use count
7.3 Abstraction of use counts
7.4 Access functions and copy on write
7.5 Discussion
Chapter 8 An object-oriented program
8.1 The problem
8.2 An object-oriented solution
8.3 Handle classes
8.4 Extension 1: New operations
8.5 Extension 2: New node types
8.6 Reflections
Chapter 9 Analysis of a classroom exercise: Part 1
9.1 The problem
9.2 Designing the interface
9.3 A few loose ends
9.4 Testing the interface
9.5 Strategy
9.6 Tactics
9.7 Combining pictures
9.8 Conclusion
Chapter 10 Analysis of a classroom exercise: Part 2
10.1 Strategy
10.2 Exploiting the structure
10.3 Conclusion
Chapter 11 When not to use virtual functions
11.1 The case for
11.2 The case against
11.3 Destructors are special
11.4 Summary
Part III Templates
Chapter 12 Designing a container class
12.1 What does it contain?
12.2 What does copying the container mean?
12.3 How do you get at container elements?
12.4 How do you distinguish reading from writing?
12.5 How do you handle container growth?
12.6 What operations does the container provide?
12.7 What do you assume about the container element type?
12.8 Containers and inheritance
12.9 Designing an arraylike class
Chapter 13 Accessing container elements
13.1 Imitating a pointer
13.2 Getting at the data
13.3 Remaining problems
13.4 Pointer to const Array
13.5 Useful additions
Chapter 14 Iterators
14.1 Completing the Pointer class
14.2 What is an iterator?
14.3 Deleting an element
14.4 Deleting the container
14.5 Other design considerations
14.6 Discussion
Chapter 15 Sequences
15.1 The state of the art
15.2 A radical old idea
15.3 Well, maybe a few extras...
15.4 Example of use
15.5 Maybe a few more...
15.6 Food for thought
Chapter 16 Templates as interfaces
16.1 The problem
16.2 The first example
16.3 Separating the iteration
16.4 Iterating over arbitrary types
16.5 Adding other types
16.6 Abstracting the storage technique
16.7 The proof of the pudding
16.8 Summary
Chapter 17 Templates and generic algorithms
17.1 A specific example
17.2 Generalizing the element type
17.3 Postponing the count
17.4 Address independence
17.5 Searching a nonarray
17.6 Discussion
Chapter 18 Generic iterators
18.1 A different algorithm
18.2 Categories of requirements
18.3 Input iterators
18.4 Output iterators
18.5 Forward iterators
18.6 Bidirectional iterators
18.7 Random-access iterators
18.8 Inheritance?
18.9 Performance
18.10 Summary
Chapter 19 Using generic iterators
19.1 Iterator types
19.2 Virtual sequences
19.3 An output-stream iterator
19.4 An input-stream iterator
19.5 Discussion
Chapter 20 Iterator adaptors
20.1 An example
20.2 Directional asymmetry
20.3 Consistency and asymmetry
20.4 Automatic reversal
20.5 Discussion
Chapter 21 Function objects
21.1 An example
21.2 Function pointers
21.3 Function objects
21.4 Function-object templates
21.5 Hiding intermediate types
21.6 One type covers many
21.7 Implementation
21.8 Discussion
Chapter 22 Function adaptors
22.1 Why function objects?
22.2 Function objects for built-in operators
22.3 Binders
22.4 A closer look
22.5 Interface inheritance
22.6 Using these classes
22.7 Discussion
Part IV Libraries
Chapter 23 Libraries in everyday use
23.1 The problem
23.2 Understanding the problem--part 1
23.3 Implementation--part 1
23.4 Understanding the problem--part 2
23.5 Implementation--part 2
23.6 Discussion
Chapter 24 An object lesson in library-interface design
24.1 Complications
24.2 Improving the interface
24.3 Taking stock
24.4 Writing the code
24.5 Conclusion
Chapter 25 Library design is language design
25.1 Character strings
25.2 Memory exhaustion
25.3 Copying
25.4 Hiding the implementation
25.5 Default constructor
25.6 Other operations
25.7 Substrings
25.8 Conclusion
Chapter 26 Language design is library design
26.1 Abstract data types
26.2 Libraries and abstract data types
26.3 Memory allocation
26.4 Memberwise assignment and initialization
26.5 Exception handling
26.6 Summary
Part V Technique
Chapter 27 Classes that keep track of themselves
27.1 Design of a trace class
27.2 Creating dead code
27.3 Generating audit trails for objects
27.4 Verifying container behavior
27.5 Summary
Chapter 28 Allocating objects in clusters
28.1 The problem
28.2 Designing the solution
28.3 Implementation
28.4 Enter inheritance
28.5 Summary
Chapter 29 Applicators, manipulators, and function objects
29.1 The problem
29.2 A solution
29.3 A different solution
29.4 Multiple arguments
29.5 An example
29.6 Abbreviations
29.7 Musings
29.8 Historical notes, references, and acknowledgments
Chapter 30 Decoupling application libraries from input-output
30.1 The problem
30.2 Solution 1: Trickery and brute force
30.3 Solution 2: Abstract output
30.4 Solution 3: Trickery without brute force
30.5 Remarks
Part VI Wrapup
Chapter 31 Simplicity through complexity
31.1 The world is complicated
31.2 Complexity becomes hidden
31.3 Computers are no different
31.4 Computers solve real problems
31.5 Class libraries and language semantics
31.6 Making things easy is hard
31.7 Abstraction and interface
31.8 Conservation of complexity
Chapter 32 What do you do after you say Hello world?
32.1 Find the local experts
32.2 Pick a tool kit and become comfortable with it
32.3 Some parts of C are essential ...
32.4 ... but others are not
32.5 Set yourself a series of problems
32.6 Conclusion