C++ Timesaving Techniques for Dummies

Description

* Seasoned C++ programmer Matthew Telles shows developers at any level of experience how to save hours by improving, refactoring, and debugging their code
* Some of the techniques covered include mastering 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, finding and fixing memory leaks, and reducing code complexity
* The easy-to-follow, two-column Timesaving Techniques format makes mastering each timesaver a snap
* C++ is one of today's most widely used programming languages, with compilers offered by Microsoft, Borland, and Code Warrior
* This book is the perfect companion to C++ For Dummies, Fifth Edition (0-7645-6852-3)

CONTENTS:

Introduction.

  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

  
Template Class.

  
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.

  Index.