C++ Timesaving Techniques For Dummies
Seasoned C++ programmer Matthew Telles shows developers at any level of experience how to save hours by improving, refactoring, and debugging their codeSome 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 complexityThe easy-to-follow, two-column Timesaving Techniques format makes mastering each timesaver a snapC++ is one of today's most widely used programming languages, with compilers offered by Microsoft, Borland, and Code WarriorThis book is the perfect companion to C++ For Dummies, Fifth Edition (0-7645-6852-3)
- Electronic book text | 499 pages
- 04 Mar 2005
- John Wiley & Sons Inc
- FOR DUMMIES
- United States
- 1st edition
- Drawings: 25 B&W, 0 Color
Table of contents
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.
About Matthew A. Telles
Matthew Telles is a 20-year veteran of the software-development wars. In his time, he has seen FORTRAN, COBOL, and other dinosaur languages come and go. Currently a senior software engineer for Research Systems, Inc., his days are spent finding and fixing bugs that other people have created. Besides trying to be tactful, he also enjoys working with other developers to teach the techniques he has mastered over his career. With expertise in programming, designing, documenting, and debugging applications, he has reached the pinnacle of a programmer's existence: the ability to write his own bio blurbs for books. He is the author of seven other programming books.