The book consists of 7 chapters. STL provides four types of components: containers, algorithms, iterators, and functors.

The first three chapters cover the containers in STL. Note that each chapter consists of items. Each item is a single piece of advice. The title of an item is an imperative: “Always do this” or “Never do that”, or even “Consider doing this”. This design splits the whole book into smaller, concrete and easy-to-digest chunks. A wide variety of topics are discussed in these three chapters, from the choice of containers to weird C++ syntax quirks. After these chapters you’ll have a better understanding of the containers, their underlying abstract data structures and possible implementations, will have learned some cool tricks and good practices, also some things you should never do.

The book is from 2001 and a lot of things have changed since then. The Item 25 talks about the nonstandard hashing containers, how unfortunate it is that STL lacks them and how to fill the void. Even though, since C++11 we have “unordered” hashing containers, this item is still worth reading.

The next, fourth chapter covers the iterators. It gives a good understanding of the overall concept and idea behind the iterators, teaches some cool tricks and practical usages.

The next, fifth chapter covers the algorithms. If you’re one of those people who are scared of this word, relax: there is no math here. The whole idea of STL was to take that responsibility and implement those algorithms in the best possible way. All you have to do is to use them correctly. This chapter covers the majority of STL algorithms, shows the common mistakes and teaches how to avoid them, teaches the importance of the naming and the philosophy behind (for example the difference between remove and erase).

By the way, if you really are one of those people, don’t be. Algorithms are awesome. Go check out this book.

The next chapter covers the functors, functor classes, etc. These components complete the algorithms and thus are very important too. As we have std::function and lambdas since C++11, some of the items in this chapter might seem expired, and yes, maybe there is no practical use of it anymore, but it’s quite important to understand the “under the hood” of these new features, especially the lamdas. And of course, there are still projects that are stuck with C++98, so it’s definitely worth learning.

The last chapter is a summary of the STL, gives some practical tips and, more importantly, teaches the philosophy of STL, sets the right mindset. It’s very important to have the right guidance into the world of STL, not only to be safe from mistakes, but also to get the maximum out of it.