In the absence of a standard set of such data structure and algorithm components, programmers have been forced either to program everything from scratch or to adopt one of several commercial packages. While writing everything from scratch often gives programmers a sense of control, it is also a source of frustration, since there is rarely time to implement the best techniques, even assuming they are already known to the programmer. And the available commercial libraries have suffered from several drawbacks. In the C++ realm, for example, the problems include
Incompatibility: The interfaces of classes supplied by various vendors are invariably different, making it difficult to write portable code.
Inefficiency: The implementations of most commercially available components libraries typically involve complex class hierarchies with extensive use of inheritance and virtual functions. As a result, using these components results in significantly less-efficient programs than could be written in C.
Unwieldy interfaces: In most component libraries, all operations to be performed on a data structure are part of the interface of the class defining it. Besides making it difficult for programmers to add new operations without recompiling the code, this makes the interfaces needlessly large.
These problems have been widely recognized for many years, but few solutions have been proposed and none has been widely embraced - not, that is, until now. The Standard Template Library is both a remarkable advance in programming methodology and a fully accepted part of the C++ Standard Library. It does not seem overly optimistic to expect that STL components will become some of the most widely used software in existence. The reasons are fivefold:
C++ is becoming one of the most widely used programming languages (which is in large part due to the support it provides for building and using component libraries).
Since STL has been incorporated into the ANSI/ISO standard for C++ and its libraries, compiler vendors are making it part of their standard distributions.
All components in STL are generic, meaning that they are adaptable (by language-supported, compile-time techniques) to many different uses.
The generality of STL components has been achieved without sacrificing efficiency.
The design of STL components as fine-grained, interchangeable building blocks makes them a suitable basis for further development of components for specialized areas such as databases, user interfaces, and so forth.
Virtually all C++ programmers know that the origin of this language is due to one person, Bjarne Stroustrup, who began thinking of how to extend the C language to support definition of classes and objects as early as 1979. So too it is the case that the architecture of STL is largely the creation of one person, Alexander Stepanov.
It is interesting that it was also in 1979, at about the same time as Stroustrup's initial research, that Alex began working out his initial ideas of generic programming and exploring their potential for revolutionizing software development. Although one of this book's authors (D.R.M.) had developed and advocated some aspects of generic programming as early as 1971, it was limited to a rather specialized area of software development (computer algebra). It was Alex who recognized the full potential for generic programming and persuaded his then-colleagues at General Electric Research and Development (including, primarily, D.R.M. and Deepak Kapur) that generic programming should be pursued as a comprehensive basis for software development. But at that time there was no real support in any programming language for generic programming. The first major language to provide such support was Ada, and by 1987 Alex and D.R.M. had developed and published an Ada library for list processing that embodied the results of much of their research on generic programming. However, Ada had not achieved much acceptance outside of the defense industry, and C++ seemed like a better bet for both becoming widely used and providing good support for generic programming, even though the language was relatively immature (it did not even have templates, which were added only later). Another reason for turning to C++, which Alex recognized early on, was that the C/C++ model of computation, which allows very flexible access to storage (via pointers) is crucial to achieving generality without losing efficiency.
Still, much research and experimentation were needed, not just to develop individual components, but more importantly to develop an overall architecture for a component library based on generic programming. First at AT&T Bell Laboratories and later at Hewlett-Packard Research Labs, Alex experimented with many architectural and algorithm formulations, first in C and later in C++. D.R.M. collaborated in this research, and in 1992 Meng Lee joined Alex's project at HP and became a major contributor.
This work likely would have continued for some time just as a research project, or at best would have resulted in an HP-proprietary library, if Andrew Koenig of Bell Labs had not become aware of the work and asked Alex to present the main ideas at a November 1993 meeting of the ANSI/ISO committee for C++ standardization. The committee's response was overwhelmingly favorable and led to a request from Koenig for a formal proposal in time for the March 1994 meeting. Despite the tremendous time-pressure, Alex and Meng were able to produce a draft proposal that received preliminary approval at that meeting.
The committee had several requests for changes and extensions (some of them major), and a small group of committee members met with Alex and Meng to help work out the details. The requirements for the most significant extension (associative containers) had to be shown to be consistent by fully implementing them, a task Alex delegated to D.R.M. It would have been quite easy for the whole enterprise to spin out of control at this point, but again Alex and Meng met the challenge and produced a proposal that received final approval at the July 1994 ANSI/ISO committee meeting. (Additional details of this history can be found in an interview Alex gave in the March 1995 issue of Dr. Dobbs Journal.)
Subsequently, the Stepanov and Lee document (Ref. 10) has been incorporated almost intact into the ANSI/ISO C++ draft standard (Ref. 1, parts of clauses 17 through 27). It also has influenced other parts of the C++ Standard Library, such as the string facilities, and some of the previously adopted standards in those areas have been revised accordingly.
In spite of STL's success with the committee, there remained the question of how STL would make its way into actual availability and use. With the STL requirements part of the publicly available draft standard, compiler vendors and independent software library vendors could of course develop their own implementations and market them as separate products or as selling points for their other wares. One of this book's authors (A.S.) was among the first to recognize the commercial potential and began exploring it as a line of business for his company, Modena Software Incorporated, even before STL had been fully accepted by the committee.
The prospects for early widespread dissemination of STL were considerably improved with Hewlett-Packard's decision to make its implementation freely available on the Internet in August 1994. This implementation, developed by Stepanov, Lee, and D.R.M. during the standardization process, is the basis of Modena's STL++ product and several other vendors' offerings; it is referred to in this book as the "HP reference implementation."
The Stepanov and Lee document, while precise and complete, was aimed more at the committee than at the wide audience of C++ programmers. Along with modifying the HP reference implementation to work well with several compilers and providing several additional classes, Modena developed the STL++ Manual, the first comprehensive user-level documentation of STL. (D.R.M. served as an advisor to Modena and was the principal author of the Tutorial section of the STL++ Manual.) We recognized, though, that an even more comprehensive treatment of STL was needed, one that would have better and more complete coverage of all aspects of the library. With much encouragement and assistance from our editor, Mike Hendrickson, we have attempted to meet this goal with the present book.
With the publication of this book, Modena and Addison-Wesley are also making available on the Internet all of the source code for examples used in this book, so that readers who want to try them do not have to type them. Instructions for finding and retrieving all of this material can be found in Appendix B.
We do not want to give the impression that we believe STL is the solution to all programming problems. There are potentially still some bumps in the road to its acceptance by the broad programming community, such as compiler weaknesses and the usual opportunities for misunderstanding of a radically new approach. We hope this book will make the road for STL itself as smooth as possible, but of course there are still many fundamental data structures and algorithms that are not covered. Beyond this realm, there are many more specialized areas of computation that also cry out for component standardization. References 3 and 7 discuss the larger view in some detail. We hope that among our readers will be some who have the vision and resources to continue in the direction that STL has opened up, carrying on its ideas to other component libraries, not only in C++ but also in other programming languages.
Although in the larger scheme of things it is just a small step toward realizing McIlroy's original vision (Ref. 6), STL is a remarkable achievement and has the potential for revolutionizing the way a large number of people program. We hope this book helps you become a full participant in that revolution.
We gratefully acknowledge the encouragement and assistance of many people. First and foremost, Alex Stepanov and Meng Lee offered continuous encouragement and were always available to help straighten out any misconceptions we had about the design of the library. Invaluable assistance with code development and testing was provided by several Modena staff members, including Atul Gupta, Kolachala Kalyan, and Narasimhan Rampalli. Several reviewers of earlier drafts gave us much valuable feedback and helped us find ways to present the most crucial ideas more clearly. They include Mike Ballantyne, Tom Cargill, Edgar Chrisostomo, Brian Kernighan, Scott Meyers, Larry Podmolik, Kathy Stark, Steve Vinoski, and John Vlissides. Others who also made valuable suggestions include Dan Benanav, Bob Cook, Bob Ingalls, Nathan Schimke, Kedar Tupil, and Rick Wilhelm. Finally, we thank the team at Addison-Wesley for their expert editorial and production assistance: Kim Dawley, Katie Duffy, Rosa Gonzalez, Mike Hendrickson, Simone Payment, Avanda Peters, John Wait, and Pamela Yee.
Los Gatos, CA
"The second edition is clearer and adds more examples on how to use STL in a practical environment. Moreover, it is more concerned with performance and tools for its measurement. Both changes are very welcome."
--Lawrence Rauchwerger, Texas A&M University
"So many algorithms, so little time! The generic algorithms chapter with so many more examples than in the previous edition is delightful! The examples work cumulatively to give a sense of comfortable competence with the algorithms, containers, and iterators used."
--Max A. Lebow, Software Engineer, Unisys Corporation
The STL Tutorial and Reference Guide is highly acclaimed as the most accessible, comprehensive, and practical introduction to the Standard Template Library (STL). Encompassing a set of C++ generic data structures and algorithms, STL provides reusable, interchangeable components adaptable to many different uses without sacrificing efficiency. Written by authors who have been instrumental in the creation and practical application of STL, STL Tutorial and Reference Guide, Second Edition includes a tutorial, a thorough description of each element of the library, numerous sample applications, and a comprehensive reference.
You will find in-depth explanations of iterators, generic algorithms, containers, function objects, and much more. Several larger, non-trivial applications demonstrate how to put STL's power and flexibility to work. This book will also show you how to integrate STL with object-oriented programming techniques. In addition, the comprehensive and detailed STL reference guide will be a constant and convenient companion as you learn to work with the library.
This second edition is fully updated to reflect all of the changes made to STL for the final ANSI/ISO C++ language standard. It has been expanded with new chapters and appendices. Many new code examples throughout the book illustrate individual concepts and techniques, while larger sample programs demonstrate the use of the STL in real-world C++ software development. An accompanying Web site, including source code and examples referenced in the text, can be found at http://www.cs.rpi.edu/~musser/stl-book/index.html.--This text refers to the Paperback edition.