Using the STL: The C++ Standard Template Library

594 Pages·2000·4.32 MB·English

by  Robert Robson (auth.)

Using the STL
Second Edition
Springer Science+Business Media, LLC
Robert Robson
Using the STL
The C++ Standard Template Library
Second Edition
With 36 Illustrations
, Springer
Robert Robson
2645 Battleford Road, #1104
Mississauga, Ontario L5N 3R8
Canada
[email protected]
Library of Congress Cataloging-in-Publication Data
Robson, Robert.
Using the STL: the C++ standard template librarylRobert Robson.
p. cm.
Includes bibliographical references.
ISBN 978-0-387-98857-3 ISBN 978-1-4612-1312-3 (eBook)
DOI 10.1007/978-1-4612-1312-3
1. C++ (Computer program language). 2. Standard template library.
I. Title.
QA76.73.Cl53R625 1999
005.l3'3---dc21 99-26377
Printed on acid-free paper.
© 2000, 1998 Springer Science+Business Media New York
Originally published by Springer-Verlag Berlin Heidelberg New York in 2000
All rights reserved. This work may not be translated or copied in whole or in part without the
written permission of the publisher (Springer Science+Business Media, LLC),
except for brief excerpts in connection with reviews or scholarly analysis. Use
in connection with any form of information storage and retrieval, electronic adaptation, computer
software, or by similar or dissimilar methodology now known or hereafter developed is forbidden.
The use of general descriptive names, trade names, trademarks, etc., in this publication, even if the
former are not especially identified, is not to be taken as a sign that such names, as understood by
the Trade Marks and Merchandise Marks Act, may accordingly be used freely by anyone.
Production managed by Francine McNeill; manufacturing supervised by Erica Bresler.
Photocomposed copy prepared from the author's Ami Pro files.
9 8 7 6 5 4 3 2 1
ISBN 978-0-387-98857-3
Preface to the Second Edition
A lot has happened since the first edition of this book was written. When the
first edition was prepared, there was only one version of the Standard Template
Library (STL) available-the Hewlett-Packard version. Since then, several other
versions have appeared from major compiler and library vendors. This is in an
effort to conform to the recent International Standards Organization/International
Electrotechnical Commission (ISO/IEC) C++ standards, which define the STL
as part of the Standard C++ Library.
As expected, the STL is becoming widely available and an accepted part of
C++ program development. This is good. Unfortunately, the proliferation of
implementations makes it difficult to exactly define the STL. We now have mul
tiple implementations, many of which are slightly incompatible with one another.
The reasons for this are largely due to different capabilities of the compilers on
which they are implemented. Many compilers do not implement the most recent
features of the language since production of standards often precedes conform
ing implementations by many months. This will improve over time as the com
pilers add the necessary capabilities to support the full STL.
In attempting to revise a book on the STL, I was faced with the question of
which definition to use. When there was only a single implementation, the an
swer was obvious. With several implementations differing in slight ways, there
is the possibility of describing the most commercially successful version, de
scribing an idealized version, trying to describe all of the versions, or describing
the standard. Describing the most commercially successful version would do a
disservice to those running other versions. Describing all versions is just not
practical since I do not have access to all of the hardware necessary to run some
of the versions out there. Therefore, I decided to describe the STL as defined by
the most recent ISO/IEC C++ standard of September 1998. Although I have yet
to find an implementation that conforms to this standard, most of the implemen
tations come very close--close enough that the casual user might not even notice
vi Preface to the Second Edition
the differences. Furthermore, the compiler and library vendors are working on
implementations that fully conform to the standard. Thus, by the time you read
this, a conforming implementation might be available. Regardless, this is the
standard that all vendors will be striving to meet and is the safest implementation
to describe.
This book also describes extensions provided by some of the popular imple
mentations. I have not attempted to be rigorous in this, as I merely want to pro
vide you with a glimpse of what is possible and how future development of the
STL might proceed. I want to introduce these extensions to those of you who
might be using those libraries. The space devoted to these discussions is mini
mal, and it is clearly indicated that such capabilities are not part of the C++
standard.
All languages evolve, and C++ is no different. Thus, any book describing a
language can be no more than a snapshot of the language as it is at some point in
time. The C++ standard will change, and the definition of the STL will likely
change with it. Fortunately, most of the concepts and basic structure of the lan
guage and libraries will remain the same. Therefore, I have hopes that the infor
mation in this book will be useful for a period of years.
Thanks are due to the readers who provided comments on the first edition. I
have attempted to address their comments in an effort to correct deficiencies in
the first edition. My thanks also go to Michelle French, who was an enormous
help in editing the manuscript for the second edition.
Robert Robson
Mississauga, Ontario, Canada
1999
Preface to the First Edition
Programming languages evolve in steps. They began with weakly typed lan
guages like FORTRAN and progressed to strongly typed languages like
PASCAL. This had the positive effect of moving the detection of many pro
gramming errors from run time to compile time. This had the negative effect of
limiting the generality of functions since they were now bound to specific data
types. This virtually eliminated the writing of reusable software components.
The result was that programmers had to reimplement common algorithms and
data structures over and over.
Newer languages, such as C++, provide a way to decouple algorithms and
data structures from the data types upon which they operate. C++ provides this
capability via the template mechanism. Suddenly, it became possible to write
generic algorithms and data structures that could be reused. In effect, this pro
vides debugged software components that can be combined to form programs
much faster than by reimplementing the components each time they are needed.
At the same time that programming languages were evolving, computer hard
ware was becoming incredibly inexpensive compared to programmers' salaries.
This provided a strong incentive to reduce costs by increasing programmer pro
ductivity. Software reuse was seen as one way to increase programmer pro
ductivity.
The drive to increase programmer productivity was initially met by the intro
duction of reusable components by compiler vendors and other software compa
nies. While this was a major step forward, it was flawed by introducing multiple
libraries that addressed the problem in different ways. The result was that com
ponent reuse meant that a programmer might need to learn several such libraries.
viii Preface to the First Edition
The Standard Template Library (STL) was introduced after several years of
studying how a library of reusable components should be designed. As a result,
it introduces several new concepts that make the library easier to use and allow
the generic algorithms to be applied to data stored in arrays as well as the con
tainers provided by the STL.
The STL has been accepted as a standard by the American National Stan
dards Institute (ANSI) committee for the standardization of the C++ language.
This means that it must be provided by all C++ compilers, just like common
functions such as strlen ( ). The result is a single, well-defined library of re
usable components that is available to all programmers regardless of the com
piler or platform they use.
This book introduces the algorithms and data structures that comprise the
STL and the philosophy behind their creation. An understanding of the philoso
phy is crucial since it allows you to see the underlying structure and regularity in
the library. An understanding of this regularity reduces the amount of material
that you must remember to use the STL effectively.
This book began as a series of notes on the use of the STL for a program
ming project in which I was involved. As the magnitude of effort and the re
quired detail became apparent, turning it into a book was the natural thing to do.
The resulting book not only describes the components of the STL and the
philosophy behind them, but it shows how you can use them. This is done by
pointing out some of the pitfalls in the usage of the STL and by showing exam
ples of real-world problems being solved with the STL. An explanation of many
of the algorithms implemented by the STL is provided for those readers not fa
miliar with the underlying concepts.
While this book is aimed primarily at professional programmers, it is not re
stricted to this audience. It is suitable for software managers who need a high
level understanding of the STL as well as students who wish to expand their pro
gramming knowledge and skills. A table at the end of the introduction shows
which chapters are most appropriate to each type of reader.
I believe that the STL will become an important component in the Standard
C++ Library and that it will be vital for programmers to have a good working
knowledge of the STL. The result will be decreased tedium in the production of
software, higher quality, and increased productivity.
Preface to the First Edition ix
I would like to thank the people who read initial versions of this book espe
cially Heather Collicutt and Brigitte Bonert. I also wish to thank Ross Judd of
Atomic Energy of Canada, Ltd., who had the foresight and interest to allow me
the time to investigate the STL and write this book. Final thanks go to all of the
people at Springer-Verlag who made this book possible.
I wish you well in your programming endeavors and hope that this book
helps you achieve your goals.
Robert Robson
Mississauga, Ontario, Canada
1997
Contents
Preface to the Second Edition ..... .................. .................... ...... ..... ....... ... v
Preface to the First Edition .................................................................... vii
1 Introduction
1.1 What Is the STL? ................................................................... 1
1.2 History .................................................................................... 3
1.3 STL Components ............ .................. ...... .............. ................. 3
1.4 Generic Algorithms ................................................................ 4
1.4.1 C++ Templates ........................................................... 7
1.5 Iterators ................................................................................... 10
1.6 Standard Exceptions ............................................................... 13
1.7 Complexity .. .............. ......... ...... ......... .................... ......... ........ 14
1. 7.1 Analyzing Complexity .. ........ ...... ............ ................... 22
1.8 Thread Safety ......................................................................... 23
1.9 Namespaces ............................................................................ 25
1.10 Overview of This Book ......................................................... 25
2 Iterators 29
2.1 Introduction 29
2.2 Pointers as Iterators ............................................................... . 29
2.3 Iterator Classes ...................................................................... . 34
2.3.1 Input Iterators ........................................................... .. 39
2.3.2 Output Iterators ........................................................ .. 40
2.3.3 Forward Iterators ....................................................... . 41
2.3.4 Bidirectional Iterators ................................................. 41
2.3.5 Random Access Iterators ........................................... 42
2.4 Using Iterators ........................................................................ 42
2.4.1 Stream Iterators ...... .................... .............. .................. 43
2.4.2 Forward Iterators ...... ...................... ...................... ...... 46