Skip to main content

C++ Timesaving Techniques For Dummies

C++ Timesaving Techniques For Dummies

Matthew Telles

ISBN: 978-0-764-59558-5

Mar 2005

499 pages

Select type: E-Book

Product not available for purchase

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)
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.

Download the Source Code
To use this file, download it to your local machine and unzip it. Windows users can use the Windows built-in ZIP utilities or a 3rd party utility like WinZip. Be sure to use the correct option in your ZIP utility to preserve the directory structure when decompressing the archive.
Download