Note: This document requires the installation of the fonts Georgia, Verdana and Andale Mono (code font) for proper viewing. These can be found at: http://sourceforge.net/project/showfiles.php?group_id=34153&release_id=105355

Revision 19—(August 23, 2003)

Finished Chapter 11, which is now going through review and copyediting. Modified a number of examples throughout the book so that they will compile with Linux g++ (basically fixing case-sensitive naming issues).

Revision 18—(August 2, 2003)

Chapter 5 is complete. Chapter 11 is updated and is near completion. Updated the front matter and index entries. Home stretch now.

Revision 17—(July 8, 2003)

Chapters 5 and 11 are 90% done!

Revision 16—(June 25, 2003)

Chapter 5 text is almost complete, but enough is added to justify a separate posting. The example programs for Chapter 11 are also fairly complete. Added a matrix multiplication example to the valarray material in chapter 7. Chapter 7 has been tech-edited. Many corrections due to comments from users have been integrated into the text (thanks!).

Revision 15—(March 1 ,2003)

Fixed an omission in C10:CuriousSingleton.cpp. Chapters 9 and 10 have been tech-edited.

Revision 14—(January ,2003)

Fixed a number of fuzzy explanations in response to reader feedback (thanks!). Chapter 9 has been copy-edited.

Revision 13—(December 31, 2002)

Updated the exercises for Chapter 7. Finished rewriting Chapter 9. Added a template variation of Singleton to chapter 10. Updated the build directives. Fixed lots of stuff. Chapters 5 and 11 still await rewrite.

Revision 12—(December 23, 2002)

Added material on Design Patterns as Chapter 10 (Concurrency will move to Chapter 11). Added exercises for Chapter 6. Here is the status of all chapters:

100% complete: 1-4, 6, 8

Copy-edited, waiting for tech edit: 7, 10

Incomplete: 5, 9, 11

Revision 11 (December 13, 2002) –

Chapter 7 has been updated. Chapter 6 has been copy-edited and a few bugs were fixed. Chapter 4 has been tech-edited. The exercises are still out of date except for chapters 1-3.

Revision 10 (October 15, 2002) –

Chapters 1 through 3 are now 100% complete (copy-edited and tech-edited). Chapter 4 has been copy-edited. Updated Chapter 6 to fit in its new position and adding introductory material. (Chapters 5 and 7-10 are still unfinished at this point).

Revision 9 (August 29, 2002) –

Finished Chapter 4 (IOStreams). Reordered the material and added material on wide stream and locales. Removed references to strstreams. Edited the “Iostreams examples” section. Added new exercises.

Revision 8 (August 6, 2002) --

Made ExtractCode.cpp in Chapter 3 work for GNU C++.

Copy-edited Chapters 1 through 3.

Revision 7 (July 31, 2002) --

Fixed omissions in comments for code extraction throughout text.

Edited Chapter 3:

• Added a wide-character version of ichar_traits
• Replaced SiteMapConvert.cpp with ExtractCode.cpp
• Added exercises

Revision 6 (July 27, 2002) --

Finished Chapter 3 (Strings)

• Mentioned caveat about reference counting with multithreading.
• Removed first (out-of-date) HTML example
• Fixed the ichar_traits example
• Fixed stupid MemCheck.cpp error in Chapter 2

Revision 5 (July 20, 2002) --

Chapters 1 and 2 are “finished”.

• Reordered the material in Chapter 1:
• Placed exception specifications last, and warned of their dangers with template classes
• Added a section on Exception Safety.
• Added material on auto_ptr
• Added material illustrating bad_exception
• Explained the internal implementation of exceptions and the Zero-cost Model
• Merged Chapter 3 (Debugging) into Chapter 2:
• Added material on invariants, assertions and Design-by-contract
• Placed the TestSuite in its own namespace
• Finished the MemCheck system for tracking memory errors
• Removed Chapter 11 (Design Patterns)
• Will be replaced by Chapter 10 (Concurrent Programming)

Revision 4, August 19, 2001 --

• Restructured the book; this is the first version with Chuck Allison coauthoring. Incorporated Chuck's testing framework, which will be used throughout the book and automatically included as part of the book's build process in the makefiles.
• In the code subdirectory of the unpacked distribution, you can now use make to compile for Borland, Microsoft, Gnu g++2.95 (distributed with Cygwin) and Gnu g++3.0 (tested under Linux).
• Under Windows98/NT/2000, you will get best results running under the free Cygwin environment (www.Cygwin.com), even if you're compiling for Borland or Microsoft. In particular, some linker command lines for Microsoft are too long for Win98 COMMAND.COM, but work just fine under Cygwin.
• Made many code changes to allow programs to be run inside the test framework, in particular removing the need for user input when executing programs.
• Added //{L} ../TestSuite/Test in all the programs where the unit test framework is used that can be run without user input, to cause the makefile builder to generate calls to the programs as part of the build process.

