Dear customers, please be informed that our shopping cart will be unavailable between August 21 and September 1, 2014, as we will be making some changes to serve you better. To minimise any possible delivery disruption, we encourage you to make your purchases before August 21. We appreciate your understanding and apologise for any inconvenience.
  • Print
  • Share
C++ Timesaving Techniques For Dummies (076457986X) cover image

C++ Timesaving Techniques For Dummies

ISBN: 978-0-7645-7986-8
499 pages
March 2005
This title is out-of-print and not currently available for purchase from this site.

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.


  • Print
  • Share