Debugging Windows Programs: Strategies, Tools, and Techniques for Visual C++ Programmers (DevelopMentor Series) (Paperback)

by Everett N. McKay (Author), Mike Woodring (Author)

Editorial Reviews

Amazon.com Review
Debugging Windows Programs: Strategies, Tools, and Techniques for Visual C++ Programmers sounds like it might focus on using a debugger exclusively, but this book is actually a wide-ranging tour of how to write better, more robust Visual C++ code that can be debugged more easily. Mixing plenty of nuts-and-bolts tips with higher-level strategies for effective testing, Debugging Windows Programs offers plenty of valuable expertise for any working C++ programmer.

The focus is on providing practical tips for more successful debugging, but many of the suggestions are for tweaking the way in which you write C++ code. Early sections examine how to take full advantage of assert statements (whether in C, MFC, or custom functions), which can be used to write safer code; trace statements, which are used to log debug messages, are covered, too. (Chances are that you haven't seen all of the APIs; luckily, they're rounded up for you here.) There are also numerous tips about C++ style, like how to choose readable variable names, along with the debugging dos and don'ts of working with errors, exceptions, COM objects, and threads.

Chances are, even if you are an experienced Visual C++ programmer, you'll learn something useful about how to get more out of the C++ debugger from the last sections of this book. From the right compiler and linker switches (which can be mysterious) to how to customize watch variables by tweaking the configuration files in C++, you'll learn how to be more productive with this tool. The text concludes with another useful section, an FAQ-style listing of dozens of common debugging questions and answers.

Although it's highly practical, the book also recommends thinking about your code, applying strategies for each aspect of debugging features consistently and effectively. The bottom line is that you not only will find bugs in present code, but also you'll design code that's easier to test and debug in the future. In all, Debugging Windows Programs delivers a good mix of practical tips and strategies that'll help C++ programmers create more robust (and testable) code. --Richard Dragan

Topics covered:

The debugging and testing process Tips for writing better Visual C++ code Assertions (C, MFC, and custom assert statements) Logging output with trace statements (including trace APIs) Exception handling and debugging First-chance and last-chance exceptions Tips for better debugging in C++ Naming conventions Postmortem Just-in-time (JIT) and remote debugging

Using map and .pdb files Compiler and linking options Debug windows Customizing the C++ debugging environment Basic and advanced debugging techniques Catching memory leaks with the debug heap Debugging multithreaded programs (including avoiding race conditions and deadlock) A primer for COM debugging Frequently asked questions and answers about debugging

Product Description
(Pearson Education) Shows readers how to prevent bugs by taking advantage of the Visual C++ development tools and writing code in a way that makes certain types of bugs impossible. Provides specific solutions to the most common debugging problems. Softcover. DLC: Debugging in computer science.

See all Editorial Reviews

Product Details

• Paperback: 592 pages
• Publisher: Addison-Wesley Professional (August 28, 2000)
• Language: English
• ISBN-10: 020170238X
• ISBN-13: 978-0201702385
• Product Dimensions: 9 x 7.4 x 1.5 inches
• Shipping Weight: 2.1 pounds (View shipping rates and policies)
• Average Customer Review: 4.5 out of 5 stars See all reviews (13 customer reviews)
• Amazon.com Sales Rank: #632,395 in Books (See Bestsellers in Books)

  Popular in these categories: (What's this?)

  #25 in	Books > Computers & Internet > Programming > Languages & Tools > Visual C++
  #36 in	Books > Computers & Internet > Programming > Languages & Tools > Debugging

Customer Reviews

Most Helpful Customer Reviews

14 of 14 people found the following review helpful:

5.0 out of 5 stars "must have" for general debugging, April 8, 2002

By	developer (England) - See all my reviews

In my experience, programmers fall into two categories: general (majority) and advanced (few); advanced ones understanding register and stack dumps etc, general ones being lost. This book covers the more general programmer, Robbins book the advanced. Comparing the two, you could write your own debugger and your own "core" dumps (which you can then examine) from Robbins book; with this one you can't, but it covers useful stuff missing from Robbins book (eg. PE format, address space partitioning). As such they have some overlap but supplement each other. Both books are essential to serious developers. I have one gripe with this and Robbins book: neither suggests outputting the mixed source/assembly/machine_code (.COD files); these are essential (without a .PDB) if a crash occurs so that the offending instruction etc. can be found, as many instructions usually follow a line of source; secondly, function locals only show in .CODs (as offsets from EBP) so making them easy to locate on a stack trace.

12 of 12 people found the following review helpful:

5.0 out of 5 stars Bugs? My codes only have features..., September 5, 2000

By	Min Kim (Laurel, MD) - See all my reviews

This book should have been included with the MS Visual C++ documentation. If you can say "My code doesn't have bugs, only features," then you may skip this book. I found this book full of tips and tricks and secrets of visual c++ debugging. Just by having this book on your side, you will save hours and hours of frustration trying to find that one line that's keeping you from going home.
Beginning few chapters are basic debugging knowledge every visual C++ programmers should be aware of. It explains more of 'preventive' programming styles so that you notice your bugs before your customers. Various topics including assert and compiler options are well explained, much better than the ones you would find in the vc++ documentation.
I was happy to finally see some explanation on Dr. Watson messages. In Chapter 6: Debugging with Windows, Woodring and McKay explains all the precious information buried in those memory dumps that we often ignore. After all, all those hexadecimal numbers got to mean something, right?
If you have been always unsure about your multithread knowledge, this book contains a good section on multithread programming issues and how to monitor your threads from the debugger.
And for those who can't sleep at night because of some odd bug buried in thousands of lines of code, I recommend jumping right into Chapter 12: Desperate Measures. You are probably too frustrated to think straight now. Let this book help you calm down and look through your code step by step. This chapter simply provides a code checking checklist that you should probably copy down and tape it to your monitor.
For those of you that are starting a fresh batch of code and thinking about buying this book, my recommendation is to read this book first, then code. You'll be a lot happier later. And for those of you that have already written a few million lines of code and trying to debug, you can apply some of the techniques found in this book to build up confidence in your code. I suppose if you live dangerously ("Just let 'er rip and hope for the best"), then most of the things explained in this book will only seem annoying to you, but I'm sure most of you programmers out there would like to know a few neat debugging tricks to show off in front of your co-workers.

10 of 10 people found the following review helpful:

5.0 out of 5 stars An invaluable book  packed with immediately useful macros, September 23, 2000

By	"awcoats" (Royal Oak, Michigan United States) - See all my reviews

The vast majority of recommendations are so simple, yet so effective. Even if you only read random sections of this book, it will be of immediate benefit. This book in conjunction with John Robbin's book (Debugging Applications) are invaluable in not just giving you tips on how to find bugs but much more importantly how to code defensively to reduce the chances of bugs occurring in the first place.

As the authors mention in the preface, they are not many original ideas in the book - but it is a good consolation of publicly available information. The book adds value by explaining when to use certain techniques and when to use others e.g. Chapter 5 -Using exceptions vs. return values.

Because the book is specifically geared to C++ programmers there are some fantastic macros. For instance _CoCreateServer which wraps CoCreateInstance but gives detailed error information if anything goes wrong. Chapter 9 - Debugging Memory was particularly useful. Being able to detect leaking memory in ATL components (just like MFC does) was worth the price of the book alone.

My only criticism is the use of the Arial font which makes the book a little getting used to seeing on the printed page.