“This book is a tremendous achievement. You owe it to yourself to have a copy on your shelf. The chapter on iostreams is the most comprehensive and understandable treatment of that subject I’ve seen to date.”

Al Stevens
Contributing Editor, Doctor Dobbs Journal

“Eckel’s book is the only one to so clearly explain how to rethink program construction for object orientation. That the book is also an excellent tutorial on the ins and outs of C++ is an added bonus.”

Andrew Binstock
Editor, Unix Review

“Bruce continues to amaze me with his insight into C++, and Thinking in C++ is his best collection of ideas yet. If you want clear answers to difficult questions about C++, buy this outstanding book.”

Gary Entsminger
Author, The Tao of Objects

“Thinking in C++ patiently and methodically explores the issues of when and how to use inlines, references, operator overloading, inheritance and dynamic objects, as well as advanced topics such as the proper use of templates, exceptions and multiple inheritance. The entire effort is woven in a fabric that includes Eckel’s own philosophy of object and program design. A must for every C++ developer’s bookshelf, Thinking in C++ is the one C++ book you must have if you’re doing serious development with C++.”

Richard Hale Shaw
Contributing Editor, PC Magazine

 

Thinking

In

C++

Volume 2: Practical Programming

Bruce Eckel, President, MindView, Inc.
Chuck Allison, Utah Valley State College

 

 

©2004 MindView, Inc.

The information in this book is distributed on an “as is” basis, without warranty. While every precaution has been taken in the preparation of this book, neither the author nor the publisher shall have any liability to any person or entitle with respect to any liability, loss or damage caused or alleged to be caused directly or indirectly by instructions contained in this book or by the computer software or hardware products described herein.

All rights reserved. No part of this book may be reproduced in any form or by any electronic or mechanical means including information storage and retrieval systems without permission in writing from the publisher or authors, except by a reviewer who may quote brief passages in a review. Any of the names used in the examples and text of this book are fictional; any relationship to persons living or dead or to fictional characters in other works is purely coincidental.

Dedication

To all those who have worked tirelessly
on the development of the C++ language

 

What’s inside...

Preface                                                       19

Goals........................................ 19

Chapters................................... 20

Exercises................................... 23

Exercise solutions............. 23

Source code............................... 23

Language standards................... 25

Language support............. 25

Seminars, CD-ROMs & consulting. 25

Errors....................................... 26

About the cover......................... 26

Acknowledgements..................... 26

Building Stable Systems                             29

1: Exception handling                                31

Traditional error handling............. 32

Throwing an exception................ 34

Catching an exception................. 36

The try block.................... 36

Exception handlers........... 36

Exception matching..................... 39

Catching any exception..... 42

Re-throwing an exception.. 42

Uncaught exceptions......... 43

Cleaning up................................ 45

Resource management..... 47

Making everything an object 49

auto_ptr.......................... 52

Function-level try blocks.... 53

Standard exceptions................... 55

Exception specifications............... 58

Better exception specifications?          64

Exception specifications and inheritance           64

When not to use exception specifications         66

Exception safety......................... 66

Programming with exceptions....... 71

When to avoid exceptions.. 71

Typical uses of exceptions. 73

Overhead................................... 77

Summary................................... 79

Exercises................................... 80

2: Defensive programming                         83

Assertions................................. 86

A simple unit test framework........ 90

Automated testing............ 92

The TestSuite Framework.. 97

Test suites..................... 101

The test framework code. 102

Debugging techniques............... 110

Trace macros................. 110

Trace file....................... 111

Finding memory leaks..... 112

Summary................................. 119

Exercises................................. 120

The Standard C++ Library                        125

3: Strings in depth                                   127

What’s in a string?.................... 128

Creating and initializing C++ strings 130

Operating on strings................. 133

Appending, inserting,  and concatenating strings           134

Replacing string characters 136

Concatenation using  nonmember overloaded operators           141

Searching in strings.................. 142

Finding in reverse........... 147

Finding first/last of a set of characters 148

Removing characters from strings       150

Comparing strings.......... 153

Strings and character traits 157

A string application................... 164

Summary................................. 170

Exercises................................. 171

4: Iostreams                                             172

Why iostreams?........................ 172

Iostreams to the rescue............ 177

Inserters and extractors.. 177

Common usage.............. 183

Line-oriented input.......... 185

Handling stream errors.............. 187

File iostreams........................... 190

A File-Processing Example 192

Open modes................... 194

Iostream buffering.................... 195

Seeking in iostreams................. 198

String iostreams....................... 202

Input string streams........ 203

Output string streams...... 205

Output stream formatting.......... 209

Format flags................... 209

Format fields.................. 211

Width, fill, and precision.. 213

An exhaustive example... 214

Manipulators............................. 218

Manipulators with arguments 219

Creating manipulators..... 223

Effectors........................ 224

Iostream examples.................... 227

Maintaining class library source code   227

Detecting compiler errors 232

