Customer Reviews

Effective STL: 50 Specific Ways to Improve Your Use of the Standard Template Library

5 star:		(28)
4 star:		(8)
3 star:		(3)
2 star:		(2)
1 star:		(0)

 

 

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!

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.

I'm a professional software engineer. I write code all day long and have lots of experience with C++, but I hadn't used STL much until recently. If you're in a similar situation--decent C++ knowledge but not an STL expert--this book is for you. I haven't even read the whole thing yet, and already I am using patterns from the book to write more effective code.

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.

Following in the tradition of his prior books, Meyers delivers another gem with Effective STL. This one is a must have for your software development bookshelf.

I user several STL books regularly and none of them have come close to giving me the in depth understanding that this book has. Sure, others are better references, beginner guides, etc.. but if you really want to understand what is going on under the covers and how to write -good- STL, this book is your answer. I have seen suggestions from this book result in massive performance improvements in naively written STL code.

Enough said, go pick up a copy .. :)

I was very pleased to see this book come out as I am a huge fan of Meyers' Effective C++ and More Effective C++. Both of those books offer many concrete suggestions on how to improve your C++ coding and do things you didn't think you could do. Effective STL, on the other hand, offers mainly suggestions of what not to do. You'll find most of the items tell you that you should not use a specific technique because it is not portable, not a clean design, or simply because it will not work.

All of this is good to know, but I didn't find it as useful as his other two Effective books. Other than the use of the built in looping functions like for_each the book didn't really provide me with many new "tricks" for my "bag."

However, all the information in the book is useful, and the intermediate level STL programmer will probably learn a lot of ways to avoid problems by reading this book. Hopefully there will be a second edition in the future that will give the book a little more utility.

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.

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!

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.

Four years passed when I first read this book, I still consider it a classic on the STL topic.

The best parts of this book are its analyses and reasoning although a bit verbose and rambling. You could come up all the results by yourself through several years battling industrial experience. But, if all these "effective weapons" have already been manufactured and well justified by others, why not just take it. It will save you from a lot of scars.

According to my own experience, if you really want to master STL, the following way is a solid path (luckily I'v gone through it by accident):
1. C++ template programming, or as C++ community named it "generic programming". The whole STL is built on it.
2. foundamental data structures, especially balanced tree, because all associative containers are implemented as some kinds of balanced tree (this step should be very easy to achieve by anyone).
3. practical algorithms (not only those on your college textbook) widely used in industrial background, the more the better. (If you are an aggresive reader, "Introduction to algorithms, 2nd Ed." by Thomas Cormen could satisfy your stomach. If you don't feel exhaustive, try Donald Knuth's "The Art of Computer Programming". If you are still unsatisfied, tell me your name, because honestly I want to learn something from you).
4. solid OO understanding, STL prefers it. For example, when you choose between traditional functions or functors, STL prefers functors. The same between smart pointers and raw pointers, actually iterators are sort of smart pointers (Anyway, don't get confused, the coverage of OO is much more than what are used in STL context).

After you finish all these steps, STL will become so natural to you, you won't have any surprise.

Actually I have a "Least Surprise Principle". You can use this book as a tool to gauge your proficiency on STL. When you finish your reading, if you get a lot of surprises, you really need this book. If you feel some surprises but not a lot, you are in good shape. If you feel everything in this book is so natural without any surprise, you are master already. Anyway, if you reached this level, don't forget send me a short e-mail, I will take my hat off to you.

I continue to be amazed at how well Scott Meyers' formula works: Pick a topic, set out to write exacttly 50 tips about it, and do it! The secret why this author is so successful with his formula (and never comes across as formulaic) is that he is both deeply knowledgeable about what works in the areas he writes about and has excellent intuition or experience about the areas in which other programmers working in the field are most likely to stumble.

This book is not a user's guide to the STL (And I won't hesitate to, once again, recommend Nicolai Josuttis' _The C++ Standard Library_ for that), but you will find this an excellent use of your time and money as a second book on the STL.