3.6 — Using an integrated debugger: Stepping

In this lesson, you'll learn how to use integrated debugger tools to step through your code execution line by line. This is one of the most powerful debugging techniques available and allows you to see exactly what your program is doing at each step.

What is an integrated debugger?

An integrated debugger is a tool built into your development environment (IDE) that allows you to:

• Pause program execution at specific points
• Step through code line by line
• Examine variable values at any point
• Understand the flow of your program
• Identify where bugs occur

Popular IDEs with integrated debuggers include:

• Visual Studio (Windows)
• Visual Studio Code (Cross-platform)
• Code::Blocks (Cross-platform)
• CLion (Cross-platform)
• Xcode (macOS)
• Eclipse CDT (Cross-platform)

Understanding stepping modes

Debuggers typically offer several stepping modes:

Step Into (F11)

Enters into function calls to debug the internals of called functions.

Step Over (F10)

Executes the current line but doesn't enter into function calls.

Step Out (Shift+F11)

Continues execution until the current function returns.

Continue (F5)

Continues execution until the next breakpoint.

Let's explore these with examples:

Setting up for debugging

First, you need to compile your program with debug information:

# Compile with debug symbols
g++ -g -o debug_program program.cpp

# For more comprehensive debugging info
g++ -g -O0 -o debug_program program.cpp

The -g flag includes debug symbols, and -O0 disables optimizations that might make debugging confusing.

Example: Stepping through a simple program

#include <iostream>

// Simple function to demonstrate stepping
int multiply(int a, int b)
{
    std::cout << "Inside multiply function" << std::endl;  // Step 1
    int result = a * b;                                    // Step 2
    std::cout << "Calculated: " << result << std::endl;   // Step 3
    return result;                                         // Step 4
}

int add(int x, int y)
{
    std::cout << "Inside add function" << std::endl;      // Step 1
    int sum = x + y;                                       // Step 2
    return sum;                                            // Step 3
}

int main()
{
    std::cout << "Program starting" << std::endl;         // Step 1
    
    int a = 5;                                             // Step 2
    int b = 3;                                             // Step 3
    
    std::cout << "About to call multiply" << std::endl;   // Step 4
    int product = multiply(a, b);                          // Step 5 (Step Into vs Step Over)
    
    std::cout << "About to call add" << std::endl;        // Step 6
    int sum = add(product, 10);                            // Step 7 (Step Into vs Step Over)
    
    std::cout << "Final result: " << sum << std::endl;    // Step 8
    
    return 0;                                              // Step 9
}

Stepping demonstration

Debugger Session Walkthrough:

1. Set breakpoint at line: std::cout << "Program starting" << std::endl;
2. Start debugging (F5)
3. Program stops at breakpoint

Step-by-step execution:
┌─────────────────────────────────────────────────────────────┐
│ Step Over (F10) through main():                            │
├─────────────────────────────────────────────────────────────┤
│ 1. → std::cout << "Program starting" << std::endl;         │
│      Output: "Program starting"                            │
│                                                             │
│ 2. → int a = 5;                                             │
│      Variable 'a' now equals 5                             │
│                                                             │
│ 3. → int b = 3;                                             │
│      Variable 'b' now equals 3                             │
│                                                             │
│ 4. → std::cout << "About to call multiply" << std::endl;   │
│      Output: "About to call multiply"                      │
│                                                             │
│ 5. → int product = multiply(a, b);                          │
│      Choice: Step Into (F11) or Step Over (F10)?          │
└─────────────────────────────────────────────────────────────┘

If you choose Step Into (F11):
┌─────────────────────────────────────────────────────────────┐
│ Inside multiply() function:                                │
├─────────────────────────────────────────────────────────────┤
│ 1. → std::cout << "Inside multiply function" << std::endl; │
│      Output: "Inside multiply function"                    │
│                                                             │
│ 2. → int result = a * b;                                    │
│      result = 5 * 3 = 15                                   │
│                                                             │
│ 3. → std::cout << "Calculated: " << result << std::endl;   │
│      Output: "Calculated: 15"                              │
│                                                             │
│ 4. → return result;                                         │
│      Returns 15 to caller                                  │
│                                                             │
│ 5. Back in main(), product now equals 15                   │
└─────────────────────────────────────────────────────────────┘