A simple datalogger........ 235

Internationalization................... 240

Wide Streams................. 240

Locales.......................... 243

Summary................................. 246

Exercises................................. 246

5: Templates in depth                              251

Template parameters................. 251

Non-type template parameters           252

Default template arguments 254

Template template parameters           256

The typename keyword... 263

Using the template keyword as a hint  266

Member Templates......... 268

Function template issues........... 271

Type deduction of function template arguments            271

Function template overloading            276

Taking the address of a generated function template    277

Applying a function to an STL sequence           281

Partial ordering of function templates  285

Template specialization............... 286

Explicit specialization....... 287

Partial Specialization....... 289

A practical example........ 291

Preventing template code bloat           295

Name lookup issues.................. 300

Names in templates........ 300

Templates and friends..... 306

Template programming idioms.... 312

Traits............................. 312

Policies.......................... 318

The curiously recurring template pattern          323

Template metaprogramming....... 326

Compile-time programming 327

Expression templates...... 337

Template compilation models...... 344

The inclusion model........ 344

Explicit instantiation........ 345

The separation model...... 348

Summary................................. 350

Exercises................................. 351

6: Generic algorithms                               355

A first look............................... 355

Predicates...................... 359

Stream iterators............. 361

Algorithm complexity...... 364

Function objects....................... 365

Classification of function objects         367

Automatic creation of function objects 368

Adaptable function objects 372

More function object examples            374

Function pointer adapters 383

Writing your own function object adapters        390

A catalog of STL algorithms....... 394

Support tools for example creation      397

Filling and generating...... 401

Counting........................ 403

Manipulating sequences... 404

Searching and replacing.. 410

Comparing ranges.......... 419

Removing elements........ 423

Sorting and operations on sorted ranges          427

Heap operations............. 438

Applying an operation to each element in a range         440

Numeric algorithms......... 449

General utilities.............. 453

Creating your own STL-style algorithms  455

Summary................................. 457

Exercises................................. 457

7: Generic containers                               465

Containers and iterators............ 465

STL reference documentation 467

A first look............................... 468

Containers of strings....... 474

Inheriting from STL containers            476

A plethora of iterators............... 479

Iterators in reversible containers        481

Iterator categories.......... 482

Predefined iterators........ 485

The basic sequences:  vector, list, deque 491

Basic sequence operations 491

vector............................ 495

deque............................ 502

Converting between sequences           505

Checked random-access. 508

list................................. 509

Swapping basic sequences 516

set.......................................... 517

A completely reusable tokenizer         520

stack....................................... 526

queue...................................... 530

Priority queues......................... 535

Holding bits.............................. 545

bitset<n>....................... 546

vector<bool>................. 551

Associative containers............... 552

Generators and fillers for associative containers           558

The magic of maps......... 561

Multimaps and duplicate keys 563

Multisets........................ 567

Combining STL containers.......... 571

Cleaning up  containers of pointers 574

Creating your own containers..... 576

STL extensions......................... 579

Non-STL containers.................. 581

Summary................................. 586

Exercises................................. 587

Special Topics                                          591

8: Runtime type identification                  593

Runtime casts.......................... 593

The typeid operator.................. 599

Casting to intermediate levels 602

void pointers.................. 603

Using RTTI with templates 604

Multiple inheritance.................... 605

Sensible uses for RTTI............... 606

A trash recycler.............. 607

Mechanism and overhead of RTTI 612

Summary................................. 613

Exercises................................. 614

9: Multiple inheritance                             615

Perspective............................... 615

Interface inheritance.................. 617

Implementation inheritance........ 621

Duplicate subobjects................. 628

Virtual base classes................... 633

Name lookup issues.................. 643

Avoiding MI.............................. 647

Extending an interface............... 648

Summary................................. 653

Exercises................................. 653

10: Design patterns                                  655

The pattern concept.................. 655

The singleton........................... 657

Variations on singleton.... 658

Classifying patterns................... 664

Features, idioms, patterns 664

Building complex objects........... 665

Factories: encapsulating object creation  673

Polymorphic factories...... 676

Abstract factories............ 680

Virtual constructors......... 683

Observer.................................. 690

The “inner class” idiom.... 693

The observer example.... 697

Multiple dispatching................... 701

Multiple dispatching with Visitor           705

Exercises................................. 708

11: Concurrency                                       710

Motivation................................ 711

Concurrency in C++.................. 712

Installing ZThreads......... 713

Defining Tasks.......................... 715

Using Threads.......................... 717

Creating responsive user interfaces    719

Simplifying with Executors 721

Yielding.......................... 725

Sleeping........................ 726

Priority.......................... 728

Sharing limited resources........... 730

Ensuring the existence of objects        731

Improperly accessing resources          735

Controlling access........... 738

Simplified coding with Guards 740

Thread local storage....... 744

Terminating tasks...................... 747

Preventing iostream collision 747

The Ornamental Garden.. 748

