C++ Gotchas: Avoiding Common Problems in Coding and Design View Larger Image | Stephen C. Dewhurst
Addison-Wesley, Paperback, Published November 2002, 325 pages, ISBN 0321125185 | List Price: $49.99
Our Price: $38.95
You Save: $11.04 (22% Off)
| | | Availability: Out-Of-Stock |
Be the First to Write a Review and tell the world about this title!People who purchase this book frequently purchase: - Effective C++: 55 Specific Ways to Improve Your Programs and Designs, 3rd Edition; Scott Meyers, $38.95, 22% Off!
- Exceptional C++ Style: 40 New Engineering Puzzles, Programming Problems, and Solutions; Herb Sutter, $34.95, 22% Off!
- C++ Coding Standards: 101 Rules, Guidelines, and Best Practices; Herb Sutter, et al, $34.95, 22% Off!
- C++ FAQ's, 2nd Edition; Marshall P. Cline, et al, $46.50, 22% Off!
Books on similar topics, in best-seller order:Books from the same publisher, in best-seller order:
C++ Gotchas: Avoiding Common Problems in Coding and Design is
the professional programmer's manual for avoiding or correcting ninety-nine
of the most common, destructive, and interesting C++ design and programming
errors. It also serves as an insider's guide to the more subtle C++ features
and programming techniques.
This book introduces basic errors present in almost all C++ code, such as excessive
commenting and unnecessary cleverness. It also includes chapters handling increasingly
complex mistakes in syntax, preprocessing, conversions, initialization, memory
and resource management, polymorphism, class design, and hierarchy design. Each
error is explained and its context and repercussions clearly illustrated. The
resolution of each problem is subsequently detailed and demonstrated.
Author Stephen Dewhurst supplies readers with idioms and design patterns that
can be applied to provide customized solutions to common problems. Readers also
gain deeper knowledge of the commonly misunderstood features of C++ used in
advanced programming and design.
Readers discover:
- How to escape both common and complex traps associated with C++
- How to produce more reusable, more maintainable code
- Advanced C++ programming techniques
- Nuances of the C++ language
Showing how to navigate through the greatest dangers in C++ programming, C++
Gotchas provides programmers with the practical know-how needed to gain
expert status.
Table of Contents
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 Multi-Dimensional 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 vs. 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: Non-Virtual Base Class Destructor.
Gotcha #71: Hiding Non-Virtual 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 vs. 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.
|
