on July 3, 2002
This book follows in the manner of Scott Meyers' other excellent C++ books (Effective C++ and More Effective C++). It is divided into 50 "items" covering specific topics in using the Standard C++ Standard Library neatly grouped into 7 chapters on effective use of the containers, iterators and algorithms that make up the Library. This is a very good supplement to more basic and comprehensive books like The C++ Standard Library, by Nicolai Josuttis. Meyers' book assumes you have a basic familiarity with the inventory and interfaces of the STL and shows you how to use the STL more efficiently, safely and clearly. The book can be a little frustrating for those who just want a "do it this way" approach. Each item in the book takes you through the reasoning behind why it's better to use the STL in one way and not another. But, in the long run, this is a much more effective approach. The "why" is as important has the "how". The book also contains plenty of crossreferences between items, so it makes a good reference when you are done reading it through.
on July 3, 2002
I'm not a professional programmer, but I play one on... Okay, I admit I'm a pretender. I code when I need to, not as an end in and of itself. When I put digits to keyboard, C++ is my language of choice, but often things aren't as clear as they should be...like STL. You gotta love it. Somebody finally comes up with a standardized container library for C++, and it proves to be difficult to do anything but the most basic "stuff it" and "get it" operations...and getting it is sometimes not guaranteed.
Along comes Scott Meyers and Effective STL with 50 specific recommendations on using the STL. Bless you, man...I mean it. This book clears up many misconceptions about the STL and will tidy up your code. It will make you wiser, help you to do things with STL that you didn't even know were possible, and may even make STL...fun (shhhh!). Its like a slap to the face. It will pull you out of your catatonic state and make you...effective.
So put down the keyboard, stop fondling your mouse, and go read a book. If you know what "STL" stands for, you need this one.
on July 31, 2001
This is the third in a series of books by Meyers on using C++ effectively. The book follows the same format as the earlier two: Chapters progress from more fundamental issues to more complex ones; each chapter consists of a sequence of related items; each item is presented (loosely speaking) as a "problem description" and the solution for it.
The material covers a wide scope, ranging from stuff that will help first-time STL users (e.g., why to use empty instead of size), to material that helps even long-time STL users.
New STL users should find the sections on selecting the most appropriate containers and algorithms very useful. I know I wish I had read something like this when I started using STL. Even though the material is presented very concisely, it is clearly and thoroughly explained. This is not a cook-book: you will not only learn the right way, but also understand *why* it is the right way.
As an STL user with about 4 years experience, I found the sections on equality vs. equivalence and function objects particularly enlightening. Although perhaps none of this material was completely "new" to me, seeing it all presented logically really crystalized my understanding of these topics.
Meyers discussion of allocators and how to write them is one of the best around. His presentation of why predicates should be stateless is crystal clear (and he makes this the "big deal" it deserves to be).
As far as negatives go, I don't have any major criticism of this book. On a minor note, I wish he had been a bit more thorough in his discussion of techniques for dealing with compile-time bugs in STL code. The book discusses how to read compiler diagnostics, but doesn't discuss some other very useful techniques, such as replacing any user-types in containers with ints. In my experience, this can go a long way to separating problems with STL usage, problems with functor usage, and problems in the underlying class stored in the container. The compiler messages for containers of ints are much clearer. And if you can get your code to work (STL-wise) with containers of ints, it should work then with containers to class X, if X is properly written and the functors are properly written.
Bottomline: this book is a must read for anyone learning to use the STL, and a great review and reference for experienced STLers.
on July 26, 2001
If you aren't yet convinced that the STL can help you write better C++, I would seriously consider buying and reading this book cover-to-cover. I had heard that STL implementations were far from standard and many people even told me to avoid it entirely. From the very first page of this book, Scott's enthusiasm for the STL was apparent. By the time I finished the book, my own views on STL had changed entirely.
There are plenty of tips and tricks in this book, but more importantly it will show you how to think about using the STL. It's not just the "use std::vector instead of dynamically allocated arrays" that's important, but "the notion of a vector is one that you need not reinvent each time you sit down to code!!". In some sense I have started to see the STL as the lowest common denominator in a great deal of my code, since a lot of it reduces down to a combination of containers, iterators and basic algorithms.
For those of you using Microsoft's Visual C++ 6 or earlier, there is also a great Appendix about the shortcomings in your STL library and several ways to remedy them.
on July 18, 2001
Effective STL is a great book. It's a worthy successor to Scott Meyers' other two must-have books, Effective C++ and More Effective C++. In fact, this book should have been called Even More Effective C++.
The format's no different from the previous two books. There are 50 very specific tips on STL usage, ranging from the trivial (call empty() instead of size() to check for an empty container) to the obscure (Understand how to use a reverse_iterator's base iterator).
The best tip in the book is the discussion on judicious use of STL algorithms. STL consists of over a hundred algorithms covering just about every possible need you'll have. In most cases, you can greatly improve your code by preferring STL's built-in algorithms to your own, but there are some situations where using the built-in stuff can just render your code unmaintainable.
My only complaint is that I feel a bit ripped off by the last two items. Item 49 discusses STL error messages, but not in enough depth to be useful. Item 50 is a set of reviews of STL-related websites. It appears that the author ran out of gas just before item 50 and decided to "promote" a couple of the appendices to items.
I guess I'll have to dock the book 1/25 of a star, but that still rounds up to five stars. This is a book that you'll want to have if you plan to use STL. End of story.
on July 5, 2001
There we go - with his well-known sharpness and diligence, Scott absorbed STL in all detail, taught it in seminars, chewed on the ensuing experience, and distilled it all in this book.
I was one of the reviewers and in the beginning I thought that reviewing a book on STL is going to be an easy enough task. I was wrong.
I learned lots of new things on using STL effectively: why `empty()` is better than `size() == 0`, when and how to write custom allocators, how std::string might be implemented, how associative containers distinguish between equality and equivalence, how to implement associative containers as sorted vectors (that's a gem!), and many, many other things that I either had a blurry understanding of, or simply didn't know about. Now I'm glad I do, because my understanding of the STL and the practical use of it are much better.
The book went through an extensive review process; it is really combed and distilled to its finest. I recommend it to any C++ programmer who uses STL - which should be, any C++ programmer, period. Five well deserved stars.
on June 22, 2001
If you're a C++ programmer who has never used STL, or if you've ever programmed using STL and you've only read documentation on what STL containers and algorithms do (as opposed to how to use them), you must get this book and read it. Your natural inclination as a C++ programmer will prevent you from getting the most from STL. Every one of the 50 items in this book are helpful, and they are often written in a humorous manner, which makes it a very enjoyable (and informative) read.
Lots of STL books tell you what STL containers and algorithms do. Scott teaches you (at least) two things that are hard to get in other books: 1) How the STL containers work and 2) How to best use them for your purposes. If you've ever stared at a 2,000 character error message from STL and just shook your head, if you hand-write loops for simple container operations, if you ever wondered whether you need to write a custom allocator, you need this book. Just by reading and understanding about 1/2 of the items in this book, my knowledge of STL has increased tenfold, and the enjoyable style of the writing made it fun!
on June 17, 2001
This is a truly useful book. It explains lots of little "gotchas" that I didn't know about previously, and Scott does his usual excellent job at explaining *why* it's important to do things a certain way (and no other). One part that I found particularly interesting is about the futility of writing container-independent code; not only does that section show why this is a bad idea, it also serves as a splendid illustration of the idiosyncracies of the various containers. The chapter on iterators is priceless, as are the tips about writing comprehensible code and debugging.
The presentation is very much up-to-date (even to the point where it anticipates some of the forthcoming updates to the C++ standard). The writing style is clear and precise without sounding academic or condescending, and the book has an index that actually works.
"Effective STL" is every bit as good as "Effective C++" and "More Effective C++". No C++ programmer should still be writing code without the STL, and no-one writing code with the STL should be without this book. Buy it!
on October 19, 2002
Effective STL is an advanced book of wisdom to some of the more important features in the C++ STL. There are many books about the STL, but this book definitely stands out in terms of its contents. Scott Meyers does not write an STL reference. Meyers writes an STL wisdom. He presents exceptional advices on important STL features including containers, iterators, algorithms, and function objects, and STL usage in terms of correctness, simplicity, efficiency, and pure speed.
Meyers answers this question: So you know fundamental features of the C++ STL, But do you know why and when to implement those C++ STL tools as solutions?
I highly recommend Effective STL.
on June 24, 2002
This is an indispensible book if you are already a very competent C++ programmer but think you might be missing out on some of STL. Do *not* purchase this book to learn STL - that's not what it's for. Buy this book if you've been using STL for a while and are pretty familiar with it. it contains many very specific examples of what to do, and what not to do with STL. You'll be disgusted byu how many of his "rules" you were breaking! Unfortunately, you won't understand it before you use STL for a while.
To learn STL, I highly recommend "C++: HOW TO PROGRAM" by Deitel and Deitel. It might be ugly, but it is the best C++ book out there.