Terminating when blocked 754

Interruption.................... 755

Cooperation between threads..... 761

Wait and signal............... 762

Producer-Consumer relationships        767

Solving Threading problems with Queues         770

Broadcast...................... 777

Deadlock.................................. 784

Summary................................. 791

Exercises................................. 793

A: Recommended reading                         797

General C++............................ 797

Bruce’s books................. 798

Chuck’s books................ 798

In-depth C++........................... 798

Design Patterns........................ 800

B: Etc                                                       801

Index                                                       809

 

Preface

In Volume 1 of this book, you learn the fundamentals of C and C++. In this volume, we look at more advanced features, with an eye towards developing techniques and ideas that produce robust C++ programs.

Thus, in this volume we are assuming that you are familiar with the material developed in Volume 1. ^Comment

Goals

Our goals in this book are to: ^Comment

1.               Present the material a simple step at a time, so the reader can easily digest each concept before moving on.

2.               Teach “practical programming” techniques that you can use on a day-to-day basis.

3.               Give you what we think is important for you to understand about the language, rather than everything we know. We believe there is an “information importance hierarchy,” and there are some facts that 95% of programmers will never need to know, but that would just confuse people and add to their perception of the complexity of the language. To take an example from C, if you memorize the operator precedence table (we never did) you can write clever code. But if you have to think about it, it will confuse the reader/maintainer of that code. So forget about precedence, and use parentheses when things aren’t clear. This same attitude will be taken with some information in the C++ language, which is more important for compiler writers than for programmers.

4.               Keep each section focused enough so the lecture time—and the time between exercise periods—is small. Not only does this keep the audience’ minds more active and involved during a hands-on seminar, but it gives the reader a greater sense of accomplishment.

5.               We have endeavored not to use any particular vendor’s version of C++. We have tested the code on all the implementations we could, and when one implementation absolutely refused to work because it doesn’t conform to the C++ Standard, we’ve flagged that fact in the example (you’ll see the flags in the source code) to exclude it from the build process.

6.               Automate the compiling and testing of the code in the book. We have discovered that code that isn’t compiled and tested is probably broken, so in this volume we’ve instrumented the examples with test code. In addition, the code that you can download from http://www.MindView.net has been extracted directly from the text of the book using programs that also automatically create makefiles to compile and run the tests. This way we know that the code in the book is correct.

Chapters

Here is a brief description of the chapters contained in this book:

Part 1: Building Stable Systems

1. Exception handling. Error handling has always been a problem in programming. Even if you dutifully return error information or set a flag, the function caller may simply ignore it. Exception handling is a primary feature in C++ that solves this problem by allowing you to “throw” an object out of your function when a critical error happens. You throw different types of objects for different errors, and the function caller “catches” these objects in separate error handling routines. If you throw an exception, it cannot be ignored, so you can guarantee that something will happen in response to your error. The decision to use exceptions (a good one!) affects code design in fundamental ways. ^Comment

2. Defensive Programming. Many software problems can be prevented. To program defensively is to craft code in such a way that bugs can be found and fixed early before they have a chance to do damage in the field. The use of assertions is the single most important thing you can do to validate your code during development, while at the same time leaving an executable documentation trail in your code that reveals what you were thinking when you wrote the code in the first place. Before you let your code out of your hands it should be rigorously tested. A framework for automated unit testing is an indispensable tool for successful, everyday software development.

Part 2: The Standard C++ Library

3. Strings in Depth. Text processing is the most common programming activity by far. The C++ string class relieves the programmer from memory management issues, while at the same time delivering a powerhouse of text processing capability. C++ also supports the use of wide characters and locales for internationalized applications.

 4. Iostreams. One of the original C++ libraries—the one that provides the essential I/O facility—is called iostreams. Iostreams is intended to replace C’s stdio.h with an I/O library that is easier to use, more flexible, and extensible—you can adapt it to work with your new classes. This chapter teaches you the ins and outs of how to make the best use of the existing iostream library for standard I/O, file I/O, and in-memory formatting. ^Comment

5. Templates in Depth. The distinguishing feature of “modern C++” is the broad power of templates. Templates are for more than just generic containers; they support development of robust, generic, high-performance libraries. There is a lot to know about templates—they constitute, as it were, a sub-language within the C++ language, and give the programmer an impressive degree of control over the compilation process. It is not an understatement to say that templates have revolutionized C++ programming.

6. Generic Algorithms. Algorithms are at the core of computing, and C++, through its template facility, supports an impressive entourage of powerful, efficient, and easy-to-use generic algorithms. The standard algorithms are also customizable through function objects. This chapter looks at every algorithm in the library. (Chapters 6 and 7 cover that portion of the standard C++ library commonly-known as the Standard Template Library, or STL.)

