C++ gotchas : avoiding common problems in coding and design

Preface. Acknowledgments. 1. Basics. Gotcha #1: Excessive Commenting. Gotcha #2: Magic Numbers. Gotcha #3: Global Variables. Gotcha #4: Failure to Distinguish Overloading from Default Initialization. Gotcha #5: Misunderstanding References. Gotcha #6: Misunderstanding Const. Gotcha #7: Ignorance of Base Language Subtleties. Gotcha #8: Failure to Distinguish Access and Visibility. Gotcha #9: Using Bad Language. Gotcha #10: Ignorance of Idiom. Gotcha #11: Unnecessary Cleverness. Gotcha #12: Adolescent Behavior. 2. Syntax. Gotcha #13: Array/Initializer Confusion. Gotcha #14: Evaluation Order Indecision. Gotcha #15: Precedence Problems. Gotcha #16: for Statement Debacle. Gotcha #17: Maximal Munch Problems. Gotcha #18: Creative Declaration-Specifier Ordering. Gotcha #19: Function/Object Ambiguity. Gotcha #20: Migrating Type-Qualifiers. Gotcha #21: Self Initialization. Gotcha #22: Static and Extern Types. Gotcha #23: Operator Function Lookup Anomaly. Gotcha #24: Operator — Subtleties. 3. The Preprocessor. Gotcha #25: #define Literals. Gotcha #26: #define Pseudofunctions. Gotcha #27: Overuse of #if. Gotcha #28: Side Effects in Assertions. 4. Conversions. Gotcha #29: Converting Through void *. Gotcha #30: Slicing. Gotcha #31: Misunderstanding Pointer-to-Const Conversion. Gotcha #32: Misunderstanding Pointer-to-Pointer-to-Const Conversion. Gotcha #33: Misunderstanding Pointer-to-Pointer-to-Base Conversion. Gotcha #34: Pointer-to-MultiDimensional Array Problems. Gotcha #35: Unchecked Downcasting. Gotcha #36: Misusing Conversion Operators. Gotcha #37: Unintended Constructor Conversion. Gotcha #38: Casting Under Multiple Inheritance. Gotcha #39: Casting Incomplete Types. Gotcha #40: Old-Style Casts. Gotcha #41: Static Casts. Gotcha #42: Temporary Initialization of Formal Arguments. Gotcha #43: Temporary Lifetime. Gotcha #44: References and Temporaries. Gotcha #45: Ambiguity Failure of dynamic_cast. Gotcha #46: Misunderstanding Contravariance. 5. Initialization. Gotcha #47: Assignment/Initialization Confusion. Gotcha #48: Improperly Scoped Variables. Gotcha #49: Failure to Appreciate C++'s Fixation on Copy Operations. Gotcha #50: Bitwise Copy of Class Objects. Gotcha #51: Confusing Initialization and Assignment in Constructors. Gotcha #52: Inconsistent Ordering of the Member Initialization List. Gotcha #53: Virtual Base Default Initialization. Gotcha #54: Copy Constructor Base Initialization. Gotcha #55: Runtime Static Initialization Order. Gotcha #56: Direct versus Copy Initialization. Gotcha #57: Direct Argument Initialization. Gotcha #58: Ignorance of the Return Value Optimizations. Gotcha #59: Initializing a Static Member in a Constructor. 6. Memory and Resource Management. Gotcha #60: Failure to Distinguish Scalar and Array Allocation. Gotcha #61: Checking for Allocation Failure. Gotcha #62: Replacing Global New and Delete. Gotcha #63: Confusing Scope and Activation of Member new and delete. Gotcha #64: Throwing String Literals. Gotcha #65: Improper Exception Mechanics. Gotcha #66: Abusing Local Addresses. Gotcha #67: Failure to Employ Resource Acquisition Is Initialization. Gotcha #68: Improper Use of auto_ptr. 7. Polymorphism. Gotcha #69: Type Codes. Gotcha #70: Nonvirtual Base Class Destructor. Gotcha #71: Hiding Nonvirtual Functions. Gotcha #72: Making Template Methods Too Flexible. Gotcha #73: Overloading Virtual Functions. Gotcha #74: Virtual Functions with Default Argument Initializers. Gotcha #75: Calling Virtual Functions in Constructors and Destructors. Gotcha #76: Virtual Assignment. Gotcha #77: Failure to Distinguish among Overloading, Overriding, and Hiding. Gotcha #78: Failure to Grok Virtual Functions and Overriding. Gotcha #79: Dominance Issues. 8. Class Design. Gotcha #80: Get/Set Interfaces. Gotcha #81: Const and Reference Data Members. Gotcha #82: Not Understanding the Meaning of Const Member Functions. Gotcha #83: Failure to Distinguish Aggregation and Acquaintance. Gotcha #84: Improper Operator Overloading. Gotcha #85: Precedence and Overloading. Gotcha #86: Friend versus Member Operators. Gotcha #87: Problems with Increment and Decrement. Gotcha #88: Misunderstanding Templated Copy Operations. 9. Hierarchy Design. Gotcha #89: Arrays of Class Objects. Gotcha #90: Improper Container Substitutability. Gotcha #91: Failure to Understand Protected Access. Gotcha #92: Public Inheritance for Code Reuse. Gotcha #93: Concrete Public Base Classes. Gotcha #94: Failure to Employ Degenerate Hierarchies. Gotcha #95: Overuse of Inheritance. Gotcha #96: Type-Based Control Structures. Gotcha #97: Cosmic Hierarchies. Gotcha #98: Asking Personal Questions of an Object. Gotcha #99: Capability Queries. Bibliography. Index. 0321125185T11072002