Appendix A. Beyond Effective C++ Effective C++ covers what I consider to be the most important general guidelines for practicing C++ programmers, but if you're interested in more ways to improve your effectiveness, I encourage you to examine my other C++ books, More Effective C++ and Effective STL. More Effective C++ covers additional programming guidelines and includes extensive treatments of topics such as efficiency and programming with exceptions. It also describes important C++ programming techniques like smart pointers, reference counting, and proxy objects. Effective STL is a guideline-oriented book like Effective C++, but it focuses exclusively on making effective use of the Standard Template Library. Tables of contents for both books are summarized below. Contents of More Effective C++ Basics Item 1: | Distinguish between pointers and references | Item 2: | Prefer C++-style casts | Item 3: | Never treat arrays polymorphically | Item 4: | Avoid gratuitous default constructors |
Operators Item 5: | Be wary of user-defined conversion functions | Item 6: | Distinguish between prefix and postfix forms of increment and decrement operators | Item 7: | Never overload &&, ||, or, | Item 8: | Understand the different meanings of new and delete |
Exceptions Item 9: | Use destructors to prevent resource leaks | Item 10: | Prevent resource leaks in constructors | Item 11: | Prevent exceptions from leaving destructors | Item 12: | Understand how throwing an exception differs from passing a parameter or calling a virtual function | Item 13: | Catch exceptions by reference | Item 14: | Use exception specifications judiciously | Item 15: | Understand the costs of exception handling |
Efficiency Item 16: | Remember the 80-20 rule | Item 17: | Consider using lazy evaluation | Item 18: | Amortize the cost of expected computations | Item 19: | Understand the origin of temporary objects | Item 20: | Facilitate the return value optimization | Item 21: | Overload to avoid implicit type conversions | Item 22: | Consider using op= instead of stand-alone op | Item 23: | Consider alternative libraries | Item 24: | Understand the costs of virtual functions, multiple inheritance, virtual base classes, and RTTI |
Techniques Item 25: | Virtualizing constructors and non-member functions | Item 26: | Limiting the number of objects of a class | Item 27: | Requiring or prohibiting heap-based objects | Item 28: | Smart pointers | Item 29: | Reference counting | Item 30: | Proxy classes | Item 31: | Making functions virtual with respect to more than one object |
Miscellany Item 32: | Program in the future tense | Item 33: | Make non-leaf classes abstract | Item 34: | Understand how to combine C++ and C in the same program | Item 35: | Familiarize yourself with the language standard |
Contents of Effective STL 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 a container's 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. |
|