If you choose Step Over (F10):
┌─────────────────────────────────────────────────────────────┐
│ multiply(a, b) executes completely:                        │
├─────────────────────────────────────────────────────────────┤
│ Output: "Inside multiply function"                         │
│ Output: "Calculated: 15"                                   │
│ product = 15                                                │
│ → Next line: std::cout << "About to call add" << std::endl;│
└─────────────────────────────────────────────────────────────┘

Advanced stepping example with recursion

#include <iostream>

// Recursive function to demonstrate advanced stepping
int factorial(int n)
{
    std::cout << "factorial(" << n << ") called" << std::endl;
    
    if (n <= 1)
    {
        std::cout << "Base case: returning 1" << std::endl;
        return 1;
    }
    
    std::cout << "Recursive case: " << n << " * factorial(" << (n-1) << ")" << std::endl;
    int result = n * factorial(n - 1);
    
    std::cout << "factorial(" << n << ") returning " << result << std::endl;
    return result;
}

void demonstrateRecursiveStepping()
{
    std::cout << "=== Recursive Stepping Demo ===" << std::endl;
    int value = 4;
    
    std::cout << "Calculating factorial of " << value << std::endl;
    int result = factorial(value);
    std::cout << "Final result: " << result << std::endl;
}

/*
Stepping through factorial(4):

Call Stack Visualization:
┌─────────────────────────────────────────────────────────────┐
│ Step Into trace for factorial(4):                          │
├─────────────────────────────────────────────────────────────┤
│ 1. factorial(4) called                                     │
│    → n = 4, not base case                                  │
│    → About to call factorial(3)                            │
│                                                             │
│ 2. factorial(3) called (Step Into)                         │
│    → n = 3, not base case                                  │
│    → About to call factorial(2)                            │
│                                                             │
│ 3. factorial(2) called (Step Into)                         │
│    → n = 2, not base case                                  │
│    → About to call factorial(1)                            │
│                                                             │
│ 4. factorial(1) called (Step Into)                         │
│    → n = 1, BASE CASE!                                     │
│    → Returns 1                                             │
│                                                             │
│ 5. Back in factorial(2): result = 2 * 1 = 2               │
│    → Returns 2                                             │
│                                                             │
│ 6. Back in factorial(3): result = 3 * 2 = 6               │
│    → Returns 6                                             │
│                                                             │
│ 7. Back in factorial(4): result = 4 * 6 = 24              │
│    → Returns 24                                            │
└─────────────────────────────────────────────────────────────┘

Using Step Out (Shift+F11):
- If you're inside factorial(1) and press Step Out
- Debugger continues until factorial(1) returns
- Stops at the line after the function call in factorial(2)
*/

int main()
{
    demonstrateRecursiveStepping();
    return 0;
}

Debugging loops with stepping

#include <iostream>
#include <vector>

void demonstrateLoopStepping()
{
    std::cout << "=== Loop Stepping Demo ===" << std::endl;
    
    std::vector<int> numbers = {2, 4, 6, 8, 10};
    int sum = 0;
    
    std::cout << "Calculating sum of even numbers" << std::endl;
    
    // Loop to step through
    for (size_t i = 0; i < numbers.size(); ++i)  // Breakpoint here
    {
        std::cout << "Processing index " << i << " (value: " << numbers[i] << ")" << std::endl;
        sum += numbers[i];
        std::cout << "Current sum: " << sum << std::endl;
    }
    
    std::cout << "Final sum: " << sum << std::endl;
}

