Introduction
Debugging is a major part of the development lifecycle. Sometimes challenging, sometimes puzzling, sometimes annoying, one for sure - it is unavoidable for any not-so-trivial program. The progress of debugging tools over the last years has made many debugging tasks much easier and less time-consuming.
This article summarizes 10 debugging tricks and techniques that can save you a lof of time when using Visual Studio.
1. Hover mouse to evaluate expression
Debugging can be challenging. Stepping through a function to
understand what went wrong, looking through the call stack to
see where did that value come from... In either case adding
watch expressions or looking through a list of locals can take
quite a time. However, things get easier if you just point your
mouse at a variable of interest. Moreover, classes and
structures will be expanded with one click, allowing to find the
field you need quickly and conveniently.
2. Change values on-the-fly
Debugger is much more than a tool for analyzing crashes and
wierd behavior. Many bugs can be prevented by stepping through a
freshly written function and checking that it behaves as
expected. Sometimes you are curious "would the function behave
correctly if this condition was true?". And in most cases it
does not mean changing the code and restarting. Just hover the
mouse over a variable, double-click at the value and type in the
new one!
3. Set next statement
One typical debugging scenario is analyzing why does a
function call fail by going through the function step-by-step.
And what do you do when you've just discovered that a function
called another function that returned an error? Restart
debugging? There's a better idea: just drag the yellow statement
marker to the line you want to be executed next, like the
function that has just failed, and then simply step in. Simple,
isn't it?
4. Edit and continue
Debugging a complex program, or a plugin? Found an error, but don't want to lose time stopping, rebuilding and restarting again and the function is called too often to use the previous trick each time? No problem, just fix the bug in-place and continue stepping. Visual Studio will modify your program and continue debugging with no need to restart.
5. A convenient watch window
Probably, every modern debugger has a watch window. However,
what's really cool about the Visual Studio one is how easy you
can add and remove variables there. Just click at the empty
line, type your expression and press Enter. Or simply press
delete button to remove an expression that is no longer needed.
6. Annotated disassembly
Optimizing the performance of the critical parts of your
program can be much easier using the interactive disassembly
mode. Visual Studio shows you the instructions corresponding to
every line of your code and allows running the code
step-by-step, as well as setting breakpoints at arbitrary
locations. And, of course, the expression evaluation and
modification will work just like for the C++ code.
7. Threads window with stacks
Debugging multi-threaded applications can
be painful. Or it can be fun. Depends on your debugger. One
really nice feature of Visual Studio 2010 is the stack view in
the threads window. You can get a convenient overview of all
your threads and navigate through their call stacks directly
from the window.
8. Conditional breakpoints
If you're trying to reproduce a rare event and getting too many
false positives with your breakpoints, you can easily make them
conditional! Simply specify the condition for a breakpoint and
Visual Studio will automatically ignore the breakpoint when the
condition does not hold.
9. Memory window
Some bugs are caused by incorrect
structure definitions, missing alignment attributes, etc. Seeing
the raw memory contents simplifies locating and fixing those
bugs. Visual Studio features a convenient memory window that can
interpret the values as 8/16/32/64-bit numbers, as well as
floating-point numbers and allows changing them on-the-fly by
simply typing the new values over the old ones like in a text
editor.
10. Go To Definition
One last feature to mention is not
directly related to debugging, rather to exploring big projects. If you are trying to find a bug in some code you have not written yourself, having a quick answer to "what is this type" or "what does this function do" can save you a lot of time. And Visual Studio does this with ease via the Go To Definition command.