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

*Seasoned C++ programmer Matthew Telles shows developers at any level of experience to save hours by improving, refactoring, and debugging their code

*Some of the techniques covered include mastering asserts, creating a complete class, hiding a 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

*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

Introduction.
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 .
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++ .

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 .
Technique 70: Converting Numbers to Words.
Technique 71: Reducing the Complexity of Code.

Title: C++ Timesaving Techniques for Dummies
Author: Matthew Telles
Edition: 1st Edition
ISBN: 978-0-7645-7986-8
Type: eBook
Language: English
Computer Programming
REVIEW 83%
83%

No Comments

  • Can you please leave feedback and comments here

    Your opinions and comments would be greatly appreciated. If you have comments or questions we've added this section so that we might have a dialogue with you.

Complete all fields

five × 1 =