C++ Timesaving Techniques for Dummies – Matthew Telles – 1st Edition


*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 at run-time, finding and fixing leaks, and reducing code

*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

View more

Table of Contents


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.

Leave us a commentNo Comments

Inline Feedbacks
View all comments
Would love your thoughts, please comment.x