C++ Gotchas

Stephen C. Dewhurst was among the first users of C++ at Bell Labs. He has more than twenty years of experience in applying C++ to problem areas such as compiler design, securities trading, e-commerce, and embedded telecommunications. He is the author and coauthor of several books on C++ and is a member of the advisory board for The C++ Source, a contributing editor for C/C++ Users Journal, and a former columnist for C++ Report. He is also the author of two C++ compilers and numerous articles on compiler design and C++ programming techniques. 0321125185AB02022005

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