9 of 9 people found the following review helpful
Not timeless, but still a very useful volume,
Verified Purchase(What's this?)
This review is from: Effective STL: 50 Specific Ways to Improve Your Use of the Standard Template Library (Paperback)
"Effective STL" is the final installment of Scott Meyers' "Effective" trilogy. While the first two volumes ("Effective C++" and "More Effective C++") discussed general tips on C++, "Effective STL" focuses exclusively on the STL, which is taken to mean the parts of the C++ standard library that work with iterators. It goes without saying that this book should be read after "Effective C++, Third Edition". One could probably get away with skipping over "More Effective C++", thus going directly from "Effective C++" to "Effective STL".
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.