Dummies.com
  • Print
  • Share
C++ Timesaving Techniques For Dummies (076457986X) cover image

C++ Timesaving Techniques For Dummies

ISBN: 978-0-7645-7986-8
Paperback
499 pages
March 2005
This title is out-of-print and not currently available for purchase from this site.
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.

  • Print
  • Share