7. Generic Containers & Iterators. C++ supports all the common data structures known to man in a type-safe manner. You never have to worry about what such a container holds; the homogeneity of its objects is guaranteed. Separating the traversing of a container from the container itself, another accomplishment of templates, is made possible through iterators. This ingenious arrangement allows a flexible application of algorithms to containers by means of the simplest of designs.

Part 3: Special Topics

8. Run-time type identification. Run-time type identification (RTTI) lets you find the exact type of an object when you only have a pointer or reference to the base type. Normally, you’ll want to intentionally ignore the exact type of an object and let the virtual function mechanism implement the correct behavior for that type. But occasionally (like when writing software tools such as debuggers) it is helpful to know the exact type of an object for which you only have a base pointer; often this information allows you to perform a special-case operation more efficiently. This chapter explains what RTTI is for and how to use it. ^Comment

9. Multiple inheritance. This sounds simple at first: A new class is inherited from more than one existing class. However, you can end up with ambiguities and multiple copies of base-class objects. That problem is solved with virtual base classes, but the bigger issue remains: When do you use it? Multiple inheritance is only essential when you need to manipulate an object through more than one common base class. This chapter explains the syntax for multiple inheritance, and shows alternative approaches—in particular, how templates solve one common problem. The use of multiple inheritance to repair a “damaged” class interface is demonstrated as a genuinely valuable use of this feature. ^Comment

10. Design Patterns. The most revolutionary advance in programming since objects is the introduction of design patterns. A design pattern is a language-independent codification of a solution to a common programming problem, expressed in such a way that it can apply to many contexts. Patterns such as Singleton, Factory Method, and Visitor now find their way into daily discussions around the keyboard. This chapter shows how to implement and use some of the more useful design patterns in C++.

11. Concurrent Programming. Users have long been used to responsive user interfaces that (seem to) process multiple tasks simultaneously. Modern operating systems allow processes to have multiple threads that share the process address space. Multi-threaded programming requires a different mindset, however, and comes with its own set of “gotchas.” This chapter uses a freely available library (the ZThread library by Eric Crahen of IBM) to show how to effectively manage multi-threaded applications in C++.

Exercises

We have discovered that simple exercises are exceptionally useful during a seminar to complete a student’s understanding, so you’ll find a set at the end of each chapter. ^Comment

These are fairly simple, so they can be finished in a reasonable amount of time in a classroom situation while the instructor observes, making sure all the students are absorbing the material. Some exercises are a bit more challenging to keep advanced students entertained. They’re all designed to be solved in a short time and are only there to test and polish your knowledge rather than present major challenges (presumably, you’ll find those on your own—or more likely they’ll find you).

Exercise solutions

Solutions to exercises can be found in the electronic document The C++ Annotated Solution Guide, Volume 2, available for a nominal fee from www.MindView.net. ^Comment

Source code

The source code for this book is copyrighted freeware, distributed via the web site http://www.MindView.net. The copyright prevents you from republishing the code in print media without permission. ^Comment

In the starting directory where you unpacked the code you will find the following copyright notice: ^Comment

 

You may use the code in your projects and in the classroom as long as the copyright notice is retained. ^Comment

Language standards

Throughout this book, when referring to conformance to the ANSI/ISO C standard, we will be referring to the 1989 standard, and will generally just say ‘C.’ Only if it is necessary to distinguish between Standard 1989 C and older, pre-Standard versions of C will we make the distinction. We do not reference C99 in this book. ^Comment

As this book goes to press the ANSI/ISO C++ committee has long ago finished working on the first C++ standard, commonly known as C++98. We will use the term Standard C++ to refer to this standardized language. If we simply refer to C++, assume we mean “Standard C++.” The C++ standards committee continues to address issues important to the C++ community that will find expression in C++0x, a future C++ standard not likely to be available for many years. ^Comment

Language support

Your compiler may not support all the features discussed in this book, especially if you don’t have the newest version of your compiler. Implementing a language like C++ is a Herculean task, and you can expect that the features will appear in pieces rather than all at once. But if you attempt one of the examples in the book and get a lot of errors from the compiler, it’s not necessarily a bug in the code or the compiler—it may simply not be implemented in your particular compiler yet. On the Windows platform we have validated all examples with the C++ compiler found in Microsoft’s Visual Studio .NET 2003; Borland C++ Builder version 6; the GNU projects g++ compiler, version 3.2, running under Cygwin; and the Edison Design Group’s C++ front end using the Dinkumware full C++ library. We have also run all the examples on Mac OS X with Metrowerks C++ version 8. In those instances where a compiler does not support the feature required by a sample program, we have so indicated in comments in the source code. ^Comment

Seminars, CD-ROMs & consulting

Bruce Eckel’s company, MindView, Inc., provides public hands-on training seminars based on the material in this book, and also for advanced topics. Selected material from each chapter represents a lesson, which is followed by a monitored exercise period so each student receives personal attention. We also provide on-site training, consulting, mentoring, and design & code walkthroughs. Information and sign-up forms for upcoming seminars and other contact information can be found at http://www.MindView.net. ^Comment

