C++ Timesaving Techniques For Dummies

C++ Timesaving Techniques For Dummies
Cover
Contents
Introduction
Saving Time with This Book
What's Available on the Companion Web Site?
Conventions Used in This Book
What's In This Book
Part I: Streamlining the Means and Mechanics of OOP
Part II: Working with the Pre-Processor
Part III: Types
Part IV: Classes
Part V: Arrays and Templates
Part VI: Input and Output
Part VII: Using the Built-in Functionality
Part VIII: Utilities
Part IX: Debugging C++ Applications
Part X: The Scary (or Fun!) Stuff
Icons Used in This Book
Part I: Streamlining the Means and Mechanics of OOP
Technique 1: Protecting Your Data with Encapsulation
Creating and Implementing an Encapsulated Class
Making Updates to an Encapsulated Class
Technique 2: Using Abstraction to Extend Functionality
Creating a Mailing-List Application
Testing the Mailing-List Application
Technique 3: Customizing a Class with Virtual Functions
Customizing a Class with Polymorphism
Testing the Virtual Function Code
Why Do the Destructors Work?
Technique 4: Inheriting Data and Functionality
Implementing a ConfigurationFile Class
Testing the ConfigurationFile Class
Delayed Construction
Technique 5: Separating Rules and Data from Code
The cDate Class
Testing the cDate Class
Part II: Working with the Pre-Processor
Technique 6: Handling Multiple Operating Systems
Creating the Header File
Testing the Header File
Technique 7: Mastering the Evils of Asserts
The Assert Problem
Fixing the Assert Problem
Technique 8: Using const Instead of #define
Using the const Construct
Identifying the Errors
Fixing the Errors
Technique 9: Macros and Why Not to Use Them
Initiating a Function with a String Macro - Almost
Fixing What Went Wrong with the Macro
Using Macros Appropriately
Technique 10: Understanding sizeof
Using the sizeof Function
Evaluating the Results
Using sizeof with Pointers
Part III: Types
Technique 11: Creating Your Own Basic Types
Implementing the Range Class
Testing the Range Class
Technique 12: Creating Your Own Types
Creating the Matrix Class
Matrix Operations
Multiplying a Matrix by a Scalar Value
Multiplying a Matrix by Scalar Values, Take 2
Testing the Matrix Class
Technique 13: Using Enumerations
Implementing the Enumeration Class
Testing the Enumeration Class
Technique 14: Creating and Using Structures
Implementing Structures
Interpreting the Output
Technique 15: Understanding Constants
Defining Constants
Implementing Constant Variables
Testing the Constant Application
Using the const Keyword
Technique 16: Scoping Your Variables
Illustrating Scope
Interpreting the Output
Technique 17: Using Namespaces
Creating a Namespace Application
Testing the Namespace Application
Technique 18: Fixing Breaks with Casts
Using Casts
Addressing the Compiler Problems
Testing the Changes
Technique 19: Using Pointers to Member Functions
Implementing Member-Function Pointers
Updating Your Code with Member-Function Pointers
Testing the Member Pointer Code
Technique 20: Defining Default Arguments for Your Functions and Methods
Customizing the Functions We Didn't Write
Customizing Functions We Wrote Ourselves
Testing the Default Code
Fixing the Problem
Part IV: Classes
Technique 21: Creating a Complete Class
Creating a Complete Class Template
Testing the Complete Class
Technique 22: Using Virtual Inheritance
Implementing Virtual Inheritance
Correcting the Code
Technique 23: Creating Overloaded Operators
Rules for Creating Overloaded Operators
Using Conversion Operators
Using Overloaded Operators
Testing the MyString Class
Technique 24: Defining Your Own new and delete Handlers
Rules for Implementing new and delete Handlers
Overloading new and delete Handlers
Testing the Memory Allocation Tracker
Technique 25: Implementing Properties
Implementing Properties
Testing the Property Class
Technique 26: Doing Data Validation with Classes
Implementing Data Validation with Classes
Testing Your SSN Validator Class
Technique 27: Building a Date Class
Creating the Date Class
Implementing the Date Functionality
Testing the Date Class
Some Final Thoughts on the Date Class
Technique 28: Overriding Functionality with Virtual Methods
Creating a Factory Class
Testing the Factory
Enhancing the Manager Class
Technique 29: Using Mix-In Classes
Implementing Mix-In Classes
Compiling and Testing Your Mix-In Class
Part V: Arrays and Templates
Technique 30: Creating a Simple Template Class
Technique 31: Extending a Template Class
Implementing Template Classes in Code
Testing the Template Classes
Using Non-class Template Arguments
Technique 32: Creating Templates from Functions and Methods
Implementing Function Templates
Creating Method Templates
Technique 33: Working with Arrays
Using the Vector Class
Technique 34: Implementing Your Own Array Class
Creating the String Array Class
Technique 35: Working with Vector Algorithms
Working with Vector Algorithms
Technique 36: Deleting an Array of Elements
Examining Allocations of Arrays and Pointers
Technique 37: Creating Arrays of Objects
Technique 38: Working with Arrays of Object Pointers
Creating an Array of Heterogeneous Objects
Technique 39: Implementing a Spreadsheet
Creating the Column Class
Creating the Row Class
Creating the Spreadsheet Class
Testing Your Spreadsheet
Part VI: Input and Output
Technique 40: Using the Standard Streams to Format Data
Working with Streams
Technique 41: Reading In and Processing Files
Testing the File-Reading Code
Creating the Test File
Technique 42: How to Read Delimited Files
Reading Delimited Files
Testing the Code
Technique 43: Writing Your Objects as XML
Creating the XML Writer
Testing the XML Writer
Technique 44: Removing White Space from Input
Technique 45: Creating a Configuration File
Creating the Configuration-File Class
Setting Up Your Test File
Testing the Configuration-File Class
Part VII: Using the Built-In Functionality
Technique 46: Creating an Internationalization Class
Building the Language Files
Creating an Input Text File
Reading the International File
Testing the String Reader
Technique 47: Hashing Out Translations
Creating a Translator Class
Testing the Translator Class
Technique 48: Implementing Virtual Files
Creating a Virtual File Class
Testing the Virtual File Class
Improving Your Virtual File Class
Technique 49: Using Iterators for Your Collections
Technique 50: Overriding the Allocator for a Collection Class
Creating a Custom Memory Allocator
Technique 51: Using the auto_ptr Class to Avoid Memory Leaks
Using the auto_ptr Class
Technique 52: Avoiding Memory Overwrites
Creating a Memory Safe Buffer Class
Technique 53: Throwing, Catching, and Re-throwing Exceptions
Throwing and Logging Exceptions
Dealing with Unhandled Exceptions
Re-throwing Exceptions
Technique 54: Enforcing Return Codes
Technique 55: Using Wildcards
Creating the Wildcard Matching Class
Testing the Wildcard Matching Class
Part VIII: Utilities
Technique 56: Encoding and Decoding Data for the Web
Creating the URL Codec Class
Testing the URL Codec Class
Technique 57: Encrypting and Decrypting Strings
Implementing the Rot13 Algorithm
Testing the Rot13 Algorithm
Implementing the XOR Algorithm
Testing the XOR Algorithm
Technique 58: Converting the Case of a String
Implementing the transform Function to Convert Strings
Testing the String Conversions
Technique 59: Implementing a Serialization Interface
Implementing the Serialization Interface
Testing the Serialization Interface
Technique 60: Creating a Generic Buffer Class
Creating the Buffer Class
Testing the Buffer Class
Technique 61: Opening a File Using Multiple Paths
Creating the Multiple-Search-Path Class
Testing the Multiple-Search-Path Class
Part IX: Debugging C++ Applications
Technique 62: Building Tracing into Your Applications
Implementing the Flow Trace Class
Testing the Flow Trace System
Adding in Tracing After the Fact
Technique 63: Creating Debugging Macros and Classes
The assert Macro
Logging
Testing the Logger Class
Design by Contract
Technique 64: Debugging Overloaded Methods
Adding Logging to the Application
Part X: The Scary (or Fun!) Stuff
Technique 65: Optimizing Your Code
Making Functions Inline
Avoiding Temporary Objects
Passing Objects by Reference
Postponing Variable Declarations
Choosing Initialization Instead of Assignment
Technique 66: Documenting the Data Flow
Learning How Code Operates
Testing the Properties Class
Technique 67: Creating a Simple Locking Mechanism
Creating the Locking Mechanism
Testing the Locking Mechanism
Technique 68: Creating and Using Guardian Classes
Creating the File-Guardian Class
Testing the File-Guardian Class
Technique 69: Working with Complex Numbers
Implementing the Complex Class
Testing the Complex Number Class
Technique 70: Converting Numbers to Words
Creating the Conversion Code
Testing the Conversion Code
Technique 71: Reducing the Complexity of Code
A Sample Program
Componentizing
Restructuring
Specialization
Index
Team DDU