Ruminations on C++: A Decade of Programming Insight and Experience (Paperback)

First Try.
Doing it without Classes.
Why was it Easier in C++?
A Bigger Example.
Conclusion.

I. MOTIVATION.

The Problem.
History and Context.
Automatic Software Distribution.
Enter C++.
Recycled Software.
Postscript.

The Success of Small Projects.
Abstraction.
Machines Should Work for People.

The Problem.
The Classical Solution.
Virtual Copy Functions.
Defining a Surrogate Class.
Summary.

The Problem.
A Simple Class.
Attaching a Handle.
Getting at the Object.
Simple Implementation.
Use-Counted Handles.
Copy on Write.
Discussion.

Review.
Separating the use Count.
Abstraction of use Counts.
Access Functions and Copy on Write.
Discussion.

The Problem.
An Object-Oriented Solution.
Handle Classes.
Extension 1: New Operations.
Extension 2: New Node Types.
Reflections.

The Problem.
Designing the Interface.
A Few Loose Ends.
Testing the Interface.
Strategy.
Tactics.
Combining Pictures.
Conclusion.

Strategy.
Exploiting the Structure.
Conclusion.

The Case For.
The Case Against.
Destructors are Special.
Summary.

III. TEMPLATES.

What Does it Contain?
What Does Copying the Container Mean?
How Do You Get at Container Elements?
How Do You Distinguish Reading from Writing?
How Do You Handle Container Growth?
What Operations Does the Container Provide?
What Do You Assume about the Container Element Type?
Containers and Inheritance.
Designing an Arraylike Class.

Imitating a Pointer.
Getting at the Data.
Remaining Problems.
Pointer to Const Array.
Useful Additions.

Completing the Pointer Class.
What is an Iterator?
Deleting an Element.
Deleting the Container.
Other Design Considerations.
Discussion.

The State of the Art.
A Radical Old Idea.
Well, Maybe a Few Extras.
Example of Use.
Maybe a Few More.
Food for Thought.

The Problem.
The First Example.
Separating the Iteration.
Iterating Over Arbitrary Types.
Adding Other Types.
Abstracting the Storage Technique.
The Proof of the Pudding.
Summary.

A Specific Example.
Generalizing the Element Type.
Postponing the Count.
Address Independence.
Searching a Nonarray.
Discussion.

A Different Algorithm.
Categories of Requirements.
Input Iterators.
Output Iterators.
Forward Iterators.
Bidirectional Iterators.
Random-Access Iterators.
Inheritance?
Performance.
Summary.

Iterator Types.
Virtual Sequences.
An Output-Stream Iterator.
An Input-Stream Iterator.
Discussion.

An Example.
Directional Asymmetry.
Consistency and Asymmetry.
Automatic Reversal.
Discussion.

An Example.
Function Pointers.
Function Objects.
Function-Object Templates.
Hiding Intermediate Types.
One Type Covers Many.
Implementation.
Discussion.

Why Function Objects?
Function Objects For Built-In Operators.
Binders.
A Closer Look.
Interface Inheritance.
Using These Classes.
Discussion.

IV. LIBRARIES.

The Problem.
Understanding the Problem—Part 1.
Implementation—Part 1.
Understanding the Problem—Part 2.
Implementation—Part 2.
Discussion.

Complications.
Improving the Interface.
Taking Stock.
Writing the Code.
Conclusion.

Character Strings.
Memory Exhaustion.
Copying.
Hiding the Implementation.
Default Constructor.
Other Operations.
Substrings.
Conclusion.

Abstract Data Types.
Libraries and Abstract Data Types.
Memory Allocation.
Memberwise Assignment and Initialization.
Exception Handling.
Summary.

V. TECHNIQUE.

Design of a Trace Class.
Creating Dead Code.
Generating Audit Trails for Objects.
Verifying Container Behavior.
Summary.

The Problem.
Designing the Solution.
Implementation.
Enter Inheritance.
Summary.

The Problem.
A Solution.
A Different Solution.
Multiple Arguments.
An Example.
Abbreviations.
Musings.
Historical Notes, References, and Acknowledgments.

The Problem.
Solution 1: Trickery and Brute Force.
Solution 2: Abstract Output.
Solution 3: Trickery without Brute Force.
Remarks.

VI. WRAPUP.

The World is Complicated.
Complexity Becomes Hidden.
Computers are no Different.
Computers Solve Real Problems.
Class Libraries and Language Semantics.
Making Things Easy is Hard.
Abstraction and Interface.
Conservation of Complexity.

Find the Local Experts.
Pick a Tool Kit and Become Comfortable with it.
Some Parts of C are Essential.
But Others are not.
Set Yourself a Series of Problems.
Conclusion.