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

View more

  • 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.
  • Citation

Leave us a comment

No Comments

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