What the book coves: The purpose of this book is to provide simple, quick, time saving techniques (over 70!) that can be used by all programmers at any level of experience in order to improve their application development.
Some of the techniques that will be covered include:
Mastering the evils of asserts
Creating a complete class
Hiding a method of a base class
Freeing blocks of memory
Implementing a simple locking mechanism
Creating debugging macros
Checking for errors at run-time
Memory leaks and how to find them
Beware the overloaded method
Reducing complexity of code
Series features: Breaks programming tasks and topics into hands-on techniques focused on giving readers the most efficient means of completing a task. Designed to encourage quick reading, including two-column format and enable reader to streamline the programming process in C++.
* This book is the perfect companion to C++ For Dummies, Fifth Edition (0-7645-6852-3)
Part I: Streamlining the Means and Mechanics of OOP.
Technique 1: Protecting Your Data with Encapsulation.
Technique 2: Using Abstraction to Extend Functionality.
Technique 3: Customizing a Class with Virtual Functions.
Technique 4: Inheriting Data and Functionality.
Technique 5: Separating Rules and Data from Code.
Part II: Working with the Pre-Processor.
Technique 6: Handling Multiple Operating Systems.
Technique 7: Mastering the Evils of Asserts.
Technique 8: Using const Instead of #define.
Technique 9: Macros and Why Not to Use Them.
Technique 10: Understanding sizeof.
Part III: Types.
Technique 11: Creating Your Own Basic Types.
Technique 12: Creating Your Own Types.
Technique 13: Using Enumerations.
Technique 14: Creating and Using Structures.
Technique 15: Understanding Constants.
Technique 16: Scoping Your Variables.
Technique 17: Using Namespaces.
Technique 18: Fixing Breaks with Casts.
Technique 19: Using Pointers to Member Functions.
Technique 20: Defining Default Arguments for Your Functions and Methods.
Part IV: Classes.
Technique 21: Creating a Complete Class.
Technique 22: Using Virtual Inheritance.
Technique 23: Creating Overloaded Operators.
Technique 24: Defining Your Own new and delete Handlers.
Technique 25: Implementing Properties.
Technique 26: Doing Data Validation with Classes.
Technique 27: Building a Date Class.
Technique 28: Overriding Functionality with Virtual Methods.
Technique 29: Using Mix-In Classes.
Part V: Arrays and Templates.
Technique 30: Creating a Simple
Technique 31: Extending a Template Class.
Technique 32: Creating Templates from Functions and Methods.
Technique 33: Working with Arrays.
Technique 34: Implementing Your Own Array Class.
Technique 35: Working with Vector Algorithms.
Technique 36: Deleting an Array of Elements.
Technique 37: Creating Arrays of Objects.
Technique 38: Working with Arrays of Object Pointers.
Technique 39: Implementing a Spreadsheet.
Part VI: Input and Output.
Technique 40: Using the Standard Streams to Format Data.
Technique 41: Reading In and Processing Files.
Technique 42: How to Read Delimited Files.
Technique 43: Writing Your Objects as XML.
Technique 44: Removing White Space from Input.
Technique 45: Creating a Configuration File.
Part VII: Using the Built-In Functionality.
Technique 46: Creating an Internationalization Class.
Technique 47: Hashing Out Translations.
Technique 48: Implementing Virtual Files.
Technique 49: Using Iterators for Your Collections.
Technique 50: Overriding the Allocator for a Collection Class.
Technique 51: Using the auto_ptr Class to Avoid Memory Leaks.
Technique 52: Avoiding Memory Overwrites.
Technique 53:Throwing, Catching, and Re-throwing Exceptions.
Technique 54: Enforcing Return Codes.
Technique 55: Using Wildcards.
Part VIII: Utilities.
Technique 56: Encoding and Decoding Data for the Web.
Technique 57: Encrypting and Decrypting Strings.
Technique 58: Converting the Case of a String.
Technique 59: Implementing a Serialization Interface.
Technique 60: Creating a Generic Buffer Class.
Technique 61: Opening a File Using Multiple Paths.
Part IX: Debugging C++ Applications.
Technique 62: Building Tracing into Your Applications.
Technique 63: Creating Debugging Macros and Classes.
Technique 64: Debugging Overloaded Methods.
Part X: The Scary (or Fun!) Stuff.
Technique 65: Optimizing Your Code.
Technique 66: Documenting the Data Flow.
Technique 67: Creating a Simple Locking Mechanism.
Technique 68: Creating and Using Guardian Classes.
Technique 69: Working with Complex Numbers.
Technique 70: Converting Numbers to Words.
Technique 71: Reducing the Complexity of Code.