ZeePedia

Public C++ Seminars:Preface

Introduction to Objects:The progress of abstraction, Extreme programming >>
img
.....
Thinking in C++,
Volume 1, 2nd Edition
Completed January 13, 2000
Bruce Eckel, President,
MindView, Inc.
Planet PDF brings you the Portable Document
Format (PDF) version of Thinking in C++ Volume 1
(2nd Edition). Planet PDF is the premier PDF-
related site on the web. There is news, software,
white papers, interviews, product reviews, Web
links, code samples, a forum, and regular articles
by many of the most prominent and respected PDF
experts in the world. Visit our sites for more detail:
img
Winner, Software Development Magazine's
1996 Jolt Award for Best Book of the Year
"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
img
Comments from Readers:
Wonderful book ... Great stuff! Andrew Schulman, Doctor Dobbs Journal
An absolute, unqualified must. One of the most-used, most trusted books on my
shelf." TUG Lines
This is stuff a programmer can really use. IEEE Computer
A refreshing departure. PJ Plauger, Embedded Systems Programming
magazine
...Eckel succeeds ... it's so readable. Unix World
Should definitely be your first buy. C Gazette
A fantastic reference for C++! Michael Brandt, Senior Analyst/Programmer,
Sydney, Australia
On our project at HRB Systems we call your book "The Answer Book". It is our
C++ Bible for the project. Curt Snyder, HRB Systems
Your book is really great, and I can't thank you enough for making it available
for free on the web. It's one of the most thorough and useful references for C++
I've seen. Russell Davis
... the only book out there that even comes close to being actually readable when
trying to learn the ropes of C++ (and the basics of good object oriented
programming in general). Gunther Schulz, KawaiiSoft
I love the examples in your book. There's stuff there that I never would have
thought of (and some things that I didn't know you could do)! Rich Herrick,
Senior Associate Software Engineer, Lockheed-Martin Federal Systems,
Owego, NY
It's an amazing book. Any questions I have I refer to this online book. Helped in
every case. I'm simply happy to have access to a book of this caliber. Wes Kells,
Comp Eng. Student, SLC Kingston.
You are an invaluable resource and I greatly appreciate your books, email list
etc... It seems every project I have worked on has been successful because of your
insights. Justin Voshell
This is the book I have been looking for on C++. Thomas A. Fink, Managing
Director, Trepp, LLC
Your books are authoritative yet easy to read. To my colleagues I call you the
K&R of C++. Mark Orlassino, Senior Design Engineer, Harmon
Industries, Inc., Hauppauge, NY
img
When I first started learning C++, your book "Thinking in C++" was my shining
guide light in a dark tunnel. It has been my endeavor to improve my C++ skills
whenever possible, and to that effect, "Thinking in C++" has given me the strong
foundation for my continuous improvement. Peter Tran, Senior Systems
Analyst (IM), Compaq Computer Corporation
This book is the best general reference in my on-going quest to master C++. Most
books explain some topics thoroughly but are deficient in others. "Thinking in
C++" 2/E does not pass the buck to another book. When I have questions it has
answers. Thomas Michel
I have a whole mountain of books and none of them make sense nor do they
explain things properly. I have been dying for a good template and STL book.
Then I decided to read your material and I was amazed. What you did was show
how to write C++ with templates and STL without bogging down with details.
What you did was what I expected of the C++ community, the next generation of
C++ authors. As an author I AM IMPRESSED at your writing and explanation
skills. You covered topics that nobody has properly covered before. Your
approach is one from a person who has actually sat down and went through the
material in detail. And then you questioned the sanity of the situation and what
would be the problem areas. On my bookshelf, it will definitely be one of the
necessary books, right beside Petzold. Christian Gross, consultant/mentor
cgross@eusoft.com
I think your book is very, very, VERY good. I have compared it to others in the
bookstore, and have found that your book actually teaches me basic C++
fundamentals while I learn the STL... a very nice experience to learn about both
at once, hand-in-hand. I think your book is laid out very well, and explains
things in an easy-to-understand fashion. Jeff Meininger, Software Developer,
boxybutgood.com
Your book is the best by far of any I've seen. Please get it right so that we can all
have an excellent and "reliable" reference work! And please hurry! We are
desperate for a work of this quality! Steve Strickland, Live Minds (a Puzzle
business)
(On Usenet) Unlike most other C++ authors, Eckel has made a career of teaching
C++ and Java classes ONLY. He's had the benefit of a GREAT deal of novice
feedback, and the books reflect that. His books are not just about writing in
C++/Java, but understanding the intent of the languages and the mindset that
goes with thinking in them. Eckel's also the best technical writer I've read since
Jeff Duntemann. Very clear and easy to read. Don't be put off by the apparent
large size of his books. Either can be read in *less* than 21 days. :-} Randy
Crawford, MRJ Technology Solutions, Fairfax VA
img
Your work is greatly appreciated and I thank you for helping me understand
both C++ and Java better. Barry Wallin, Math/Computer Science Teacher,
Rosemount High School, Rosemount, MN
I would like to thank you for your book "Thinking in C++" which is, with no
doubt, the best book I ever read about this subject. Riccardo Tarli - SW
Engineer - R&D TXT Ingegneria Informatica - Italy
I have been reading both of your books, Thinking In Java and Thinking In C++.
Each of these books is easily the best in its category. Ratnakarprasad H.
Tiwari, Mumbai, India
... the "Debugging Hints" section is so valuable, I'm tempted to print it and keep
it with me at all times. I think this section should be a mandatory part of any
introductory class after the first one or two programming problems. Fred
Ballard, Synectics Inc.
Your book is really a treasure trove of C++ knowledge. I feel like you give a good
overview and then explain the nuts and bolts. Raymond Pickles, Antenna
Section, Radar Division, U.S. Naval Research Laboratory, Washington
DC
As an Internal Medicine Specialist and Computer Scientist I spend a great deal of
time trying to extract information from books and journals. My experience is that
a good author is one who makes difficult concepts accessible, a great one makes
it look almost easy. On this score you are certainly one of my top three technical
writers. Keep up the good work. Dr. Declan O'Kane, Leicester, England
For my second-level C++ course, "Thinking in C++" is my constant reference
and companion, and I urge my students to consult it regularly. I refer to the
chapter on Operator Overloading constantly. The examples/code alone are
worth the cost of the book many times over. So many books and development
environments are predicated on the assumption that the only application for a
programming language is for a Windows environment; it's great to find and use
a book which concentrates on C++ so we can prepare our students for careers in
fields like embedded systems, networking, etc., which require real depth of
understanding. Robert Chase, Professor, Sweet Briar College
I think it's a fantastic intro to C++, especially for longtime dabblers like me ­ I
often know "how," but rarely "why," and TIC2 is a godsend. Tony Likhite,
System Administrator/DBA, Together Networks
After reading the first 80 pages of this book, I have a better understanding of oop
then I've gotten out of the ton of books I've accumulated on the subject. Thanks...
Rick Schneewind
img
img
Thinking
In
C++
Second Edition
Bruce Eckel
President, MindView Inc.
Prentice Hall
Upper Saddle River, New Jersey 07458
http://www.prenhall.com
img
img
Publisher: Alan Apt
Production Editor: Scott Disanno
Executive Managing Editor: Vince O'Brien
Vice President and Editorial Director: Marcia Horton
Vice President of Production and Manufacturing: David W. Riccardi
Project Manager: Ana Terry
Book Design, Cover Design and Cover Line Art:
Daniel Will-Harris, daniel@will-harris.com
Cover Watercolor: Bruce Eckel
Copy Editor: Stephanie English
Production Coordinator: Lori Bulwin
Editorial Assistant: Toni Holm
Marketing Managers: Jennie Burger, Bryan Gambrel
©2000 by Bruce Eckel, MindView, Inc.
Published by Prentice Hall Inc.
Pearson Higher Education
Upper Saddle River, New Jersey 07632
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 author, 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.
Printed in the United States of America
10 9 8 7 6 5 4 3 2 1
ISBN 0-13-979809-9
Prentice-Hall International (UK) Limited, London
Prentice-Hall of Australia Pty. Limited, Sydney
Prentice-Hall Canada, Inc., Toronto
Prentice-Hall Hispanoamericana, S.A., Mexico
img
Prentice-Hall of India Private Limited, New Delhi
Prentice-Hall of Japan, Inc., Tokyo
Pearson Education Asia Ltd., Singapore
Editora Prentice-Hall do Brasil, Ltda., Rio de Janeiro
img
Public
C++ Seminars
Check
for in-depth details and the date
and location of the next:
Hands-On C++ Seminar
· Based on this book
· Get a solid grounding in Standard C++ fundamentals
· Includes in-class programming exercises
· Personal attention during exercises
Intermediate C++ Seminar
· Based on Volume 2 of this book (downloadable at
)
· In-depth coverage of the Standard C++ Library
· Strings, containers, iterators, algorithms
· In-depth templates & exception handling
Advanced C++ Topics
· Based on advanced topics in Volume 2 of this book
· Design patterns
· Building robust systems
· Creating testing & debugging frameworks
Subscribe to the free newsletter
to be automatically informed
of upcoming seminars
Also visit www.BrucEckel.com for:
Consulting Services
!"
!"
Exercise solutions for this book
img
Seminars-on-CD-ROM
If you like theThinking in C
Seminar-on-CD packaged with
this book, then you'll also like:
Bruce Eckel's
Hands-On C++ Seminar
Multimedia CD ROM
It's like coming to the seminar!
Available at
·
Overhead slides and synchronized audio recorded by Bruce Eckel
·
All the lectures from the Hands-On C++ Seminar
·
Based on this book
·
Get a solid grounding in Standard C++ Fundamentals
·
Just play it to see and hear the lectures!
·
Lectures are indexed so you can rapidly locate the discussion
of any subject
·
Details and sample lecture can be found on the Web site
See
for other Seminars-on-CD ROM
· The Intermediate C++ Seminar
· Advanced C++ Topics
img
Dedication
To my parents, my sister, and my brother
img
...................................
What's inside...
1: Introduction to
What's new in
The progress of
What's in Volume 2
An object has an
The hidden
Reusing the
Inheritance: reusing
Language
Is-a vs. is-like-a
Interchangeable
The book's
objects with
CD ROMs, seminars,
Creating and
Exception handling:
Book design and
Analysis
Phase 1: What are
Phase 2: How will
Phase 4: Iterate
img
.................................................................
More about
Extreme
Character array
Why C++
Introducing
Reading and
You're already on
Introducing
Systems are easier to
Maximal leverage
Source-code reuse
Strategies for
Creating
Using the C
Creating your own
2: Making & Using
Controlling
The process of
language
The break and
Tools for separate
Introduction to
Your first
Auto increment
Introduction to
Fundamentals of
img
....................................................................
Function
Modifying the
Introduction to
Defining a
Pointers and references
Complicated declarations
Defining variables
Arrays of pointers
Specifying storage
Make: managing
separate
Operators and
A tiny C-like
Dynamic
Common pitfalls
Abstract
sizeof ­ an operator
Composite type
Header file
Aliasing names
Importance of
Combining variables
The multiple-declaration
Clarifying programs
The preprocessor directives
#define, #ifdef,
Saving memory
Turning variables and
img
....................................................
Aggregate
5: Hiding the
Default
C++ access
7: Function Overloading
& Default
More name
Modifying Stash to use
Overloading on
Modifying Stack to use
Overloading
Hiding the
Default
Choosing overloading
6: Initialization &
vs. default
Guaranteed
initialization with the
Guaranteed cleanup
with the
Elimination of the
Stash with
Assignment and
constructors and
Function arguments &
Stack with constructors
img
..........................................................
Other storage
Passing and returning
Compile-time constants
Static members
const objects &
Defining storage for
Static initialization
Preprocessor
Alternate linkage
11: References & the
Stash & Stack
Inlines &
References
Hidden activities in
constructors &
Argument-passing
The copy-
More preprocessor
Passing & returning
Improved error
Alternatives to copy-
Pointers
Static elements
static variables
img
.....................................................
12: Operator
new & delete
Warning &
Making a pointer
Running out
Overloadable
Overloading
Overloading global
Arguments &
Overloading
Overloading
Operators you
Non-member
Overloading
14: Inheritance &
Automatic type
Composition
Inheritance
Pitfalls in automatic
The constructor
Member object
13: Dynamic
Built-in types in the
Combining composition
Order of constructor &
Functions that
Memory manager
don't automatically
Early examples
Inheritance and static
delete void* is
Cleanup responsibility
img
..........................................................
Abstract base classes
Choosing composition
and pure virtual
Inheritance and
Operator overloading
Overloading &
Multiple
Incremental
virtual functions &
Behavior of virtual functions
Upcasting and the
Destructors and
Composition vs.
Pointer & reference
Creating an
Operator
15: Polymorphism &
Evolution of C++
16: Introduction to
Overview
How C++ implements
Non-inline
Stack and Stash
Why virtual
Turning ownership
img
..................
Holding objects
Introducing
B: Programming
C: Recommended
Depth &
img
Preface
Like any human language, C++ provides a way to
express concepts. If successful, this medium of
expression will be significantly easier and more flexible
than the alternatives as problems grow larger and more
complex.
img
You can't just look at C++ as a collection of features; some of the
features make no sense in isolation. You can only use the sum of
the parts if you are thinking about design, not simply coding. And
to understand C++ this way, you must understand the problems
with C and with programming in general. This book discusses
programming problems, why they are problems, and the approach
C++ has taken to solve such problems. Thus, the set of features I
explain in each chapter will be based on the way that I see a
particular type of problem being solved with the language. In this
way I hope to move you, a little at a time, from understanding C to
the point where the C++ mindset becomes your native tongue.
Throughout, I'll be taking the attitude that you want to build a
model in your head that allows you to understand the language all
the way down to the bare metal; if you encounter a puzzle, you'll
be able to feed it to your model and deduce the answer. I will try to
convey to you the insights that have rearranged my brain to make
me start "thinking in C++."
What's new in the second edition
This book is a thorough rewrite of the first edition to reflect all of
the changes introduced in C++ by the finalization of the C++
Standard, and also to reflect what I've learned since writing the
first edition. The entire text present in the first edition has been
examined and rewritten, sometimes removing old examples, often
changing existing examples and adding new ones, and adding
many new exercises. Significant rearrangement and re-ordering of
the material took place to reflect the availability of better tools and
my improved understanding of how people learn C++. A new
chapter was added which is a rapid introduction to the C concepts
and basic C++ features for those who don't have the C background
to tackle the rest of the book. The CD ROM bound into the back of
the book contains a seminar that is an even gentler introduction to
the C concepts necessary to understand C++ (or Java). It was
created by Chuck Allison for my company (MindView, Inc.), and
2
Thinking in C++
img
it's called "Thinking in C: Foundations for Java and C++." It
introduces you to the aspects of C that are necessary for you to
move on to C++ or Java, leaving out the nasty bits that C
programmers must deal with on a day-to-day basis but that the
C++ and Java languages steer you away from (or even eliminate, in
the case of Java).
So the short answer to the question "what's different in the 2nd
edition?" is: what isn't brand new has been rewritten, sometimes to
the point where you wouldn't recognize the original examples and
material.
What's in Volume 2 of this book
The completion of the C++ Standard also added a number of
important new libraries, such as string and the containers and
algorithms in the Standard C++ Library, as well as new complexity
in templates. These and other more advanced topics have been
relegated to Volume 2 of this book, including issues such as
multiple inheritance, exception handling, design patterns, and
topics about building and debugging stable systems.
How to get Volume 2
Just like the book you currently hold, Thinking in C++, Volume 2 is
downloadable in its entirety from my Web site at
. You can find information on the Web site
about the expected print date of Volume 2.
The Web site also contains the source code for both of the books,
along with updates and information about other seminars-on-CD
ROM that MindView, Inc. offers, public seminars, and in-house
training, consulting, mentoring, and walkthroughs.
Preface
3
img
..
Prerequisites
In the first edition of this book, I decided to assume that someone
else had taught you C and that you have at least a reading level of
comfort with it. My primary focus was on simplifying what I found
difficult: the C++ language. In this edition I have added a chapter
that is a rapid introduction to C, along with the Thinking in C
seminar-on-CD, but I am still assuming that you already have some
kind of programming experience. In addition, just as you learn
many new words intuitively by seeing them in context in a novel,
it's possible to learn a great deal about C from the context in which
it is used in the rest of the book.
Learning C++
I clawed my way into C++ from exactly the same position I expect
many of the readers of this book are in: as a programmer with a
very no-nonsense, nuts-and-bolts attitude about programming.
Worse, my background and experience was in hardware-level
embedded programming, in which C has often been considered a
high-level language and an inefficient overkill for pushing bits
around. I discovered later that I wasn't even a very good C
programmer, hiding my ignorance of structures, malloc( )and
free( ), setjmp( )and longjmp( ) and other "sophisticated"
,
concepts, scuttling away in shame when the subjects came up in
conversation instead of reaching out for new knowledge.
When I began my struggle to understand C++, the only decent
book was Bjarne Stroustrup's self-professed "expert's guide,1" so I
was left to simplify the basic concepts on my own. This resulted in
my first C++ book,2 which was essentially a brain dump of my
experience. That was designed as a reader's guide to bring
1 Bjarne Stroustrup, The C++ Programming Language, Addison-Wesley, 1986 (first
edition).
2 Using C++, Osborne/McGraw-Hill 1989.
4
Thinking in C++
img
.
programmers into C and C++ at the same time. Both editions3 of
the book garnered enthusiastic response.
At about the same time that Using C++ came out, I began teaching
the language in seminars and presentations. Teaching C++ (and
later, Java) became my profession; I've seen nodding heads, blank
faces, and puzzled expressions in audiences all over the world
since 1989. As I began giving in-house training to smaller groups of
people, I discovered something during the exercises. Even those
people who were smiling and nodding were confused about many
issues. I found out, by creating and chairing the C++ and Java
tracks at the Software Development Conference for many years,
that I and other speakers tended to give the typical audience too
many topics, too fast. So eventually, through both variety in the
audience level and the way that I presented the material, I would
end up losing some portion of the audience. Maybe it's asking too
much, but because I am one of those people resistant to traditional
lecturing (and for most people, I believe, such resistance results
from boredom), I wanted to try to keep everyone up to speed.
For a time, I was creating a number of different presentations in
fairly short order. Thus, I ended up learning by experiment and
iteration (a technique that also works well in C++ program design).
Eventually I developed a course using everything I had learned
from my teaching experience. It tackles the learning problem in
discrete, easy-to-digest steps and for a hands-on seminar (the ideal
learning situation) there are exercises following each of the
presentations. You can find out about my public seminars at
, and you can also learn about the seminars that
I've turned into CD ROMs.
The first edition of this book developed over the course of two
years, and the material in this book has been road-tested in many
forms in many different seminars. The feedback that I've gotten
3 Using C++ and C++ Inside & Out, Osborne/McGraw-Hill 1993.
Preface
5
img
from each seminar has helped me change and refocus the material
until I feel it works well as a teaching medium. But it isn't just a
seminar handout; I tried to pack as much information as I could
within these pages, and structure it to draw you through onto the
next subject. More than anything, the book is designed to serve the
solitary reader who is struggling with a new programming
language.
Goals
My goals in this book are to:
1.
Present the material one simple step at a time, so the reader
can easily digest each concept before moving on.
2.
Use examples that are as simple and short as possible. This
often prevents me from tackling "real world" problems, but
I've found that beginners are usually happier when they can
understand every detail of an example rather than being
impressed by the scope of the problem it solves. Also, there's
a severe limit to the amount of code that can be absorbed in a
classroom situation. For this I sometimes receive criticism for
using "toy examples," but I'm willing to accept that in favor
of producing something pedagogically useful.
3.
Carefully sequence the presentation of features so that you
aren't seeing something you haven't been exposed to. Of
course, this isn't always possible; in those situations, a brief
introductory description will be given.
4.
Give you what I think is important for you to understand
about the language, rather than everything that I know. I
believe there is an "information importance hierarchy," and
there are some facts that 95 percent of programmers will
never need to know and that would just confuse them and
add to their perception of the complexity of the language. To
take an example from C, if you memorize the operator
6
Thinking in C++
img
precedence table (I 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 I think is more important for compiler
writers than for programmers.
5.
Keep each section focused enough so the lecture time ­ and
the time between exercise periods ­ is reasonable. Not only
does this keep the audience's minds more active and
involved during a hands-on seminar, it gives the reader a
greater sense of accomplishment.
6.
Provide readers with a solid foundation so they can
understand the issues well enough to move on to more
difficult coursework and books (in particular, Volume 2 of
this book).
7.
I've tried not to use any particular vendor's version of C++
because, for learning the language, I don't think that the
details of a particular implementation are as important as the
language itself. Most vendors' documentation concerning
their own implementation specifics is adequate.
Chapters
C++ is a language in which new and different features are built on
top of an existing syntax. (Because of this, it is referred to as a
hybrid object-oriented programming language.) As more people
pass through the learning curve, we've begun to get a feel for the
way programmers move through the stages of the C++ language
features. Because it appears to be the natural progression of the
procedurally-trained mind, I decided to understand and follow this
same path and accelerate the process by posing and answering the
questions that came to me as I learned the language and those
questions that came from audiences as I taught the language.
Preface
7
img
This course was designed with one thing in mind: to streamline the
process of learning C++. Audience feedback helped me understand
which parts were difficult and needed extra illumination. In the
areas in which I got ambitious and included too many features all
at once, I came to know ­ through the process of presenting the
material ­ that if you include a lot of new features, you have to
explain them all, and the student's confusion is easily
compounded. As a result, I've taken a great deal of trouble to
introduce the features as few at a time as possible; ideally, only one
major concept at a time per chapter.
The goal, then, is for each chapter to teach a single concept, or a
small group of associated concepts, in such a way that no
additional features are relied upon. That way you can digest each
piece in the context of your current knowledge before moving on.
To accomplish this, I leave some C features in place for longer than
I would prefer. The benefit is that you will not be confused by
seeing all the C++ features used before they are explained, so your
introduction to the language will be gentle and will mirror the way
you will assimilate the features if left to your own devices.
Here is a brief description of the chapters contained in this book:
Chapter 1: Introduction to Objects
. When projects became too big
and complicated to easily maintain, the "software crisis" was born,
with programmers saying, "We can't get projects done, and if we
can, they're too expensive!" This precipitated a number of
responses, which are discussed in this chapter along with the ideas
of object-oriented programming (OOP) and how it attempts to
solve the software crisis. The chapter walks you through the basic
concepts and features of OOP and also introduces the analysis and
design process. In addition, you'll learn about the benefits and
concerns of adopting the language and suggestions for moving into
the world of C++.
Chapter 2: Making and Using Objects
. This chapter explains the
process of building programs using compilers and libraries. It
8
Thinking in C++
img
introduces the first C++ program in the book and shows how
programs are constructed and compiled. Then some of the basic
libraries of objects available in Standard C++ are introduced. By the
time you finish this chapter you'll have a good grasp of what it
means to write a C++ program using off-the-shelf object libraries.
Chapter 3: The C in C++This chapter is a dense overview of the
.
features in C that are used in C++, as well as a number of basic
features that are available only in C++. It also introduces the
"make" utility that's common in the software development world
and that is used to build all the examples in this book (the source
code for the book, which is available at ,
contains makefiles for each chapter). Chapter 3 assumes that you
have a solid grounding in some procedural programming language
like Pascal, C, or even some flavors of Basic (as long as you've
written plenty of code in that language, especially functions). If you
find this chapter a bit too much, you should first go through the
Thinking in C seminar on the CD that's bound with this book (and
also available at ).
Chapter 4: Data Abstraction
. Most features in C++ revolve around
the ability to create new data types. Not only does this provide
superior code organization, but it lays the groundwork for more
powerful OOP abilities. You'll see how this idea is facilitated by the
simple act of putting functions inside structures, the details of how
to do it, and what kind of code it creates. You'll also learn the best
way to organize your code into header files and implementation
files.
Chapter 5: Hiding the Implementation
. You can decide that some
of the data and functions in your structure are unavailable to the
user of the new type by making them private. This means that you
can separate the underlying implementation from the interface that
the client programmer sees, and thus allow that implementation to
be easily changed without affecting client code. The keyword class
is also introduced as a fancier way to describe a new data type, and
Preface
9
img
the meaning of the word "object" is demystified (it's a fancy
variable).
Chapter 6: Initialization and Cleanup
. One of the most common C
errors results from uninitialized variables. The constructor in C++
allows you to guarantee that variables of your new data type
("objects of your class") will always be initialized properly. If your
objects also require some sort of cleanup, you can guarantee that
this cleanup will always happen with the C++ destructor.
Chapter 7: Function Overloading and Default Arguments  is
. C++
intended to help you build big, complex projects. While doing this,
you may bring in multiple libraries that use the same function
name, and you may also choose to use the same name with
different meanings within a single library. C++ makes this easy
with function overloading, which allows you to reuse the same
function name as long as the argument lists are different. Default
arguments allow you to call the same function in different ways by
automatically providing default values for some of your
arguments.
Chapter 8: ConstantsThis chapter covers the const and volatile
.
keywords, which have additional meaning in C++, especially
inside classes. You'll learn what it means to apply const to a pointer
definition. The chapter also shows how the meaning of const varies
when used inside and outside of classes and how to create compile-
time constants inside classes.
Chapter 9: Inline Functions
. Preprocessor macros eliminate
function call overhead, but the preprocessor also eliminates
valuable C++ type checking. The inline function gives you all the
benefits of a preprocessor macro plus all of the benefits of a real
function call. This chapter thoroughly explores the implementation
and use of inline functions.
Chapter 10: Name ControlCreating names is a fundamental
.
activity in programming, and when a project gets large, the number
10
Thinking in C++
img
of names can be overwhelming. C++ allows you a great deal of
control over names in terms of their creation, visibility, placement
of storage, and linkage. This chapter shows how names are
controlled in C++ using two techniques. First, the static keyword is
used to control visibility and linkage, and its special meaning with
classes is explored. A far more useful technique for controlling
names at the global scope is C++'s namespacefeature, which
allows you to break up the global name space into distinct regions.
Chapter 11: References and the Copy-Constructor  pointers
. C++
work like C pointers with the additional benefit of stronger C++
type checking. C++ also provides an additional way to handle
addresses: from Algol and Pascal, C++ lifts the reference, which lets
the compiler handle the address manipulation while you use
ordinary notation. You'll also meet the copy-constructor, which
controls the way objects are passed into and out of functions by
value. Finally, the C++ pointer-to-member is illuminated.
Chapter 12: Operator Overloading
. This feature is sometimes
called "syntactic sugar;" it lets you sweeten the syntax for using
your type by allowing operators as well as function calls. In this
chapter you'll learn that operator overloading is just a different
type of function call and you'll learn how to write your own,
dealing with the sometimes-confusing uses of arguments, return
types, and the decision of whether to make an operator a member
or friend.
Chapter 13: Dynamic Object Creation
. How many planes will an
air-traffic system need to manage? How many shapes will a CAD
system require? In the general programming problem, you can't
know the quantity, lifetime, or type of objects needed by your
running program. In this chapter, you'll learn how C++'s new and
delete elegantly solve this problem by safely creating objects on the
heap. You'll also see how new and delete can be overloaded in a
variety of ways so you can control how storage is allocated and
released.
Preface
11
img
Chapter 14: Inheritance and Composition
. Data abstraction allows
you to create new types from scratch, but with composition and
inheritance, you can create new types from existing types. With
composition, you assemble a new type using other types as pieces,
and with inheritance, you create a more specific version of an
existing type. In this chapter you'll learn the syntax, how to
redefine functions, and the importance of construction and
destruction for inheritance and composition.
Chapter 15: Polymorphism and virtual Functions your own,
. On
you might take nine months to discover and understand this
cornerstone of OOP. Through small, simple examples, you'll see
how to create a family of types with inheritance and manipulate
objects in that family through their common base class. The virtual
keyword allows you to treat all objects in this family generically,
which means that the bulk of your code doesn't rely on specific
type information. This makes your programs extensible, so
building programs and code maintenance is easier and cheaper.
Chapter 16: Introduction to Templates
. Inheritance and
composition allow you to reuse object code, but that doesn't solve
all of your reuse needs. Templates allow you to reuse source code
by providing the compiler with a way to substitute type names in
the body of a class or function. This supports the use of container
class libraries, which are important tools for the rapid, robust
development of object-oriented programs (the Standard C++
Library includes a significant library of container classes). This
chapter gives you a thorough grounding in this essential subject.
Additional topics (and more advanced subjects) are available in
Volume 2 of this book, which can be downloaded from the Web site
.
12
Thinking in C++
img
Exercises
I've discovered that 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. The number of exercises has been
greatly increased over the number in the first edition.
Many of the exercises are fairly simple so that they can be finished
in a reasonable amount of time in a classroom situation or lab
section while the instructor observes, making sure all students are
absorbing the material. Some exercises are a bit more challenging to
keep advanced students entertained. The bulk of the exercises are
designed to be solved in a short time and are intended only 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 selected exercises can be found in the electronic
document The Thinking in C++ Annotated Solution Guide, available
for a small fee from .
Source code
The source code for this book is copyrighted freeware, distributed
via the Web site . The copyright prevents you
from republishing the code in print media without permission, but
you are granted the right to use it in many other situations (see
below).
The code is available in a zipped file, designed to be extracted for
any platform that has a "zip" utility (most do; you can search the
Internet to find a version for your platform if you don't already
have one installed). In the starting directory where you unpacked
the code you will find the following copyright notice:
Preface
13
img
//:! :Copyright.txt
Copyright (c) 2000, Bruce Eckel
Source code file from the book "Thinking in C++"
All rights reserved EXCEPT as allowed by the
following statements: You can freely use this file
for your own work (personal or commercial),
including modifications and distribution in
executable form only. Permission is granted to use
this file in classroom situations, including its
use in presentation materials, as long as the book
"Thinking in C++" is cited as the source.
Except in classroom situations, you cannot copy
and distribute this code; instead, the sole
distribution point is http://
(and official mirror sites) where it is
available for free. You cannot remove this
copyright and notice. You cannot distribute
modified versions of the source code in this
package. You cannot use this file in printed
media without the express permission of the
author. Bruce Eckel makes no representation about
the suitability of this software for any purpose.
It is provided "as is" without express or implied
warranty of any kind, including any implied
warranty of merchantability, fitness for a
particular purpose, or non-infringement. The entire
risk as to the quality and performance of the
software is with you. Bruce Eckel and the
publisher shall not be liable for any damages
suffered by you or any third party as a result of
using or distributing this software. In no event
will Bruce Eckel or the publisher be liable for
any lost revenue, profit, or data, or for direct,
indirect, special, consequential, incidental, or
punitive damages, however caused and regardless of
the theory of liability, arising out of the use of
or inability to use software, even if Bruce Eckel
and the publisher have been advised of the
possibility of such damages. Should the software
prove defective, you assume the cost of all
necessary servicing, repair, or correction. If you
think you've found an error, please submit the
correction using the form you will find at
. (Please use the same
form for non-code errors found in the book.)
14
Thinking in C++
img
///:~
You may use the code in your projects and in the classroom as long
as the copyright notice is retained.
Language standards
Throughout this book, when referring to conformance to the ISO C
standard, I will generally just say `C.' Only if it is necessary to
distinguish between Standard C and older, pre-Standard versions
of C will I make a distinction.
At this writing the C++ Standards Committee was finished
working on the language. Thus, I will use the term Standard C++ to
refer to the standardized language. If I simply refer to C++ you
should assume I mean "Standard C++."
There is some confusion over the actual name of the C++ Standards
Committee and the name of the standard itself. Steve Clamage, the
committee chair, clarified this:
There are two C++ standardization committees: The NCITS (formerly
X3) J16 committee and the ISO JTC1/SC22/WG14 committee. ANSI
charters NCITS to create technical committees for developing
American national standards.
J16 was chartered in 1989 to create an American standard for C++. In
about 1991 WG14 was chartered to create an international standard.
The J16 project was converted to a "Type I" (International) project
and subordinated to the ISO standardization effort.
The two committees meet at the same time at the same location, and
the J16 vote constitutes the American vote on WG14. WG14 delegates
technical work to J16. WG14 votes on the technical work of J16.
The C++ standard was originally created as an ISO standard. ANSI
later voted (as recommended by J16) to adopt the ISO C++ standard as
the American standard for C++.
Preface
15
img
Thus, `ISO' is the correct way to refer to the C++ Standard.
Language support
Your compiler may not support all of the features discussed in this
book, especially if you don't have the newest version of the
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.
The book's CD ROM
The primary content of the CD ROM packaged in the back of this
book is a "seminar on CD ROM" titled Thinking in C: Foundations for
Java & C++ by Chuck Allison (published by MindView, Inc., and
also available in quantities at ). This contains
many hours of audio lectures and slides, and can be viewed on
most computers if you have a CD ROM player and a sound system.
The goal of Thinking in C is to take you carefully through the
fundamentals of the C language. It focuses on the knowledge
necessary for you to be able to move on to the C++ or Java
languages instead of trying to make you an expert in all the dark
corners of C. (One of the reasons for using a higher-level language
like C++ or Java is precisely so we can avoid many of these dark
corners.) It also contains exercises and guided solutions. Keep in
mind that because Chapter 3 of this book goes beyond the Thinking
in C CD, the CD is not a replacement for that chapter, but should be
used instead as a preparation for this book.
Please note that the CD ROM is browser-based, so you should have
a Web browser installed on your machine before using it.
16
Thinking in C++
img
CD ROMs, seminars,
and consulting
There are seminars-on-CD-ROM planned to cover Volume 1 and
Volume 2 of this book. These comprise many hours of audio
lectures by me that accompany slides that cover selected material
from each chapter in the book. They can be viewed on most
computers if you have a CD ROM player and a sound system.
These CDs may be purchased at , where you
will find more information and sample lectures.
My company, MindView, Inc., provides public hands-on training
seminars based on the material in this book and also on 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 and code walkthroughs.
Information and sign-up forms for upcoming seminars and other
contact information can be found at .
I am sometimes available for design consulting, project evaluation
and code walkthroughs. When I first began writing about
computers, my primary motivation was to increase my consulting
activities, because I find consulting to be challenging, educational,
and one of my most enjoyable experiences, professionally. Thus I
will try my best to fit you into my schedule, or to provide you with
one of my associates (who are people that I know well and trust,
and often people who co-develop and teach seminars with me).
Errors
No matter how many tricks a writer uses to detect errors, some
always creep in and these often leap off the page to a fresh reader.
If you discover anything you believe to be an error, please use the
correction form you will find at . Your help is
appreciated.
Preface
17
img
About the cover
The first edition of this book had my face on the cover, but I
originally wanted a cover for the second edition that was more of a
work of art like the Thinking in Java cover. For some reason, C++
seems to me to suggest Art Deco with its simple curves and
brushed chrome. I had in mind something like those posters of
ships and airplanes with the long sweeping bodies.
My friend Daniel Will-Harris, (www.Will-Harris.com) whom I first
met in junior high school choir class, went on to become a world-
class designer and writer. He has done virtually all of my designs,
including the cover for the first edition of this book. During the
cover design process, Daniel, unsatisfied with the progress we were
making, kept asking "How does this relate people to computers?"
We were stuck.
On a whim, with no particular outcome in mind, he asked me to
put my face on the scanner. Daniel had one of his graphics
programs (Corel Xara, his favorite) "autotrace" the scan of my face.
As he describes it, "Autotracing is the computer's way to turn a
picture into the kinds of lines and curves it really likes." Then he
played with it until he had something that looked like a
topographic map of my face, an image that might be the way a
computer could see people.
I took this image and photocopied it onto watercolor paper (some
color copiers can handle thick stock), and then started creating lots
of experiments by adding watercolor to the image. We selected the
ones we liked best, then Daniel scanned them back in and arranged
them into the cover, adding the text and other design elements. The
whole process happened over several months, mostly because of
the time it took me to do the watercolors. But I've especially
enjoyed it because I got to participate in the art on the cover, and
because it gave me incentive to do more watercolors (what they say
about practice really is true).
18
Thinking in C++
img
Book design and production
The book's interior design was created by Daniel Will-Harris, who
used to play with rub-on letters in junior high school while he
awaited the invention of computers and desktop publishing.
However, I produced the camera-ready pages myself, so the
typesetting errors are mine. Microsoft® Word for Windows
Versions 8 and 9 were used to write the book and to create camera-
ready pages, including generating the table of contents and index.
(I created a COM automation server in Python, called from Word
VBA macros, to aid me in index marking.) Python (see
www.Python.org) was used to create some of the tools for checking
the code, and would have been use for the code extraction tool had
I discovered it earlier.
I created the diagrams using Visio® ­ thanks to Visio Corporation
for creating a useful tool.
The body typeface is Georgia and the headlines are in Verdana. The
final camera-ready version was produced in Adobe® Acrobat 4 and
taken directly to press from that file ­ thanks very much to Adobe
for creating a tool that allows e-mailing camera-ready documents,
as it enables multiple revisions to be made in a single day rather
than relying on my laser printer and overnight express services.
(We first tried the Acrobat process with Thinking in Java, and I was
able to upload the final version of that book to the printer in the
U.S. from South Africa.)
The HTML version was created by exporting the Word document
to RTF, then using RTF2HTML (see http://www.sunpack.com/RTF/) to
do most of the work of the HTML conversion. (Thanks to Chris
Hector for making such a useful, and especially reliable, tool.) The
resulting files were cleaned up using a custom Python program
that I hacked together, and the WMFs were converted to GIFs using
JASC® PaintShop Pro 6 and its batch conversion tool (thanks to
JASC for solving so many problems for me with their excellent
Preface
19
img
product). The color syntax highlighting was added via a Perl script
kindly contributed by Zafir Anjum.
Acknowledgements
First, thanks to everyone on the Internet who submitted corrections
and suggestions; you've been tremendously helpful in improving
the quality of this book, and I couldn't have done it without you.
Special thanks to John Cook.
The ideas and understanding in this book have come from many
sources: friends like Chuck Allison, 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), Bill
Plauger, Reg Charney, Tom Penello, Tom Plum, Sam Druker, and
Uwe Steinmueller; people who have spoken in my C++ track at the
Software Development Conference; and often students in my
seminars, who ask the questions I need to hear in order to make the
material more clear.
A huge thank-you to my friend Gen Kiyooka, whose company
Digigami has provided me with a web server.
My friend Richard Hale Shaw and I have taught C++ together;
Richard's insights and support have been very helpful (and Kim's,
too). Thanks also to KoAnn Vikoren, Eric Faurot, Jennifer Jessup,
Tara Arrowood, Marco Pardi, Nicole Freeman, Barbara Hanscome,
Regina Ridley, Alex Dunne, and the rest of the cast and crew at
MFI.
A special thanks to all my teachers and all my students (who are
my teachers as well).
And for favorite writers, my deep appreciation and sympathy for
your efforts: John Irving, Neal Stephenson, Robertson Davies (we
20
Thinking in C++
img
shall miss you), Tom Robbins, William Gibson, Richard Bach,
Carlos Castaneda, and Gene Wolfe.
To Guido van Rossum, for inventing Python and giving it selflessly
to the world. You have enriched my life with your contribution.
Thanks to the people at Prentice Hall: Alan Apt, Ana Terry, Scott
Disanno, Toni Holm, and my electronic copy-editor Stephanie
English. In marketing, Bryan Gambrel and Jennie Burger.
Sonda Donovan helped with the production of the CD Rom.
Daniel Will-Harris (of course) created the silkscreen design that's
on the Disc itself.
To all the great folks in Crested Butte, thanks for making it a
magical place, especially Al Smith (creator of the wonderful Camp4
Coffee Garden), my neighbors Dave & Erika, Marsha at Heg's Place
bookstore, Pat & John at the Teocalli Tamale, Sam at the Bakery
Café, and Tiller for his help with audio research. And to all the
terrific people that hang out at Camp4 in and make my mornings
interesting.
The supporting cast of friends includes, but is not limited to, Zack
Urlocker, Andrew Binstock, Neil Rubenking, Kraig Brockschmidt,
Steve Sinofsky, JD Hildebrandt, Brian McElhinney, Brinkley Barr,
Larry O'Brien, Bill Gates at Midnight Engineering Magazine, Larry
Constantine, Lucy Lockwood, Tom Keffer, Dan Putterman, Gene
Wang, Dave Mayer, David Intersimone, Claire Sawyers, the Italians
(Andrea Provaglio, Rossella Gioia, Laura Fallai, Marco & Lella
Cantu, Corrado, Ilsa and Christina Giustozzi), Chris and Laura
Strand (and Parker), the Almquists, Brad Jerbic, Marilyn Cvitanic,
the Mabrys, the Haflingers, the Pollocks, Peter Vinci, the Robbins,
the Moelters, Dave Stoner, Laurie Adams, the Cranstons, Larry
Fogg, Mike and Karen Sequeira, Gary Entsminger and Allison
Brody, Kevin, Sonda, & Ella Donovan, Chester and Shannon
Andersen, Joe Lordi, Dave and Brenda Bartlett, the Rentschlers,
Lynn and Todd, and their families. And of course, Mom and Dad.
Preface
21
Table of Contents:
  1. Introduction to Objects:The progress of abstraction, Extreme programming
  2. Making & Using Objects:Tools for separate compilation, Reading and writing files
  3. The C in C++:Creating functions, Controlling execution, Introduction to operators
  4. Data Abstraction:The basic object, Abstract data typing, Header file etiquette
  5. Hiding the Implementation:C++ access control, Handle classes
  6. Initialization & Cleanup:Guaranteed cleanup with the destructor, Aggregate initialization
  7. Function Overloading & Default Arguments:Overloading example, Default arguments
  8. Constants:Function arguments & return values, Classes, volatile
  9. Inline Functions:Preprocessor pitfalls, Stash & Stack with inlines, Reducing clutter
  10. Name Control:Static elements from C, Static initialization dependency, specifications
  11. References & the Copy-Constructor:The copyconstructor, Pointers to members
  12. Operator Overloading:Overloadable operators, Overloading assignment
  13. Dynamic Object Creation:Early examples redesigned, new & delete for arrays
  14. Inheritance & Composition:The constructor initializer list, Name hiding
  15. Polymorphism & Virtual Functions:The problem, How C++ implements late binding
  16. Introduction to Templates:Template syntax, Stack and Stash as templates
  17. A: Coding Style
  18. B: Programming Guidelines
  19. C: Recommended Reading:Depth & dark corners, Analysis & design
  20. Index