Errors

No matter how many tricks a writer uses to detect errors, some always creep in and these often leap off the page for a fresh reader. If you discover anything you believe to be an error, please use the feedback system built into the electronic version of this book, which you will find at http://www.MindView.net. The feedback system uses unique identifiers on the paragraphs in the book, so click on the identifier next to the paragraph that you wish to comment on. Your help is appreciated. ^Comment

About the cover

The cover artwork was painted by Larry O’Brien’s wife, Tina Jensen (yes, the Larry O’Brien who was the editor of Software Development Magazine for so many years). Not only are the pictures beautiful, but they are excellent suggestions of polymorphism. The idea for using these images came from Daniel Will-Harris, the cover designer (www.Will-Harris.com), working with Bruce Eckel.

Acknowledgements

Volume 2 of this book languished in a half-completed state for a long time while Bruce got distracted with other things, notably Java, Design Patterns and especially Python (see www.Python.org). If Chuck hadn’t been willing (foolishly, he has sometimes thought) to finish the other half and bring things up-to-date, this book almost certainly wouldn’t have happened. There aren’t that many people whom Bruce would have felt comfortable entrusting this book to. Chuck’s penchant for precision, correctness and clear explanation is what has made this book as good as it is.

Jamie King acted as an intern under Chuck’s direction during the completion of this book. He was instrumental in making sure the book got finished, not only by providing feedback for Chuck, but especially because of his relentless questioning and picking of every single possible nit that he didn’t completely understand. If your questions are answered by this book, it’s probably because Jamie asked them first. Jamie also enhanced a number of the sample programs and created many of the exercises at the end of each chapter.

Eric Crahen of IBM was instrumental in the completion of Chapter 11 (Concurrent Programming). When we were looking for a threads package, we sought out one that was intuitive and easy to use, while being sufficiently robust to do the job. With Eric we got that and then some—he was extremely cooperative and has used our feedback to enhance his library, while we have benefited from his insights as well.

We are grateful to have had Pete Becker as a technical editor. Few people are as articulate and discriminating as Pete, not to mention as expert in C++ and software development in general. We also thank Bjorn Karlsson for his gracious and timely technical assistance as he reviewed the entire manuscript with little notice.

The ideas and understanding in this book have come from many other sources, as well: friends like Andrea Provaglio, Dan Saks, Scott Meyers, Charles Petzold, and Michael Wilk; pioneers of the language like Bjarne Stroustrup, Andrew Koenig, and Rob Murray; members of the C++ Standards Committee like Nathan Myers (who was particularly helpful and generous with his insights), Herb Sutter, PJ Plauger, Pete Becker, Kevlin Henney, David Abrahams, Tom Plum, Reg Charney, Tom Penello, Sam Druker, and Uwe Steinmueller, John Spicer, Steve Adamczyk, and Daveed Vandevoorde; people who have spoken in the C++ track at the Software Development Conference (which Bruce created and developed, and Chuck spoke in); and often students in seminars, who ask the questions we need to hear to make the material clearer. ^Comment

The book design, cover design, and cover photo were created by Bruce’s friend Daniel Will-Harris, noted author and designer, who used to play with rub-on letters in junior high school while he awaited the invention of computers and desktop publishing. However, we produced the camera-ready pages ourselves, so the typesetting errors are ours. Microsoft^® Word XP was used to write the book and to create camera-ready pages. The body typeface is Georgia and the headlines are in Verdana. The code type face is Andale Mono. ^Comment

We also wish to thank the generous professionals at the Edison Design Group and Dinkumware, Ltd., for giving us complimentary copies of their compiler and library (respectively). Without their assistance some of the examples in this book could not have been tested. We also wish to thank Howard Hinnant and the folks at Metrowerks for a copy of their compiler, and Sandy Smith and the folks at SlickEdit for keeping Chuck supplied with a world-class editing environment for so many years. Greg Comeau also provided a copy of his successful EDG-based compiler, Comeau C++.

A special thanks to all our teachers, and all our students (who are our teachers as well).

Evan Cofsky (Evan@TheUnixMan.com) provided all sorts of assistance on the server as well as development of programs in his now-favorite language, Python. Sharlynn Cobaugh and Paula Steuer were instrumental assistants, preventing Bruce from being washed away in a flood of projects.

