Effective STL : 50 specific ways to improve your use of the standard template library = STL高效编...

table of contents

preface xi

acknowledgments xv

introduction
chapter 1: containers
item 1: choose your containers with care.
item 2: beware the illusion of container-independent code.
item 3: make copying cheap and correct for objects in containers.
item 4: call empty instead of checking size() against zero.
item 5: prefer range member functions to their single-element counterparts.
item 6: be alert for c++’s most vexing parse.
item 7: when using containers of newed pointers, remember to delete the pointers before the container is destroyed.
item 8: never create containers of auto_ptrs.
item 9: choose carefully among erasing options.
item 10: be aware of allocator conventions and restrictions.
item 11: understand the legitimate uses of custom allocators.
item 12: have realistic expectations about the thread safety of stl containers.
chapter 2: vector and string
item 13: prefer vector and string to dynamically allocated arrays.
item 14: use reserve to avoid unnecessary reallocations.
.item 15: be aware of variations in string implementations.
item 16: know how to pass vector and string data to legacy apis.
item 17: use “the swap trick” to trim excess capacity.
item 18: avoid using vector[bool].
chapter 3: associative containers
item 19: understand the difference between equality and equivalence.
item 20: specify comparison types for associative containers of pointers.
item 21: always have comparison functions return false for equal values.
item 22: avoid in-place key modification in set and multiset.
item 23: consider replacing associative containers with sorted vectors.
item 24: choose carefully between map::operator[] and map::insert when efficiency is important.
item 25: familiarize yourself with the nonstandard hashed containers.
chapter 4: iterators
item 26: prefer iterator to const_iterator, reverse_iterator, and const_reverse_iterator.
item 27: use distance and advance to convert const_iterators to iterators.
item 28: understand how to use a reverse_iterator’s base iterator.
item 29: consider istreambuf_iterators for character by character input.
chapter 5: algorithms
item 30: make sure destination ranges are big enough.
item 31: know your sorting options.
item 32: follow remove-like algorithms by erase if you really want to remove something.
item 33: be wary of remove-like algorithms on containers of pointers.
item 34: note which algorithms expect sorted ranges.
item 35: implement simple case-insensitive string comparisons via mismatch or lexicographical_compare.
item 36: understand the proper implementation of copy_if.
item 37: use accumulate or for_each to summarize ranges.
chapter 6: functors, functor classes, functions, etc.
item 38: design functor classes for pass-by-value.
item 39: make predicates pure functions.
item 40: make functor classes adaptable.
item 41: understand the reasons for ptr_fun, mem_fun, and mem_fun_ref.
item 42: make sure less[t] means operator[.
chapter 7: programming with the stl
item 43: prefer algorithm calls to hand-written loops.
item 44: prefer member functions to algorithms with the same names.
item 45: distinguish among count, find, binary_search, lower_bound, upper_bound, and equal_range.
item 46: consider function objects instead of functions as algorithm parameters.
item 47: avoid producing write-only code.
item 48: always #include the proper headers.
item 49: learn to decipher stl-related compiler diagnostics.
item 50: familiarize yourself with stl-related web sites.
bibliography
appendix a: locales and case-insensitive string comparisons
appendix b: remarks on microsoft’s stl platforms
index