/*
Loop Stepping Strategy:

1. Set breakpoint on the for loop line
2. Use Step Over (F10) to stay at the loop level:
   ┌─────────────────────────────────────────────┐
   │ Iteration 1: i = 0, numbers[0] = 2         │
   │ → sum = 0 + 2 = 2                          │
   ├─────────────────────────────────────────────┤
   │ Iteration 2: i = 1, numbers[1] = 4         │
   │ → sum = 2 + 4 = 6                          │
   ├─────────────────────────────────────────────┤
   │ Iteration 3: i = 2, numbers[2] = 6         │
   │ → sum = 6 + 6 = 12                         │
   ├─────────────────────────────────────────────┤
   │ And so on...                               │
   └─────────────────────────────────────────────┘

3. To skip remaining iterations: Set breakpoint after loop, then Continue (F5)
4. To examine specific iteration: Step Into (F11) on that iteration
*/

int main()
{
    demonstrateLoopStepping();
    return 0;
}

Finding bugs with stepping

Here's how stepping helps identify a common bug:

#include <iostream>
#include <vector>

// Bug: This function should find the index of the maximum element
int findMaxIndex(const std::vector<int>& arr)
{
    if (arr.empty())
        return -1;
    
    int maxIndex = 0;
    int maxValue = arr[0];
    
    // Bug is hidden in this loop - stepping will reveal it
    for (size_t i = 1; i < arr.size(); ++i)  // Set breakpoint here
    {
        std::cout << "Checking index " << i << " (value: " << arr[i] << ")" << std::endl;
        
        if (arr[i] > maxValue)
        {
            maxValue = arr[i];
            // BUG: Forgot to update maxIndex!
            // maxIndex = i;  <-- This line is missing
            std::cout << "New max value: " << maxValue << std::endl;
        }
    }
    
    std::cout << "Returning index: " << maxIndex << " (value: " << arr[maxIndex] << ")" << std::endl;
    return maxIndex;
}

void demonstrateBugFinding()
{
    std::cout << "=== Bug Finding with Stepping ===" << std::endl;
    
    std::vector<int> testArray = {3, 7, 2, 9, 1};
    
    std::cout << "Array contents: ";
    for (size_t i = 0; i < testArray.size(); ++i)
    {
        std::cout << "[" << i << "]=" << testArray[i] << " ";
    }
    std::cout << std::endl;
    
    int maxIdx = findMaxIndex(testArray);
    std::cout << "Maximum element is at index: " << maxIdx << std::endl;
    std::cout << "Expected: 3 (value 9), Got: " << maxIdx << " (value " << testArray[maxIdx] << ")" << std::endl;
}

/*
Stepping reveals the bug:

Step-by-step through the loop:
┌─────────────────────────────────────────────────────────────┐
│ Initial state:                                              │
│ maxIndex = 0, maxValue = 3                                  │
├─────────────────────────────────────────────────────────────┤
│ i = 1: arr[1] = 7                                          │
│ 7 > 3? YES                                                 │
│ maxValue = 7                                                │
│ maxIndex = ??? (BUG: still 0, should be 1)                │
├─────────────────────────────────────────────────────────────┤
│ i = 2: arr[2] = 2                                          │
│ 2 > 7? NO                                                  │
│ No change                                                   │
├─────────────────────────────────────────────────────────────┤
│ i = 3: arr[3] = 9                                          │
│ 9 > 7? YES                                                 │
│ maxValue = 9                                                │
│ maxIndex = ??? (BUG: still 0, should be 3)                │
├─────────────────────────────────────────────────────────────┤
│ Result: maxIndex = 0, but maxValue = 9                     │
│ The bug is clear: we update value but not index!           │
└─────────────────────────────────────────────────────────────┘
*/

int main()
{
    demonstrateBugFinding();
    return 0;
}

Practical stepping workflow

Here's a systematic approach to using stepping for debugging:

1. Preparation phase

// Before stepping:
// - Compile with debug symbols (-g flag)
// - Identify the suspicious area of code
// - Set an initial breakpoint before the problem area
// - Have expected values in mind

2. Stepping strategy

┌─────────────────────────────────────────────────────────────┐
│ Debugging Workflow:                                        │
├─────────────────────────────────────────────────────────────┤
│ 1. Start with Step Over (F10) to get overview              │
│ 2. Use Step Into (F11) when you suspect a function has bug │
│ 3. Use Step Out (Shift+F11) to escape from unrelated code │
│ 4. Set additional breakpoints to jump over large loops     │
│ 5. Watch variable values change at each step               │
│ 6. Compare actual values with expected values              │
└─────────────────────────────────────────────────────────────┘

