Debugging Windows Programs: Strategies, Tools, and Techniques for Visual C++ Pro
Everett N. McKay, Mike Woodring
For professional software developers, debugging is a way of life. This book is the definitive guide to Windows debugging, providing developers with the strategies and techniques they need to fulfill one of their most important responsibilities efficiently and effectively.
Debugging Windows Programs shows readers how to prevent bugs by taking full advantage of the Visual C++ development tools and writing code in a way that makes certain types of bugs impossible. They also will learn how to reveal bugs with debugging statements that force bugs to expose themselves when the program is executed, and how to make the most of debugging tools and features available in Windows, Visual C++, MFC, and ATL. The authors provide specific solutions to the most common debugging problems, including memory corruption, resource leaks, stack problems, release build problems, finding crash locations, and multithreading problems.
These essential topics are covered:
- The debugging process
- Writing C++ code for debugging
- Strategically using assertions, trace statements, and exceptions
- Windows postmortem debugging using Dr. Watson and MAP files
- Using the Visual C++ debugger
- Debugging memory
- Debugging multithreaded programs
- Debugging COM
Each chapter provides developers with exactly what they need to master the subject and improve development productivity and software quality.
Comprehensive, current, and practical, Debugging Windows Programs helps developers understand the debugging process and make the most of the Visual C++ debugging tools.
Table of Contents
Answers to Frequently Asked Questions.
I. DEBUGGING STRATEGIES.
1. The Debugging Process.The Five (Wrong) Stages of Debugging.
The Five Stages of Debugging.
Determining That a Bug Exists.
Gathering Bug Information.
Analyzing the Bug Information.
Removing the Bug.
Verifying the Change.
Debug Smarter, Not Harder.
2. Writing C++ Code for Debugging.Design.
C++ Programming Style.
The C++ Language.
The Visual C++ Compiler.
3. Using Assertions.The Limitations of Assertions.
Types of Assertions.
More MFC Assertion Macros.
Document Your Assertions.
4. Using Trace Statements.Types of Trace Statements.
Custom Trace Statements.
Trace Statement Strategies.
5. Using Exceptions and Return Values.Incorrect Error Handling Results in Bugs.
The Need for a Strategy.
Using Return Values.
Exceptions and Bugs.
C++ Exceptions versus Windows Structured Exception Handling.
Translating Structured Exceptions to C++ Exceptions.
Defensive Programming with Exceptions.
II. DEBUGGING TOOLS.
6. Debugging with Windows.Postmortem Debugging.
Windows API Error Codes.
Windows Exception Basics.
Portable Executable Basics.
Assembly Language Basics.
Debugging with MAP Files.
Debugging with PDB Files.
Debugging Using a Windows 98 Crash Dialog Box.
Debugging Using Dr. Watson.
7. Debugging with the Visual C++ Debugger.Compiler and Linker Options.
Debug versus Release Builds.
Debugging Release Builds.
The Test Build.
The Debug Windows.
Registers and Pseudo-registers.
Watch Window Formatting Symbols.
Debugging with Breakpoints.
Debugging with Edit and Continue.
III. DEBUGGING TECHNIQUES.
8. Basic Debugging Techniques.General Debugging Techniques.
Visual C++ Debugger Techniques.
Windows Debugging Techniques.
MFC Debugging Techniques.
9. Debugging Memory.Why Memory Leaks Aren't Acceptable.
Types of Memory Debugging.
Using the Debug Heap.
How the Debug Heap Works.
Reading Windows Memory Addresses.
Debugging Memory Corruption.
Debugging Memory Leaks.
Debugging Windows Resource Leaks.
Debugging Windows Thread Stacks.
10. Debugging Multithreaded Programs.What Is Multithreading?
Issues in Multithreaded Programs.
Writing Thread-safe Code.
Thread Creation and Termination.
Understanding the Debugger.
11. COM Debugging.Chapter Basics.
Defensive COM Programming Practices.
Debugging Base COM DLLs.
Debugging Base COM EXEs.
Debugging Configured Components.
Debugging Base COM DLLs That Are Called From ASPs.
12. Desperate Measures.Checking the Easy Stuff.
Using Your Head.
Rechecking Your Assumptions.
Checking the Obvious.
Checking the Code.
Checking the System.
Double-Checking the Documentation.
Using Other People.
Stop Living Dangerously.