Ruminations on C++ concentrates on the key C++ ideas and programming techniques--skimming the cream--to let you understand the "why" and not just the "how" of C++ programming. You need not be an expert C++ programmer to find solid fodder here, yet even experts need not fear overgrazing: You will find something worth chewing on in every chapter.
This should be your next C++ book, because it
The code is available in 3 separate formats:
Doing it without Classes.
Why was it Easier in C++?
A Bigger Example.
I. MOTIVATION.1. Why I Use C++.
History and Context.
Automatic Software Distribution.
Postscript.2. Why I Work on C++.
The Success of Small Projects.
Machines Should Work for People.3. Living in the Real World.
II. CLASSES aND INHERITANCE.4. Checklist for Class Authors.
The Classical Solution.
Virtual Copy Functions.
Defining a Surrogate Class.
Summary.6. Handles: Part 1.
A Simple Class.
Attaching a Handle.
Getting at the Object.
Copy on Write.
Discussion.7. Handles: Part 2.
Separating the use Count.
Abstraction of use Counts.
Access Functions and Copy on Write.
Discussion.8. An Object-Oriented Program.
An Object-Oriented Solution.
Extension 1: New Operations.
Extension 2: New Node Types.
Reflections.9. Analysis of a Classroom Exercise: Part 1.
Designing the Interface.
A Few Loose Ends.
Testing the Interface.
Conclusion.10. Analysis of a Classroom Exercise: Part 2.
Exploiting the Structure.
Conclusion.11. When not to use Virtual Functions.
The Case For.
The Case Against.
Destructors are Special.
III. TEMPLATES.12. Designing a Container Class.
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.13. Accessing Container Elements.
Imitating a Pointer.
Getting at the Data.
Pointer to Const Array.
Useful Additions.14. Iterators.
Completing the Pointer Class.
What is an Iterator?
Deleting an Element.
Deleting the Container.
Other Design Considerations.
The State of the Art.
A Radical Old Idea.
Well, Maybe a Few Extras.
Example of Use.
Maybe a Few More.
Food for Thought.16. Templates as Interfaces.
The First Example.
Separating the Iteration.
Iterating Over Arbitrary Types.
Adding Other Types.
Abstracting the Storage Technique.
The Proof of the Pudding.
Summary.17. Templates and Generic Algorithms.
A Specific Example.
Generalizing the Element Type.
Postponing the Count.
Searching a Nonarray.
Discussion.18. Generic Iterators.
A Different Algorithm.
Categories of Requirements.
Summary.19. Using Generic Iterators.
An Output-Stream Iterator.
An Input-Stream Iterator.
Discussion.20. Iterator Adaptors.
Consistency and Asymmetry.
Discussion.21. Function Objects.
Hiding Intermediate Types.
One Type Covers Many.
Discussion.22. Function Adaptors.
Why Function Objects?
Function Objects For Built-In Operators.
A Closer Look.
Using These Classes.
IV. LIBRARIES.23. Libraries in Everyday Use.
Understanding the Problem—Part 1.
Understanding the Problem—Part 2.
Discussion.24. An Object Lesson in Library-Interface Design.
Improving the Interface.
Writing the Code.
Conclusion.25. Library Design is Language Design.
Hiding the Implementation.
Conclusion.26. Language Design is Library Design.
Abstract Data Types.
Libraries and Abstract Data Types.
Memberwise Assignment and Initialization.
V. TECHNIQUE.27. Classes that Keep Track of Themselves.
Design of a Trace Class.
Creating Dead Code.
Generating Audit Trails for Objects.
Verifying Container Behavior.
Summary.28. Allocating Objects in Clusters.
Designing the Solution.
Summary.29. Applicators, Manipulators, and Function Objects.
A Different Solution.
Historical Notes, References, and Acknowledgments.30. Decoupling Application Libraries from Input-Output.
Solution 1: Trickery and Brute Force.
Solution 2: Abstract Output.
Solution 3: Trickery without Brute Force.
VI. WRAPUP.31. Simplicity through Complexity.
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.32. What Do You Do After You Say Hello World?
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.
C++ was just beginning to become an important influence on the programming community. Usenix had recently held its first C++ workshop, in Santa Fe, New Mexico.They had expected 50 people; more than 200 showed up. Many more would hop on the C++ bandwagon, which meant that the community would need an articulate, reasoned voice to speak against the torrent of hype that was sure to come. It would need someone who could make clear the difference between hype and substance and keep a cool head in all the turmoil. I took the offer anyway.
I am writing these words while thinking about my sixty-third column for JOOP. The column has appeared in every issue but two, during which time I badly needed a break and was lucky enough to be able to get Jonathan Shopiro to take my place. On a third occasion, I wrote only the introduction to the column, stepping aside for the distinguished Danish computer scientist Bjorn Stavtrup. In addition, Livleen Singh talked me into writing a column for the quarterlyC++ Journal, which lasted six issues before folding, and Stan Lippman cajoled me into doing a column for the C++ Reportwhen it changed from a newsletter into a full-fledged magazine. Adding my 29 C++ Reportcolumns to the others brings the total to 98.
That's a lot of stuff to be scattered in periodicals all over the place.If the articles are useful individually, they should be evenmore useful when collected.In consequence, Barbara and I (mostly Barbara) have gone back over the columns, selected the best, and added to or rewritten them as needed for coherence and continuity.
Now that you know why the book exists, let me tell you why you should read it instead of some other C++ book. Goodness knows, there are enough of them; why pick this one?
The first reason is that I think you'll enjoy it. Most C++ books don't have that in mind: They are curriculum-based. Enjoyment is secondary at best.
Magazine columns are different. I suppose there must be some people out there who thumb through a copy of JOOPin a bookstore and skim my column before deciding whether to buy the magazine, but it would be arrogant to think that there are more than a few. Most readers will be seeing my column after they've already paid for it, which means that they have a completely free choice about whether to read it or not. So each column has to be worth reading on its own.
This book contains no long, boring discussions of obscure details. Beginners are not intended to be able to learn C++ from this book alone. A few people, who already know several programming languages thoroughly, and who have figured out how to infer the rules for a new language by reading code, will be able to use this book to get an overview of C++. Most readers starting from scratch would do well to read The C++ Programming Language(Addison-Wesley 1991)by Bjarne Stroustrup, or Stan Lippman's C++ Primer(Addison-Wesley 1991), and then read this book.
This is a book about ideas and techniques, not details. If you want to find out how to make virtual base classes do double reverse backflips, you will have to turn elsewhere.What you will find here is lots of code to read.Try the examples for yourself. Classroom experience indicates that getting these programs to run and then modifying them is a good way to cement your understanding. For those who prefer to start with working code, we have made available selected examples from the book by anonymous FTP from
ftp.aw.com in directory
If you know some C++ already, I think that this book will not only entertain but also enlighten you. This is the second reason to read it. My intent isn't to teach C++ per se. Instead, I want to show you how to think about programming in C++, and how to look at problems and express a solution in C++. Knowledge can be acquired systematically; wisdom cannot.
Part I is an extended introduction to themes that will pervade the rest of the book. You won't find much code, but the ideas of abstraction and pragmatism explored there underlie both this book and, more important, the design of C++ and strategies for its effective use.
Part II looks at inheritance and object-oriented programming, which most people think are the most important ideas in C++. You will learn why inheritance is important and what it can do.You will also learn why it can be useful to conceal inheritance from its users and when to avoid inheritance altogether.
Part III explores templates, which I think constitute the most important idea in C++. The reason I think templates are so important is that they provide a particularly powerful kind of abstraction. Not only do templates allow the construction of containers that know almost nothing about the types of what they will contain, but they make it possible to abstract away things far more general than just types.
One reason that inheritance and templates are important is that they are ways of extending C++ without waiting (or paying) for people to produce new languages and compilers. The way to organize such extensions is through class libraries. Part IV talks about libraries--both their design and use.
With the basics well understood, we can look at some specialized programming techniques in Part V. Here you will find ways to tie classes inextricably together, as well as ways to keep them as far apart as possible.
Finally, in Part VI, we turn back for a last look at the terrain we have covered.
As with so much else in C++, we compromised. Where the original column was simply incorrect--either in light of how the language has changed since the column was written or because of a change in our understanding of how things should be--we'vefixed it. A particularly pervasive example is our use of
const the importance of which has steadily grown in our understanding since
const entered the language.
On the other hand, for instance, lots of examples here use
int to represent true or false values, even though the standards committee has accepted
bool as a built-in data type. The reasoning is that the columns were written that way originally, using
int for such values will still work, and it will be years before most compilers support
We are also grateful to the people who read and commented on drafts of the book and the columns that it comprises: Dag Bruck, Jim Coplien, Tony Hansen, Bill Hopkins, Brian Kernighan (who gets extra credit for reading the entire book twice carefully with pen in hand), Stan Lippman, Rob Murray, George Otto, and Bjarne Stroustrup.
The columns would never have become a book without the help of Deborah Lafferty, Loren Stevens and Tom Stone at Addison-Wesley, and the copy editing of Lyn Dupre.
We are particularly grateful to the enlightened managers at AT&T who made it possible to write these columns and to compile this book, including Dave Belanger, Ron Brachman, Jim Finucane, Sandy Fraser, Wayne Hunt, Brian Kernighan, Rob Murray, Ravi Sethi, Bjarne Stroustrup, and Eric Sumner.
Gillette, New Jersey