Effective C++ Digital Collection: 140 Ways to Improve Your Programming

Effective C++ Digital Collection: 140 Ways to Improve Your Programming......Page 2
 Effective C++......Page 15
  Introduction......Page 31
   Item 1: View C++ as a federation of languages.......Page 41
   Item 2: Prefer consts, enums, and inlines to #defines.......Page 43
   Item 3: Use const whenever possible.......Page 47
   Item 4: Make sure that objects are initialized before they’re used.......Page 56
   Item 5: Know what functions C++ silently writes and calls.......Page 64
   Item 6: Explicitly disallow the use of compiler-generated functions you do not want.......Page 67
   Item 7: Declare destructors virtual in polymorphic base classes.......Page 70
   Item 8: Prevent exceptions from leaving destructors.......Page 74
   Item 9: Never call virtual functions during construction or destruction.......Page 78
   Item 10: Have assignment operators return a reference to *this.......Page 82
   Item 11: Handle assignment to self in operator=.......Page 83
   Item 12: Copy all parts of an object.......Page 87
   Item 13: Use objects to manage resources.......Page 91
   Item 14: Think carefully about copying behavior in resource-managing classes.......Page 96
   Item 15: Provide access to raw resources in resource-managing classes.......Page 99
   Item 16: Use the same form in corresponding uses of new and delete.......Page 103
   Item 17: Store newed objects in smart pointers in standalone statements.......Page 105
   Item 18: Make interfaces easy to use correctly and hard to use incorrectly.......Page 108
   Item 19: Treat class design as type design.......Page 114
   Item 20: Prefer pass-by-reference-to-const to pass-by-value.......Page 116
   Item 21: Don’t try to return a reference when you must return an object.......Page 120
   Item 22: Declare data members private.......Page 124
   Item 23: Prefer non-member non-friend functions to member functions.......Page 128
   Item 24: Declare non-member functions when type conversions should apply to all parameters.......Page 132
   Item 25: Consider support for a non-throwing swap.......Page 136
   Item 26: Postpone variable definitions as long as possible.......Page 143
   Item 27: Minimize casting.......Page 146
   Item 28: Avoid returning “handles” to object internals.......Page 153
   Item 29: Strive for exception-safe code.......Page 157
   Item 30: Understand the ins and outs of inlining.......Page 164
   Item 31: Minimize compilation dependencies between files.......Page 170
  Chapter 6: Inheritance and Object-Oriented Design......Page 179
   Item 32: Make sure public inheritance models “is-a.”......Page 180
   Item 33: Avoid hiding inherited names.......Page 186
   Item 34: Differentiate between inheritance of interface and inheritance of implementation.......Page 191
   Item 35: Consider alternatives to virtual functions.......Page 199
   Item 36: Never redefine an inherited non-virtual function.......Page 208
   Item 37: Never redefine a function’s inherited default parameter value.......Page 210
   Item 38: Model “has-a” or “is-implemented-in-terms-of” through composition.......Page 214
   Item 39: Use private inheritance judiciously.......Page 217
   Item 40: Use multiple inheritance judiciously.......Page 222
   Item 41: Understand implicit interfaces and compile-time polymorphism.......Page 229
   Item 42: Understand the two meanings of typename.......Page 233
   Item 43: Know how to access names in templatized base classes.......Page 237
   Item 44: Factor parameter-independent code out of templates.......Page 242
   Item 45: Use member function templates to accept “all compatible types.”......Page 248
   Item 46: Define non-member functions inside templates when type conversions are desired.......Page 252
   Item 47: Use traits classes for information about types.......Page 256
   Item 48: Be aware of template metaprogramming.......Page 263
  Chapter 8: Customizing new and delete......Page 269
   Item 49: Understand the behavior of the new-handler.......Page 270
   Item 50: Understand when it makes sense to replace new and delete.......Page 277
   Item 51: Adhere to convention when writing new and delete.......Page 282
   Item 52: Write placement delete if you write placement new.......Page 286
   Item 53: Pay attention to compiler warnings.......Page 292
   Item 54: Familiarize yourself with the standard library, including TR1.......Page 293
   Item 55: Familiarize yourself with Boost.......Page 299
  Appendix A: Beyond Effective C++......Page 303
  Appendix B: Item Mappings Between Second and Third Editions......Page 307
   A......Page 310
   C......Page 311
   D......Page 313
   E......Page 314
   F......Page 317
   I......Page 318
   M......Page 320
   O......Page 321
   P......Page 322
   R......Page 323
   S......Page 324
   T......Page 325
   V......Page 326
   X......Page 327
 More Effective C++......Page 330
  Introduction......Page 342
   Item 1: Distinguish between pointers and references.......Page 350
   Item 2: Prefer C++-style casts.......Page 353
   Item 3: Never treat arrays polymorphically.......Page 357
   Item 4: Avoid gratuitous default constructors.......Page 360
   Item 5: Be wary of user-defined conversion functions.......Page 365
   Item 6: Distinguish between prefix and postfix forms of increment and decrement operators.......Page 372
   Item 7: Never overload &&, ||, or ,.......Page 376
   Item 8: Understand the different meanings of new and delete.......Page 379
  Exceptions......Page 385
   Item 9: Use destructors to prevent resource leaks.......Page 386
   Item 10: Prevent resource leaks in constructors.......Page 391
   Item 11: Prevent exceptions from leaving destructors.......Page 399
   Item 12: Understand how throwing an exception differs from passing a parameter or calling a virtual function.......Page 402
   Item 13: Catch exceptions by reference.......Page 409
   Item 14: Use exception specifications judiciously.......Page 413
   Item 15: Understand the costs of exception handling.......Page 419
  Efficiency......Page 422
   Item 16: Remember the 80-20 rule.......Page 423
   Item 17: Consider using lazy evaluation.......Page 426
   Item 18: Amortize the cost of expected computations.......Page 434
   Item 19: Understand the origin of temporary objects.......Page 439
   Item 20: Facilitate the return value optimization.......Page 442
   Item 21: Overload to avoid implicit type conversions.......Page 446
   Item 22: Consider using op= instead of stand-alone op.......Page 448
   Item 23: Consider alternative libraries.......Page 451
   Item 24: Understand the costs of virtual functions, multiple inheritance, virtual base classes, and RTTI.......Page 454
   Item 25: Virtualizing constructors and non-member functions.......Page 464
   Item 26: Limiting the number of objects of a class.......Page 471
   Item 27: Requiring or prohibiting heap-based objects.......Page 486
   Item 28: Smart pointers.......Page 500
   Item 29: Reference counting.......Page 524
   Item 30: Proxy classes.......Page 554
   Item 31: Making functions virtual with respect to more than one object.......Page 569
   Item 32: Program in the future tense.......Page 593
   Item 33: Make non-leaf classes abstract.......Page 599
   Item 34: Understand how to combine C++ and C in the same program.......Page 611
   Item 35: Familiarize yourself with the language standard.......Page 618
  Recommended Reading......Page 626
  An auto_ptr Implementation......Page 632
   A......Page 636
   C......Page 637
   D......Page 639
   E......Page 641
   F......Page 642
   I......Page 643
   M......Page 644
   O......Page 645
   P......Page 647
   R......Page 649
   S......Page 650
   T......Page 651
   V......Page 652
   Y......Page 653
   A......Page 654
   C......Page 655
   M......Page 656
   R......Page 657
   T......Page 658
   W......Page 659
 Effective STL......Page 661
  Introduction......Page 675
   Item 1: Choose your containers with care.......Page 685
   Item 2: Beware the illusion of container-independent code.......Page 689
   Item 3: Make copying cheap and correct for objects in containers.......Page 694
   Item 4: Call empty instead of checking size() against zero.......Page 697
   Item 5: Prefer range member functions to their single-element counterparts.......Page 698
   Item 6: Be alert for C++’s most vexing parse.......Page 707
   Item 7: When using containers of newed pointers, remember to delete the pointers before the container is destroyed.......Page 710
   Item 8: Never create containers of auto_ptrs.......Page 714
   Item 9: Choose carefully among erasing options.......Page 717
   Item 10: Be aware of allocator conventions and restrictions.......Page 722
   Item 11: Understand the legitimate uses of custom allocators.......Page 728
   Item 12: Have realistic expectations about the thread safety of STL containers.......Page 732
   Item 13: Prefer vector and string to dynamically allocated arrays.......Page 737
   Item 14: Use reserve to avoid unnecessary reallocations.......Page 740
   Item 15: Be aware of variations in string implementations.......Page 742
   Item 16: Know how to pass vector and string data to legacy APIs.......Page 748
   Item 17: Use “the swap trick” to trim excess capacity.......Page 751
   Item 18: Avoid using vector.......Page 753
   Item 19: Understand the difference between equality and equivalence.......Page 757
   Item 20: Specify comparison types for associative containers of pointers.......Page 762
   Item 21: Always have comparison functions return false for equal values.......Page 766
   Item 22: Avoid in-place key modification in set and multiset.......Page 769
   Item 23: Consider replacing associative containers with sorted vectors.......Page 774
   Item 24: Choose carefully between map::operator[] and map::insert when efficiency is important.......Page 780
   Item 25: Familiarize yourself with the nonstandard hashed containers.......Page 785
   Item 26: Prefer iterator to const_iterator, reverse_iterator, and const_reverse_iterator.......Page 790
   Item 27: Use distance and advance to convert a container’s const_iterators to iterators.......Page 794
   Item 28: Understand how to use a reverse_iterator’s base iterator.......Page 797
   Item 29: Consider istreambuf_iterators for character-by-character input.......Page 800
  Chapter 5: Algorithms......Page 802
   Item 30: Make sure destination ranges are big enough.......Page 803
   Item 31: Know your sorting options.......Page 807
   Item 32: Follow remove-like algorithms by erase if you really want to remove something.......Page 813
   Item 33: Be wary of remove-like algorithms on containers of pointers.......Page 817
   Item 34: Note which algorithms expect sorted ranges.......Page 820
   Item 35: Implement simple case-insensitive string comparisons via mismatch or lexicographical_compare.......Page 824
   Item 36: Understand the proper implementation of copy_if.......Page 828
   Item 37: Use accumulate or for_each to summarize ranges.......Page 830
   Item 38: Design functor classes for pass-by-value.......Page 836
   Item 39: Make predicates pure functions.......Page 840
   Item 40: Make functor classes adaptable.......Page 843
   Item 41: Understand the reasons for ptr_fun, mem_fun, and mem_fun_ref.......Page 847
   Item 42: Make sure less means operator<.......Page 851
   Item 43: Prefer algorithm calls to hand-written loops.......Page 855
   Item 44: Prefer member functions to algorithms with the same names.......Page 864
   Item 45: Distinguish among count, find, binary_search, lower_bound, upper_bound, and equal_range.......Page 866
   Item 46: Consider function objects instead of functions as algorithm parameters.......Page 875
   Item 47: Avoid producing write-only code.......Page 880
   Item 48: Always #include the proper headers.......Page 883
   Item 49: Learn to decipher STL-related compiler diagnostics.......Page 884
   Item 50: Familiarize yourself with STL-related web sites.......Page 891
  Bibliography......Page 899
  Appendix A: Locales and Case-Insensitive String Comparisons......Page 903
  Appendix B: Remarks on Microsoft’s STL Platforms......Page 913
   A......Page 919
   B......Page 920
   C......Page 921
   D......Page 922
   E......Page 923
   F......Page 925
   I......Page 926
   L......Page 927
   M......Page 928
   P......Page 929
   R......Page 930
   S......Page 931
   T......Page 932
   V......Page 933
   Z......Page 934