- Paperback: 288 pages
- Publisher: Addison-Wesley Professional; 1 edition (June 16, 2001)
- Language: English
- ISBN-10: 0201749629
- ISBN-13: 978-0201749625
- Product Dimensions: 7.3 x 0.8 x 9.1 inches
- Shipping Weight: 1.3 pounds (View shipping rates and policies)
- Average Customer Review: 56 customer reviews
- Amazon Best Sellers Rank: #80,337 in Books (See Top 100 in Books)
Enter your mobile number or email address below and we'll send you a link to download the free Kindle App. Then you can start reading Kindle books on your smartphone, tablet, or computer - no Kindle device required.
To get the free app, enter your mobile phone number.
Effective STL: 50 Specific Ways to Improve Your Use of the Standard Template Library 1st Edition
Use the Amazon App to scan ISBNs and compare prices.
Fulfillment by Amazon (FBA) is a service we offer sellers that lets them store their products in Amazon's fulfillment centers, and we directly pack, ship, and provide customer service for these products. Something we hope you'll especially enjoy: FBA items qualify for FREE Shipping and Amazon Prime.
If you're a seller, Fulfillment by Amazon can help you increase your sales. We invite you to learn more about Fulfillment by Amazon .
The Amazon Book Review
Author interviews, book reviews, editors picks, and more. Read it now
Frequently bought together
Customers who bought this item also bought
Customers who viewed this item also viewed
Written for the intermediate or advanced C++ programmer, renowned C++ expert Scott Meyers provides essential techniques for getting more out of the Standard Template Library in Effective STL, a tutorial for doing more with this powerful library.
STL is a hugely powerful feature of today's C++, but one with a well-earned reputation for complexity. The book is organized into 50 tips that explore different areas of the STL. Besides providing a list of dos and don'ts, Meyers presents a lot of background on what works and what doesn't with STL. Each tip is demonstrated with in-depth coding samples, many of which make use of two-color printing to highlight the most important lines of code. (Advanced developers will enjoy Meyers's in-depth explanations, while those who are in a hurry can skip ahead to the recommended tip itself.)
A good part of this book involves using containers, like vectors and maps, which are built into STL. (Besides the standard built-in containers, the author also highlights recent additions to STL like B-trees, which are available as extensions from other vendors.) You'll learn the best ways to allocate, add, change, and delete items inside containers, including associative containers like maps. You'll also learn to avoid common pitfalls, which can result in writing code that is slow or just plain wrong.
Other areas covered in Effective STL cover getting the most out of the 100-plus STL algorithms that are bundled with this library. Meyers shows you how to choose the correct algorithm for sorting and other functions. (Even advanced developers will learn something here.) Sections on using function objects (called functors) round out the text. Meyers shows you when these classes make sense and the best ways to implement them. Besides specific tips, you'll get plenty of general programming advice. A useful appendix shows the limitations of STL as implemented in Microsoft Visual C++ 6.0 and how to overcome them.
Overall, Effective STL is a really invaluable source of programming expertise on an essential aspect of today's C++ for anyone who is using--or planning to use--STL in real production code. It is quite simply a must-have. --Richard Dragan
- Introduction to advanced Standard Template Library (STL) programming techniques
- 50 tips and best practices for STL illustrated with sample tutorial code
- Choosing containers
- Efficient copying of elements inside containers
- Removing, erasing, and cleaning up items from containers
- Using custom allocators with STL containers
- Thread safety with STL
- Tips for programming with the STL vector and string classes (including reserving memory and calling legacy C/C++ code)
- Tips for associative containers (including comparing items, sorted vectors, and non-standard enhancements to STL)
- Tips for selecting and using STL iterator classes
- STL algorithms (including sorting, removing, and comparing items)
- Using functors with STL
- General tips for STL programming (including advice for choosing algorithms and understanding compiler diagnostic messages)
- String locales
- Overcoming STL imitations in Microsoft Visual C++ 6.0
From the Back Cover
"This is "Effective C++" volume three - it's really that good."
- Herb Sutter, independent consultant and secretary of the ISO/ANSI C++ standards committee "There are very few books which all C++ programmers "must" have. Add "Effective STL" to that list."
- Thomas Becker, Senior Software Engineer, Zephyr Associates, Inc., and columnist, "C/C++ Users Journal" C++'s Standard Template Library is revolutionary, but learning to use it well has always been a challenge. Until now. In this book, best-selling author Scott Meyers ("Effective C++," and "More Effective C++") reveals the critical rules of thumb employed by the experts - the things they almost always do or almost always avoid doing - to get the most out of the library. Other books describe "what's in" the STL. "Effective STL" shows you "how to use it." Each of the book's 50 guidelines is backed by Meyers' legendary analysis and incisive examples, so you'll learn not only what to do, but also "when" to do it - and "why." Highlights of "Effective STL" include:
- Advice on choosing among standard STL containers (like vector and list), nonstandard STL containers (like hash_set and hash_map), and non-STL containers (like bitset).
- Techniques to maximize the efficiency of the STL and the programs that use it.
- Insights into the behavior of iterators, function objects, and allocators, including things you should "not" do.
- Guidance for the proper use of algorithms and member functions whose names are the same (e.g., find), but whose actions differ in subtle (but important) ways.
- Discussions of potential portability problems, including straightforward ways to avoid them.
Top customer reviews
There was a problem filtering reviews right now. Please try again later.
The Good: in typical Meyers style, the writing is generally relaxed and even pleasant, e.g. "This works, but only if you're not terribly picky about what you mean by 'works'." (Item 7). Like in "Effective C++" (but in contradistinction to "More Effective C++") most Items are quite short and therefore easily digestible. Similarly, in this volume, too, Meyers often reiterates the main point of each Item before concluding: this sometimes feels needlessly repetitive, but is mostly great for driving home the essential issues. As in the earlier volumes, things are for the most part organized intuitively. Meyers has a knack for pedagogy and thus for different ways of getting the message across, cf. the few tables that are included in the book, most notably the one on search options in Item 45. The author's organizational prowess is also evidenced by the numerous cross-references and the list of performance-related Items at the end of the Introduction. Moving on to the specifics of the material covered in this volume: Meyers is at his best when addressing a host of topics that elsewhere are often jumbled together. The finest examples of this skill are Items 31, 41, and 45, which deal with sorting options, function adapters, and search algorithms, respectively. Meyers manages to methodically explain the commonalities and distinctions between related concepts. The overwhelming majority of the topics covered in this volume have to do with real-life programming in C++, e.g. how to pass vector and string data to legacy APIs (Item 16). In this vein, some of the Items in "Effective STL" can safely be said to constitute required reading, especially the following on: a) range member functions versus their single-element counterparts (Item 5), b) C++'s most vexing parse (Item 6), c) the swap trick used to eliminate excess capacity (Item 17), d) the erase-remove idiom that allows one to really remove elements from a container (Item 32), e) the superiority of algorithm calls in comparison with hand-written loops (Item 43), and f) the advantages of container member functions over STL algorithms with the same name (Item 44). Other Items feel like digressions (e.g. Item 10 on allocators, Item 18 on vector of bools, or Item 23 on replacing associative containers with sorted vectors) though that doesn't make them any less interesting.
The Bad: this volume is not introductory but it isn't a very good reference either. For example, in the early Items Meyers talks about list's splice member functions matter-of-factly. Of course, "Effective C++" and "More Effective C++" are also not introductory or reference works, but there's a major difference: in those books when Meyers discusses a new construct he first explains it briefly. In "Effective STL", on the other hand, he often implicitly assumes the reader will go look stuff up in something like Josuttis' book "The C++ Standard Library" (regarding which Meyers writes: "[e]very C++ programmer should have ready access to a copy"). Obviously, a short hints-and-tips type book cannot contain everything, but the reader's life would have been made much easier had Meyers simply included a few reference tables (containing function signatures) in an Appendix. Moreover, what the Appendices do include is not uniformly interesting: Appendix B addresses developers using Microsoft Visual C++ versions 4-6 and is therefore largely irrelevant today. Another point where "Effective STL" diverges slightly from the earlier volumes' practices is cross-referencing. Meyers mentions other Items extensively in those books, too, but here he's gone overboard: for example, by the time he introduces unary_function and binary_function in Item 40, he has referred to them 10 times already, which probably means that they should have been covered (way) earlier. On a different note, given the non-exhaustive nature of the book, there's important stuff that's missing, e.g. there's absolutely no mention of the at() member function of vectors, deques, and strings. Also, a few of the examples feel somewhat contrived (e.g. anyone paying attention up to that point can tell that the initially proposed solution in Item 42 is obviously unnecessary), though this is more the exception than the rule. Finally, the book's age is starting to show: "Effective STL" was published in 2001 so (despite being more up to date than "More Effective C++") a number of things would be done differently today. For example, Meyers uses for_each in many code snippets, most of which would look much cleaner using lambdas.
In a nutshell, I would say that this book is not as indispensable as "Effective C++, Third Edition", but is probably more useful than "More Effective C++". Meyers is a talented author and instructor, so all three volumes are worth reading. Were "Effective STL" to be re-written today (using C++11 and its library) the result would certainly be more interesting, but the advice contained in this book is solid, nonetheless. Overall, four and a half stars.
Readers even get some of the back story on the decisions that went into the development of STL and why they made some of the compromises that they did. The book is so clear, so lucid, and so interesting that even the novice C++ programmer will enjoy its prose. It is thoroughly informative even for programmers at all levels of experience with C++.
While I wouldn't recommend this book for a beginner, anyone that wants to further his or her understanding of the STL should read this book cover to cover.
Before I started this book, I thought STL was kind of neat. It had some useful containers. It was nice to be able to use a list or map or string class that had already been tested.
Boy, was I underestimating the power of STL. This book has made me a big STL fan, but I'm not reviewing the STL now so I'll leave that topic alone... Thanks to Scott Meyers, I have a much better grasp of the capabilities and limitations of STL. I can use it to do a lot more. I write more concise code that's easier to read and debug. I make better choices about which containers to use. I recognize situations where I can use an STL algorithm instead of many lines of my own code.
In short, I look at the STL code I wrote before and laugh... I mean, it all works, but the Meyers book has taken my use of (and appreciation for) the STL to a whole new level. I recommend this book for any C++ developer who isn't already an STL expert.
An update, 2 years after the above text was written: I still recommend this book to people and still think it's the best STL book I've read.