-- but you will though, it's a very well done text.)I think I can recommend this book to anyone interested in STL from a beginner to moderately proficient programmer.
Rating: 
Summary: Lousy book, but may be best around
Review: I bought this book looking for a reference for the STL, more than the snippets you get in "How to Program C++" books, but less than in the ANSI C++ standard.
If I could return it, I would.
It's not a tutorial - which is fine, I didn't want a tutorial. There a few tutorial examples, but they are poorly written, often bad style, and unmotivating. Better to ignore the examples, and just use this book as a reference.
It has some nice reference features - nice tables summarizing methods, etc.
However, it is totally dry, has no rationale or background information explaining the inconsistencies in the STL, and provides little useful in observing the meta-patterns that make it easier to use a library like the STL. It is a bit easier to read than the C++ standard, but not much.
The style is stilted - frankly, just like it was translated from German.
I often find myself going back to Stroustrup's one or two page summary of the STL in C++PL3, rather than to Breymann's book.
All this bad stuff being said, unfortunately, I have seen no other book suitable as a quick reference for the STL. I use the ANSI C++ standard online as my reference now.
Rating: 
Summary: Grudging Respect for content, but impossible to use
Review: I think that all of the above reviews summarizes. This book was an decent wealth of knowledge on STL.... too bad it was difficult (at best) to use.
If you already know the material in the book like the back of your hand, it's really not worth your money, there are better refrence books out there, and chances are you won't learn too much new.
If you're looking to learn a bit, then you have a choice. Either spend a bit (maybe a lot!) of extra time trying to "translate" the book out of it's unfortunate "halting" gibberish and you may gain a lot (and you may tear your hair out).
Otherwise you should just spend a bit of time looking for a better book - I agree heartily with the reviewer above: If I could, I'd return it.
(J)
Rating:
Summary: Grudging Respect for content, but impossible to use
Review: If you ever wondered why STL is the embodiment of research on generic programming (and what generic programming is anyway for C++ programmers), then this book is for you. It is not yet another STL reference by no means. It is not an introduction text either. This book will unveil the full power of STL and generic programming approach. Your relationship with STL is going to be different after reading this manuscript. Buy it, read it, and you will see why.
Rating: 
Summary: Excellent book on STL
Review: If you ever wondered why STL is the embodiment of research on generic programming (and what generic programming is anyway for C++ programmers), then this book is for you. It is not yet another STL reference by no means. It is not an introduction text either. This book will unveil the full power of STL and generic programming approach. Your relationship with STL is going to be different after reading this manuscript. Buy it, read it, and you will see why.
Rating: 
Summary: Better than most STL books
Review: Most "STL" books available today are little more than reference manuals. Furthermore, most of them are downright terrible. This one's not bad.
Breymann offers clear examples of how to use existing elements of the STL, and (more importantly) how to write code that employs the same idioms so you can take advantage of the standard C++ library in your own work. Neither the code nor the writing are top-notch, but they are by no means terrible. You'll want Stroustroup's book handy (and maybe Austern's, too), but this book is a worthwhile read.
Rating:
Summary: A mistitled book
Review: The book proceeds to describe STL like all the other STL books, but doesn't stick to its title, i.e. it doesn't provide any information on extending STL.
The book is somewhat detailed in its description of STL. It covers contains and algorithms. However, although many of the more esoteric algorithms are listed, the description of them is poor and there is no explanation why they are there at all. I found this frustrating. The truth be known, with some of these you're better off reading the source.
Most annoying, is there is no help in extending STL. I bought the book specifically for this purpose. It's name implied more than a straight description of the "stuff" in STL. There isn't a clear description of the names your new cool container must support for example, or even sample code. I may as well not have had the book in this regard.
I did email the author regarding the first point and he was kind enough to reply.
I think if the book's title implied a straight description of STL then it would be more representative of the content. I think that would be better, because the present name is misleading.
Rating:
Summary: A superbly authored treatment of the STL
Review: This book begins with an excellent treatise on how the standard template library is structured, using traditional C++ concepts. The author sets the stage for and provides an excellent explanation of the fundamental concept underlying the STL
Containers <==> Iterators <==> Algorithms
Numerous elments of "bonus" information abound in this book, such as the difference between prefix and postfix incrementing. The author is to be complimented for providing examples with useful comments on almost every line of code.
Useful information on new header names and namespaces is appreciated. Unlike other treatments on this topic, examples are diverse and useful. It is annoying to read a book where almost every example is taken from some bizzare string manipulation. The author is to be complimented for solid examples from graph theory and sparse matrix computations.
The book is a perfect length -- not a bible and not a lot of fluff -- just solid, useful, well-thought out and well presented information.
Perhaps the only item missing (or at least missed in this reviewer's first reading) is performace-related information. For example, what are the performance implications of creating a vector via successive push_back calls vs. pre-sizing or reserving space and then using the overloaded index operator to access elements? For large arrays, or vectors of vectors, understaning how a contiguous area of memory is preserved has important performance ramifications.
Other small tidbits of information might have been helpful, such as explaining the difference between
using namespace std;
map< string, int, less<string>> someMap;
and
map< string, int, less<string> > someMap;
(with maximal munching, >> is interpreted as a token in C++ ... you can tell I was burned by this) Although you don't need the 'less' in this case, it's arguably a good habit to get into. One day, you will get burned when you do need it!
Of course, performance-related info! rmation in a design-oriented book may not be appropriate -- perhaps a topic for another edition, which this reviewer would purchase in an instant.
In all, an excellent book which belongs in any serious C++ developer's library.
Rating:
Summary: Lousy book, but may be best around
Review: This book does a good job of explaining the basics of extending the STL with your own containers, predicates, iterators, and algorithms. One nice section is useful as a reference for the algorithms defined in <algorithm>. It explains in plainer language than the STL documenation that ships with VC++. I wish more time had been spent on the predicates in <functional> but the basics of predicates were covered in depth. The book uses examples that are relavent to the average programmer. One example in particular that I liked was an example implemenation of map and set like classes that used hash tables instead of trees. Since hash tables provide O(1) access instead of O(log N) for trees this is a very useful example when efficent access is more important than maintaining order.
Rating: 
Summary: A great book
Review: This book does a good job of explaining the basics of extending the STL with your own containers, predicates, iterators, and algorithms. One nice section is useful as a reference for the algorithms defined in <algorithm>. It explains in plainer language than the STL documenation that ships with VC++. I wish more time had been spent on the predicates in <functional> but the basics of predicates were covered in depth. The book uses examples that are relavent to the average programmer. One example in particular that I liked was an example implemenation of map and set like classes that used hash tables instead of trees. Since hash tables provide O(1) access instead of O(log N) for trees this is a very useful example when efficent access is more important than maintaining order.