Dawn McGee provided much-appreciated inspiration and enthusiasm during this project. The supporting cast of friends includes, but is not limited to: Mark Western, Gen Kiyooka, Kraig Brockschmidt, Zack Urlocker, Andrew Binstock, Neil Rubenking, Steve Sinofsky, JD Hildebrandt, Brian McElhinney, Brinkley Barr, Bill Gates at Midnight Engineering Magazine, Larry Constantine & Lucy Lockwood, Tom Keffer, Greg Perry, Dan Putterman, Christi Westphal, Gene Wang, Dave Mayer, David Intersimone, Claire Sawyers, The Italians (Andrea Provaglio, Laura Fallai, Marco Cantu, Michael Seaver, Huston Franklin, David Wagstaff, Corrado, Ilsa and Christina Giustozzi), Chris & Laura Strand, The Almquists, Brad Jerbic, John Kruth & Marilyn Cvitanic, Holly Payne (yes, the famous novelist!), Mark Mabry, The Robbins Families, The Moelter Families (& the McMillans), The Wilks, Dave Stoner, Laurie Adams, The Cranstons, Larry Fogg, Mike & Karen Sequeira, Gary Entsminger & Allison Brody, Chester Andersen, Joe Lordi, Dave & Brenda Bartlett, The Rentschlers, The Sudeks, Lynn & Todd, and their families. And of course, Mom & Dad, Sandy, James & Natalie, Kim& Jared, Isaac, and Abbi.

Building Stable Systems

 

Software engineers spend about as much time validating code as they do creating it. Quality is or should be the goal of every programmer, and one can go a long way towards that goal by eliminating problems before they rear their ugly heads. In addition, software systems should be robust enough to behave reasonably in the presence of unforeseen environmental problems.

Exception handling was introduced into C++ to support sophisticated error handling without cluttering code with an inordinate amount of error-handling logic. Chapter 1 shows how proper use of exceptions can make for well-behaved software, and also introduces the design principles that underlie exception-safe code. In Chapter 2 we cover unit testing and debugging techniques intended to maximize code quality long before it’s released. The use of assertions to express and enforce program invariants is a sure sign of an experienced software engineer. We also introduce a simple framework to help mitigate the tedium of unit testing.

1: Exception handling

Improving error recovery is one of the most powerful ways you can increase the robustness of your code.

Unfortunately, it’s almost accepted practice to ignore error conditions, as if we’re in a state of denial about errors. One reason, no doubt, is the tediousness and code bloat of checking for many errors. For example, printf( ) returns the number of characters that were successfully printed, but virtually no one checks this value. The proliferation of code alone would be disgusting, not to mention the difficulty it would add in reading the code. ^Comment

The problem with C’s approach to error handling could be thought of as coupling—the user of a function must tie the error-handling code so closely to that function that it becomes too ungainly and awkward to use. ^Comment

One of the major features in C++ is exception handling, which is a better way of thinking about and handling errors. With exception handling the following statements apply: ^Comment

1.               Error-handling code is not nearly so tedious to write, and it doesn't become mixed up with your "normal" code. You write the code you want to happen; later in a separate section you write the code to cope with the problems. If you make multiple calls to a function, you handle the errors from that function once, in one place.

2.               Errors cannot be ignored. If a function needs to send an error message to the caller of that function, it “throws” an object representing that error out of the function. If the caller doesn’t “catch” the error and handle it, it goes to the next enclosing dynamic scope, and so on until the error is either caught or the program terminates because there was no handler to catch that type of exception.

This chapter examines C’s approach to error handling (such as it is), discusses why it did not work well for C, and explains why it won’t work at all for C++. This chapter also covers try, throw, and catch, the C++ keywords that support exception handling. ^Comment

Traditional error handling

In most of the examples in these volumes, we use assert( ) as it was intended: for debugging during development with code that can be disabled with #define NDEBUG for the shipping product. Runtime error checking uses the require.h functions (assure( ) and require( )) developed in Chapter 9 in Volume 1. These functions are a convenient way to say, “There’s a problem here you’ll probably want to handle with some more sophisticated code, but you don’t need to be distracted by it in this example.” The require.h functions might be enough for small programs, but for complicated products you might need to write more sophisticated error-handling code. ^Comment

Error handling is quite straightforward in situations in which you know exactly what to do because you have all the necessary information in that context. Of course, you just handle the error at that point. ^Comment

The problem occurs when you don’t have enough information in that context, and you need to pass the error information into a different context where that information does exist. In C, you can handle this situation using three approaches: ^Comment

1.               Return error information from the function or, if the return value cannot be used this way, set a global error condition flag. (Standard C provides errno and perror( ) to support this.) As mentioned earlier, the programmer is likely to ignore the error information because tedious and obfuscating error checking must occur with each function call. In addition, returning from a function that hits an exceptional condition might not make sense.

2.               Use the little-known Standard C library signal-handling system, implemented with the signal( ) function (to determine what happens when the event occurs) and raise( ) (to generate an event). Again, this approach involves high coupling because it requires the user of any library that generates signals to understand and install the appropriate signal-handling mechanism; also in large projects the signal numbers from different libraries might clash.

3.               Use the nonlocal goto functions in the Standard C library: setjmp( ) and longjmp( ). With setjmp( ) you save a known good state in the program, and if you get into trouble, longjmp( ) will restore that state. Again, there is high coupling between the place where the state is stored and the place where the error occurs.

