Book Summary of Effective STL: 50 Specific Ways to Improve Your Use of the Standard Template Library
C++'s Standard Template Library is revolutionary, but until now, learning to use it well has been a challenge. In this book, best-selling author Scott Meyers exposes critical rules of thumb experts use to get the most out of STL. Using the same clear, concise approach that made Effective C++ so successful, he shows developers exactly how to unravel STL's complexities -- and leverage its full power. The book is organized into 50 guidelines, each followed by specific examples and to-the-point explanations. Meyers offers advice on what should be done, and why -- and what should not be done, and why not.

Features

Don't just learn what's "in" the STL: master its full power!
Clear, concise, concrete guidelines for using iterators, containers, function objects, algorithms, and more.
Proven approaches for building optimized, robust, reusable code.


Table Of Contants
I. Containers

Choose your containers with care.
Beware the illusion of container-independent code.
Make copying cheap and correct for objects in containers.
Call empty instead of checking size against zero.
Prefer range member functions to their single-element counterparts.
Be alert for C++’s most vexing parse.
When using containers of newed pointers, remember to delete the pointers before the container is destroyed.
Never create containers of auto_ptrs.
Choose carefully among erasing options.
Be aware of allocator conventions and restrictions.
Understand the legitimate uses of custom allocators.
Have realistic expectations about the thread safety of STL containers.

II. Vector and string

Prefer vector and string to dynamically allocated arrays.
Use reserve to avoid unnecessary reallocations.
Be aware of variations in string implementations.
Know how to pass vector and string data to legacy APIs.
Use "the swap trick" to trim excess capacity.
Avoid using vector.

III. Associative Containers

Understand the difference between equality and equivalence.
Specify comparison types for associative containers of pointers.
Always have comparison functions return false for equal values.
Avoid in-place key modification in set and multiset.
Consider replacing associative containers with sorted vectors.
Prefer map::insert to map::operator[] when efficiency is a concern.
Familiarize yourself with the nonstandard hashed containers.

IV. Iterators

Prefer iterator to const_iterator, reverse_iterator, and verse_iterator.
Use distance and advance to convert const_iterators to iterators.
Understand how to use a reverse_iterator's base iterator.
Consider istreambuf_iterators for character by character input.

V. Algorithms

Make sure destination ranges are big enough.
Know your sorting options.
Follow remove-like algorithms by erase if you really want to remove something.
Be wary of remove-like algorithms on containers of pointers.
Note which algorithms expect sorted ranges.
Implement simple case-insensitive string comparisons via mismatch or lexicographical_compare.
Use not1 and remove_copy_if to perform a copy_if.
Use accumulate or for_each to summarize sequences.

VI. Functors, Functor Classes, Functions, etc.

Design functor classes for pass-by-value.
Make predicates pure functions.
Make functor classes adaptable.
Understand the reasons for ptr_fun, mem_fun, and mem_fun_ref.
Make sure less means operator

VII. Programming with the STL

Prefer algorithm calls to hand-written loops.
Prefer member functions to algorithms with the same names.
Distinguish among count, find, binary_search, lower_bound, upper_bound, and equal_range.
Consider function objects instead of functions as algorithm parameters.
Avoid producing write-only code.
Always #include the proper headers.
Learn to decipher STL-related compiler diagnostics.
Familiarize yourself with STL-related web sites.

To be updated