Variable and Watch windows

Windows that display variables come in several different varieties:

• Locals
• File Variables
• Watches
• Variable

They're collectively called variable windows. You use the same interactions in all variable windows to display, modify, and browse your variables and data structures. The only difference between these windows is the variables they display. The values in each window are updated as you trace through your program. The windows display the following information:

Locals

Contains the list of variables local to the current routine. Choose Locals from the Data menu to open this window.

File Variables

Contains a list of all variables defined at file scope in the current module. This includes external and static symbols. Choose File Variables from the Data menu to open this window.

Watches

The Watches window allows you to add and delete variables and expressions. In other windows you can choose Watch. This opens the Watches window, and adds to it the text that's selected in another window. Use the New item in the context-sensitive or Action menu to add any expression to the Watches window. Once entered, you can choose Edit to edit the expressions or typecast the variables.

Variable

This is another instance of a Watches window. A variable window is created when you select a variable or expression in a window and use the Inspect command.

Each line of a variable window has three elements. On the left is a button. The button changes, depending on the type of the variable or expression:

structs (classes) (unions)

Structures may be opened and closed by clicking on the button at the left. When you open a structure or class, one line is added to the window for each field of the structure. These new lines are indented. If you click on the button again, the structure is closed, and the window is returned to its original state.

arrays

Like structures, arrays may be opened and closed. When you open an array, one line is added to the window for each element of the array. The debugger displays at most 1000 elements of an array. If it contains more, you can use the Type/Array... to open different ranges. Multi-dimensional arrays are treated like an array of arrays. When you open the first dimension, the lines that are added are also arrays that you can open.

pointers

When the variable is a pointer, you can click on the button. The debugger follows the pointer and changes the line to represent the item that's the result of the pointer reference. For example, if you have a pointer to an integer, and you click on the button, the integer value is displayed. The button then changes to indicate that you can undo the operation by clicking on it again.

In the case of pointers to pointers, clicking on the button follows the pointers one level each time you click, until a non-pointer value is reached. Clicking on the button at this point takes you back to the original state. When the pointer points to a structure, it's automatically opened when you click on the button. If a pointer is really an array, you can use Type/Array... to open it as an array.

Next comes the name of the variable, field, or array element being displayed. Finally, the value is displayed. If the item being displayed isn't a scalar item, the value displayed is an indication that it's a complex data type. If the value changes when you run your program, it's highlighted. If a variable goes out of scope, or a pointer value becomes invalid, the value appears as question marks.

To modify a variable's value, double-click on the value field, or cursor to it and press Enter. Double-clicking or pressing Enter on the name field is equivalent to clicking on the button. Press the right mouse button to access the following popup menu items:

Modify...

Modify the value of the selected item.

Inspect

Open a new Variable window containing the selected item. If the item is a compound object (array, class, or structure), it's opened automatically.

Break

Set a breakpoint so that execution stops when the selected item's value changes. This is the same as setting a breakpoint on the object. See the Breakpoints chapter.

Edit

Open a dialog box in which you can edit an expression in the Watch window. This is useful for typecasting variables or evaluating expressions. See the Expression Handling chapter.

New

Add a new variable or expression to the window. You're prompted for the expression to add.

Delete

Delete the selected item from the window.

Root

When the selected item is a field of a structure or an element of an array, this menu item moves the currently selected item to the parent of that item. For example, if you are examining sym->field1->field2, Root changes the current selection to sym->field1. If you're examining a deeply nested field, use Root repeatedly to find the originating expression.

Type/Hex

Change the value to be displayed in hexadecimal.

Type/Decimal

Change the value to be displayed in decimal.

Type/Character

Change the value to be displayed as a single character constant. This is useful when you have a one-byte variable that really contains a character. The debugger often displays it as an integer by default.

Type/String

The debugger automatically detects pointers to strings in the variable windows and displays the string rather than the raw pointer value. If the string isn't null-terminated, contains non-printable characters, or isn't typed as a pointer to char, this mechanism doesn't work. Type/String overrides the automatic string detection and displays the pointer as a string regardless of its type.

Type/Pointer

This undoes the effects of Type/String or Type/Array. It also lets you see the raw pointer value when the debugger has automatically displayed a pointer to char as a string.

Type/Array...

Use this menu item to display a pointer as if it were an array, or to display ranges of an array's elements. You're prompted for the first and last element to display.

Show/Raw Memory

Display raw memory at the address of this variable. This lets you examine the actual binary representation of a variable.

Show/Pointer Memory

Display the memory that the item points to. This is useful when you have a pointer to a block of memory that doesn't have a type associated with it.

Show/Pointer Code

Display the code that the variable points to. If the item being displayed is a pointer to function, you can use this menu item to see the definition of that function.

Options

This menu contains the same options found in the section ``Variables Options'' in the Debugger Environment chapter. This menu item sets options on a per-window basis, overriding the global settings. When you use the menu item to change these settings, they aren't saved between debugging sessions. To change an option permanently, see the ``Window Options Dialog'' in the Debugger Environment chapter.