When considering error-handling schemes with C++, there’s an additional critical problem: The C techniques of signals and setjmp( )/longjmp( ) do not call destructors, so objects aren’t properly cleaned up. (In fact, if longjmp( ) jumps past the end of a scope where destructors should be called, the behavior of the program is undefined.) This makes it virtually impossible to effectively recover from an exceptional condition because you’ll always leave objects behind that haven’t been cleaned up and that can no longer be accessed. The following example demonstrates this with setjmp/longjmp: ^Comment

 

The setjmp( ) function is odd because if you call it directly, it stores all the relevant information about the current processor state (such as the contents of the instruction pointer and runtime stack pointer) in the jmp_buf and returns zero. In this case it behaves like an ordinary function. However, if you call longjmp( ) using the same jmp_buf, it’s as if you’re returning from setjmp( ) again—you pop right out the back end of the setjmp( ). This time, the value returned is the second argument to longjmp( ), so you can detect that you’re actually coming back from a longjmp( ). You can imagine that with many different jmp_bufs, you could pop around to many different places in the program. The difference between a local goto (with a label) and this nonlocal goto is that you can return to any pre-determined location higher up in the runtime stack with setjmp( )/longjmp( ) (wherever you’ve placed a call to setjmp( )). ^Comment

The problem in C++ is that longjmp( ) doesn’t respect objects; in particular it doesn’t call destructors when it jumps out of a scope.^[1] Destructor calls are essential, so this approach won’t work with C++. In fact, the C++ standard states that branching into a scope with goto (effectively bypassing constructor calls), or branching out of a scope with longjmp( ) where an object on the stack has a destructor, constitutes undefined behavior. ^Comment

Throwing an exception

If you encounter an exceptional situation in your code—that is, one in which you don’t have enough information in the current context to decide what to do—you can send information about the error into a larger context by creating an object that contains that information and “throwing” it out of your current context. This is called throwing an exception. Here’s what it looks like: ^Comment

 

MyError is an ordinary class, which in this case takes a char* as a constructor argument. You can use any type when you throw (including built-in types), but usually you’ll create special classes for throwing exceptions. ^Comment

The keyword throw causes a number of relatively magical things to happen. First, it creates a copy of the object you’re throwing and, in effect, “returns” it from the function containing the throw expression, even though that object type isn’t normally what the function is designed to return. A naive way to think about exception handling is as an alternate return mechanism (although you find you can get into trouble if you take the analogy too far). You can also exit from ordinary scopes by throwing an exception. In any case, a value is returned, and the function or scope exits. ^Comment

Any similarity to function returns ends there because where you return is some place completely different from where a normal function call returns. (You end up in an appropriate part of the code—called an exception handler—that might be far removed from where the exception was thrown.) In addition, any local objects created by the time the exception occurs are destroyed. This automatic cleanup of local objects is often called “stack unwinding.” ^Comment

In addition, you can throw as many different types of objects as you want. Typically, you’ll throw a different type for each category of error. The idea is to store the information in the object and in the name of its class so that someone in a calling context can figure out what to do with your exception. ^Comment

Catching an exception

As mentioned earlier, one of the advantages of C++ exception handling is that it allows you to concentrate on the problem you’re actually trying to solve in one place, and then deal with the errors from that code in another place. ^Comment

The try block

If you’re inside a function and you throw an exception (or a called function throws an exception), the function exits in the process of throwing. If you don’t want a throw to leave a function, you can set up a special block within the function where you try to solve your actual programming problem (and potentially generate exceptions). This block is called the try block because you try your various function calls there. The try block is an ordinary scope, preceded by the keyword try: ^Comment

 

If you check for errors by carefully examining the return codes from the functions you use, you need to surround every function call with setup and test code, even if you call the same function several times. With exception handling, you put everything in a try block and handle exceptions after the try block. Thus, your code is a lot easier to write and easier to read because the goal of the code is not confused with the error checking. ^Comment

Exception handlers

Of course, the thrown exception must end up some place. This place is the exception handler, and you need one exception handler for every exception type you want to catch. Exception handlers immediately follow the try block and are denoted by the keyword catch: ^Comment

 

The syntax of a catch clause resembles functions that take a single argument. The identifier (id1, id2, and so on) can be used inside the handler, just like a function argument, although you can omit the identifier if it’s not needed in the handler. The exception type usually gives you enough information to deal with it. ^Comment

The handlers must appear directly after the try block. If an exception is thrown, the exception-handling mechanism goes hunting for the first handler with an argument that matches the type of the exception. It then enters that catch clause, and the exception is considered handled. (The search for handlers stops once the catch clause is found.) Only the matching catch clause executes; control then resumes after the last handler associated with that try block. ^Comment

Notice that, within the try block, a number of different function calls might generate the same type of exception, but you need only one handler. ^Comment

To illustrate using try and catch, the following variation of Nonlocal.cpp replaces the call to setjmp( ) with a try block and replaces the call to longjmp( ) with a throw statement. ^Comment