Rating: 
Summary: Useful, but not Handy
Review: John's reviews are interesting. While I agree with many of the points he makes, I disagree with some. And I found a few to be self-contradictory.He says, for instance, that "This is a good solid book that will get you up to speed quickly on all the important ideas in STL, and many of its basic usage idioms", but then naievely claims that "there aren't any higher level ideas than those presented here". Does the book cover only basic concepts, or is it that if the book doesn't cover it, it is not knowledge? The book is full of concrete examples. But my problem was that they were trivial. Reversing or sorting or finding characters within a string is great fun. But it doesn't help me understand who owns the memory within a container. Or how to directly and safely reference an element at an arbitrary position within a container outside of an iteration loop. A majority of the examples use trivial intrinsic datatypes for contained elements; how is using a struct or class different? All of those issues are important aspects of using the library, and not something I think a busy reader should leave to "a little imagination". While most of the disputed facts are eventually available in the text, they're not easy to find. The organization of the book isn't quite intuitive enough to make it a thoughtful reference or a breezy tutorial. And, in many cases, once found, they're not clear. John cited page 151 for an explanation of the differences between some of the collections. There, it says "With maps an multimaps, the data items are pairs of keys and data of some other type..." What's that mean? Two keys and data of some other type? Or a key and data of some other type? Does "pairs" mean "two", or an instance of the "pairs" utility class? The book really is missing information. None of the examples do any error checking whatsoever, and the exceptions that the templates throw aren't described. (Maybe, like priority queues, error handling was formalized after the book went to press. It is showing its age, and there's now a 2nd edition. I haven't purchased it.) It's ambitious to write a book that tries to serve as both a tutorial and the reference. (Me, I think it's just impossible.) This book does very well, but falls short of adequately completing either goal. I think that there's a bias against this book because it doesn't fit well with the way these reviewers would have liked to learn the subject at hand. I know that's where I landed. While true masters do indeed make it look simple, making it look simple doesn't help learning. Otherwise, we could all watch Tiger Woods for a few Sundays before taking home a Buick and a six-figure check.
Rating:
Summary: Useful, but not Handy
Review: John's reviews are interesting. While I agree with many of the points he makes, I disagree with some. And I found a few to be self-contradictory. He says, for instance, that "This is a good solid book that will get you up to speed quickly on all the important ideas in STL, and many of its basic usage idioms", but then naievely claims that "there aren't any higher level ideas than those presented here". Does the book cover only basic concepts, or is it that if the book doesn't cover it, it is not knowledge? The book is full of concrete examples. But my problem was that they were trivial. Reversing or sorting or finding characters within a string is great fun. But it doesn't help me understand who owns the memory within a container. Or how to directly and safely reference an element at an arbitrary position within a container outside of an iteration loop. A majority of the examples use trivial intrinsic datatypes for contained elements; how is using a struct or class different? All of those issues are important aspects of using the library, and not something I think a busy reader should leave to "a little imagination". While most of the disputed facts are eventually available in the text, they're not easy to find. The organization of the book isn't quite intuitive enough to make it a thoughtful reference or a breezy tutorial. And, in many cases, once found, they're not clear. John cited page 151 for an explanation of the differences between some of the collections. There, it says "With maps an multimaps, the data items are pairs of keys and data of some other type..." What's that mean? Two keys and data of some other type? Or a key and data of some other type? Does "pairs" mean "two", or an instance of the "pairs" utility class? The book really is missing information. None of the examples do any error checking whatsoever, and the exceptions that the templates throw aren't described. (Maybe, like priority queues, error handling was formalized after the book went to press. It is showing its age, and there's now a 2nd edition. I haven't purchased it.) It's ambitious to write a book that tries to serve as both a tutorial and the reference. (Me, I think it's just impossible.) This book does very well, but falls short of adequately completing either goal. I think that there's a bias against this book because it doesn't fit well with the way these reviewers would have liked to learn the subject at hand. I know that's where I landed. While true masters do indeed make it look simple, making it look simple doesn't help learning. Otherwise, we could all watch Tiger Woods for a few Sundays before taking home a Buick and a six-figure check.
Rating: 
Summary: incorrect reviews
Review: Just a few more points, to refute earlier incorrect reviews: One reviewer said: "For instance, in the detailed presentation of sets and multisets, nowhere is it mentioned what the difference between the two is. You have to go to the "Overview of STL components" to get the information." This is incorrect: the authors cover the difference numerous places (and most people can guess what the difference is). See for example pages 118 and 151 (the latter being the section explaining set, multiset, and map). Another reviewer said: "...it fails to mention several large chunks of STL that you could immediately use, including the functionals and some very useful pieces (strings (with iostreams), bit sets, fstreams, locales, limits, etc)." This also is incorrect and misleading. Most of the items above are not part of STL, but rather the standard C++ library, so of course the authors don't discuss them. Also, presumably by "functionals" the reviewer means function objects, or function adaptors. Both of these are well coevered in the book. Another review stated: "If you look for some concrete examples then this book isn't it." This is hard to accept: almost every page of this book contains carefully chosen example code illustrating the point at hand. Even a little imagination should suffice to adapt it to your particulars. And finally: "While this book might help you use STL containers in straightforward circumstances, it doesn't contain enough theory to give you mastery of the topic." Also hard to accept. This book covers as much theory as there is to present; there aren't any higher level ideas than those presented here. For example, they take great pains to explain why there is a separation of algorithm and data structure, and to illustrate the pivotal role iterators play in organizing the library, to ensure (mostly) that the right algorithms are used with the right containers. If one looks for even deeper meaning, well, most of us don't know any, so feel free to write a book on it when you find it. Seems like people are really biased against this book. Again, it's a really good introduction to the fundamentals. Sorry to see it get trashed.
Rating:
Summary: incorrect reviews
Review: Just a few more points, to refute earlier incorrect reviews: One reviewer said: "For instance, in the detailed presentation of sets and multisets, nowhere is it mentioned what the difference between the two is. You have to go to the "Overview of STL components" to get the information." This is incorrect: the authors cover the difference numerous places (and most people can guess what the difference is). See for example pages 118 and 151 (the latter being the section explaining set, multiset, and map). Another reviewer said: "...it fails to mention several large chunks of STL that you could immediately use, including the functionals and some very useful pieces (strings (with iostreams), bit sets, fstreams, locales, limits, etc)." This also is incorrect and misleading. Most of the items above are not part of STL, but rather the standard C++ library, so of course the authors don't discuss them. Also, presumably by "functionals" the reviewer means function objects, or function adaptors. Both of these are well coevered in the book. Another review stated: "If you look for some concrete examples then this book isn't it." This is hard to accept: almost every page of this book contains carefully chosen example code illustrating the point at hand. Even a little imagination should suffice to adapt it to your particulars. And finally: "While this book might help you use STL containers in straightforward circumstances, it doesn't contain enough theory to give you mastery of the topic." Also hard to accept. This book covers as much theory as there is to present; there aren't any higher level ideas than those presented here. For example, they take great pains to explain why there is a separation of algorithm and data structure, and to illustrate the pivotal role iterators play in organizing the library, to ensure (mostly) that the right algorithms are used with the right containers. If one looks for even deeper meaning, well, most of us don't know any, so feel free to write a book on it when you find it. Seems like people are really biased against this book. Again, it's a really good introduction to the fundamentals. Sorry to see it get trashed.
Rating: 
Summary: Poor organization and presentation
Review: Poorly organized and poorly presented. For instance, in the detailed presentation of sets and multisets, nowhere is it mentioned what the difference between the two is. You have to go to the "Overview of STL components" to get the information. Secondly, you have to wade through a whole bunch of code to find what it is that they are trying to say. To continue my previous illustration, how do I insert values into a set or multiset? They have one line: "The simplest 'insert' member function for 'set' and 'multiset' takes a single argument of type 'value_type', which type 'Key', and inserts a copy of the argument." This one line is followed by a page of code which I have to dredge through to find out that 'insert' is the method to be used. The authors should have done the following: <begin description> Let us assume you have defined the following set: set<char, less<char> > CharSet; To insert the letter 'a' into this CharS! et, you would say CharSet.insert('a'); <end description> The authors should then proceed to present a more difficult example. Anyway, my recommendation is DON'T buy this book. Ever. Till the authors learn how to present their stuff properly.
Rating:
Summary: Still the best guide for the standard C++ library
Review: Since this book was written the Standard Template Library (STL) has become part of the ANSI/ISO standard C++ library. The book is old (for being a bleeding edge technology) and some minor details have changed, but this is still the best guide available. Every serious C++ programmer should have this book within reach when programming.
Rating: 
Summary: dated, not detailed enough
Review: Somewhat dated reference to STL, with general overview of STL concepts. The style is simple, general, and tutorial. I wanted a book at a higher level, and I was disappointed. While this book might help you use STL containers in straightforward circumstances, it doesn't contain enough theory to give you mastery of the topic.
Rating: 
Summary: There's better out there
Review: The book itself isn't that bad. It is a good high level tutorial without too much detail. However, if you want a tutorial and reference that is more up to date I'd recommend checking out The C++ Standard Library: A Tutorial and Reference. It was recently published and covers a broader scope (the whole standard library, not just the STL).
Rating:
Summary: Don't buy this book if you want to learn how to use the STL.
Review: The book offers little to someone who wants to learn to use the STL library. The orginization is poor, and is really only useful to someone who wants a guide for implementing his/her own class library. It actually leaves necessary information to just use these templates.
Rating:
Summary: Sophisticated STL book
Review: This book deals with STL like in virtual algorythmic world. But that makes it possible to show the principles and usage of STL without loosing time or space for all the modern internet topics. The book is very precise and systematic. It helped me applying STL, when I first used it, and it worked. The book consists of three parts: 1.) A Tutorial Introduction to STL, 2.) Putting It Together: Example Programs, 3.) STL Reference Guide.
| 
