6.13. Debugging Functions

All but the most trivial programs contain many functions beyond main. It's easy for programmers, reading their own code, to overconfidently assert when a program calls a function and exactly what argument values it passes. Increasing the program's size, spreading functions across many files, and calling them in branches and loops amplifies the uncertainty.

Function bodies are blocks that can contain any valid C++ statement. Consequently, they are susceptible to the full spectrum of programming errors described previously. However, they share a complicating characteristic with branches and loops: program execution paths enter and exit them. So, when programmers debug functions, it's important to know when the program enters them, when it exits, and what it does while inside. Manual instrumentation can provide this information but not with as much flexibility and control as a debugger.

Manually Instrumenting Functions

Functions and the programs using them are too varied to prescribe a rigid instrumenting algorithm. Nevertheless, some broad patterns dominate the process. When debugging functions, the information programmers need to locate and correct an error depends on which kind of error the function harbors. Run-time errors "crash" (abnormally terminate) a program, so locating the function and the statement in the function that causes the error is the first step. Once the bracketing process has narrowed the search, programmers treat the problem as a logical error.

Locating and correcting a logical error typically involves tracking values through the program's operations and comparing them to the corresponding manually-calculated values. The comparison includes the values passed to the function's parameters and to any value it returns. The following figure uses pseudocode to outline the basic debugging patterns and illustrates some common options.

...

cerr << "calling f1 " << endl;		// i
f1(a1, a2);
cerr << "Returned from f1 " << endl;	// ii

...

int calc = f2(a3, a4);
cerr << "f2: calc = " << calc << endl;	// iii

...

void f1(p1, p2)
{
    cerr << "Entering f1 " << p1 << " " << p2 << endl;
    ...
    cerr << "Exiting f1" << endl;
}

int f2(p3, p4)
{
    cerr << __FILE__ << " " << __LINE__ << " " p3 << " " << p4 << endl;
    ...
    int r = ...;							// iv
    cerr << __FILE__ << " " << __LINE__ << " " << r << endl;
    return r;								// v
}

Manually instrumenting functions works but is inefficient and inelegant. Nevertheless, it makes a debugger's operations more concrete and engenders a deeper appreciation of its contributions to software development.

Functions And The Debugger

Functions can contain any valid C++ statement, implying that all previously described debugger operations (please see the "Review" section at the top of the page) are helpful when debugging functions. However, the stepping operations (introduced with debugging loops) are particularly helpful with functions. Although stepping controls and terminology vary across tools, the operations are typical of all modern debuggers. Once you learn what they do, you can learn how to perform the operations by consulting the tool-specific documentation.

The debugger becomes increasingly helpful as programs grow in size and complexity. Debugging is a dynamic process: information gleaned from one location informs programmers about the next location and the next value to examine. When debugging with manually inserted instrumentation, this dynamic, ever-shifting focus requires programmers to insert and remove instrumentation and rebuild the program to examine each new location. A modern debugger eases the problem by letting programmers add and remove breakpoints and tracepoints, evaluate any expression, or restart the program without rebuilding it. The following figure uses a simple program to explore different scenarios and demonstrate strategies using stepping operations.

int main()
{
    function1();			// (i)
    cout << function2() << endl;	// (ii)
    cout << function3() << endl;	// (iii)

    return 0;
}

void function1()
{					// (iv)
    cout << "function1" << endl;	// (v)
}					// (vi)

int function2()
{					// (vii)
    cout << "function2" << endl;	// (viii)
    return 10;				// (ix)
}					// (x)

int function3()
{					// (xi)
    cout << "function3" << endl;	// (xii)
    return function2();			// (xiii)
}					// (xiv)