3. Common stepping patterns

#include <iostream>

void demonstrateSteppingPatterns()
{
    std::cout << "=== Common Stepping Patterns ===" << std::endl;
    
    // Pattern 1: Step Over to skip utility functions
    std::cout << "This is a simple output" << std::endl;  // Step Over
    
    // Pattern 2: Step Into to debug suspicious functions
    int suspicious_result = suspiciousFunction(5, 10);     // Step Into
    
    // Pattern 3: Step Over loops unless problem is inside loop
    for (int i = 0; i < 1000; ++i)                        // Step Over entire loop
    {
        // Unless you suspect the bug is in here, then step into first few iterations
    }
    
    // Pattern 4: Use Step Out to escape rabbit holes
    int result = deeplyNestedFunction();                   // If you Step Into and get lost,
                                                          // use Step Out to return
}

int suspiciousFunction(int a, int b)
{
    // This function might have bugs, so we Step Into it
    return a * b + 1;  // Simple for demo, but could be complex
}

int deeplyNestedFunction()
{
    // Imagine this calls many other functions
    return 42;
}

int main()
{
    demonstrateSteppingPatterns();
    return 0;
}

IDE-specific stepping instructions

Visual Studio Code

1. Install C++ extension
2. Set breakpoint: Click left margin or F9
3. Start debugging: F5
4. Stepping commands:
   - Step Over: F10
   - Step Into: F11  
   - Step Out: Shift+F11
   - Continue: F5

Visual Studio

1. Set breakpoint: Click left margin or F9
2. Start debugging: F5 or Debug → Start Debugging
3. Stepping commands:
   - Step Over: F10
   - Step Into: F11
   - Step Out: Shift+F11
   - Continue: F5

Code::Blocks

1. Set breakpoint: Click left margin or F5
2. Start debugging: F8
3. Stepping commands:
   - Step Over: F7
   - Step Into: Shift+F7
   - Step Out: Ctrl+F7
   - Continue: F4

Best practices for stepping

1. Start broad, then narrow: Use Step Over first to get an overview, then Step Into problem areas
2. Watch variables continuously: Keep an eye on variable values as you step
3. Use conditional breakpoints: Set breakpoints that only trigger under certain conditions
4. Don't step through everything: Use Continue to jump between interesting points
5. Take notes: Keep track of what you discover as you step through

Summary

Stepping through code with an integrated debugger is one of the most powerful debugging techniques available. It allows you to:

• See exactly how your program executes line by line
• Watch variables change in real-time
• Understand the flow of complex algorithms
• Quickly identify where bugs occur
• Verify that your code does what you think it does

The key stepping modes are:

• Step Into (F11): Enter function calls to debug their internals
• Step Over (F10): Execute lines without entering function calls
• Step Out (Shift+F11): Continue until current function returns
• Continue (F5): Run until next breakpoint

In the next lesson, you'll learn about setting breakpoints and controlling program execution more precisely.

Quiz

1. What's the difference between Step Into and Step Over?
2. When would you use Step Out?
3. What compiler flag do you need to include debug information?
4. How does stepping help identify bugs that print debugging might miss?
5. What stepping strategy would you use for a program with many nested function calls?

Practice exercises

1. Create a program with nested function calls and practice using different stepping modes to trace execution.

2. Debug this function using stepping to find the bug:

   int findSum(const std::vector<int>& numbers)
   {
       int sum = 0;
       for (int i = 1; i < numbers.size(); ++i)  // Bug here
       {
           sum += numbers[i];
       }
       return sum;
   }
   

3. Use stepping to trace through this recursive function and understand the call stack:

   int fibonacci(int n)
   {
       if (n <= 1) return n;
       return fibonacci(n-1) + fibonacci(n-2);
   }
   

4. Practice the stepping workflow: Take any program you've written that has a bug, and use the systematic stepping approach to find and fix the issue.