C Debugging

Debugging Methods

printf("x = %d\n", x);

gcc -g program.c
gdb ./a.out

// Check each line
if (x == 0) // Is this right?

// Test edge cases
test_function(0);
test_function(-1);

🔹 Printf Debugging Technique

Printf debugging is the simplest and most fundamental debugging method used in C programming. By strategically placing printf() statements throughout your code, you can observe variable values and program flow during execution. This technique helps you trace code execution step-by-step, identify where variables change unexpectedly, and pinpoint the exact location where bugs occur. Printf debugging is particularly useful for beginners because it requires no special tools or debuggers, making it accessible and effective for understanding program behavior.

// Debugging a loop problem
#include <stdio.h>

int main() {
    int sum = 0;
    
    printf("DEBUG: Starting loop\n");
    
    for (int i = 1; i <= 5; i++) {
        printf("DEBUG: i = %d, sum before = %d\n", i, sum);
        sum += i;
        printf("DEBUG: sum after = %d\n", sum);
    }
    
    printf("DEBUG: Final sum = %d\n", sum);
    printf("Final result: %d\n", sum);
    
    return 0;
}

🔹 Debugging Array Problems

Arrays are one of the most common sources of bugs in C programming and require careful debugging strategies. Common array-related issues include accessing elements outside the valid index range, initializing arrays incorrectly, or failing to handle boundary conditions properly. To debug array problems effectively, use printf() statements to display array contents, verify array indices are within bounds, check initialization values, and trace loops that access array elements. Always validate array indices before accessing elements to prevent segmentation faults and undefined behavior.

// Debugging array access
#include <stdio.h>

int main() {
    int arr[5] = {10, 20, 30, 40, 50};
    int size = 5;
    
    printf("DEBUG: Array size = %d\n", size);
    
    // Print all array elements
    for (int i = 0; i < size; i++) {
        printf("DEBUG: arr[%d] = %d\n", i, arr[i]);
    }
    
    // Safe array access
    int index = 3;
    printf("DEBUG: Accessing index %d\n", index);
    
    if (index >= 0 && index < size) {
        printf("Value at index %d: %d\n", index, arr[index]);
    } else {
        printf("ERROR: Index %d is out of bounds!\n", index);
    }
    
    return 0;
}

🔹 Function Debugging

Debugging functions effectively requires monitoring both input parameters and return values carefully. Add printf() statements at the beginning of functions to display received parameters, inside functions to track variable changes, and before return statements to verify return values. This approach helps you understand function behavior, identify incorrect parameter passing, and trace how data transforms through the function. Test functions with various input values, including edge cases and boundary conditions, to ensure they work correctly in all scenarios.

// Debugging a function
#include <stdio.h>

int multiply(int a, int b) {
    printf("DEBUG: multiply called with a=%d, b=%d\n", a, b);
    
    int result = a * b;
    
    printf("DEBUG: multiply result = %d\n", result);
    return result;
}

int main() {
    int x = 4, y = 7;
    
    printf("DEBUG: Before calling multiply\n");
    printf("DEBUG: x = %d, y = %d\n", x, y);
    
    int product = multiply(x, y);
    
    printf("DEBUG: After calling multiply\n");
    printf("Final product: %d\n", product);
    
    return 0;
}

🔹 Common Debugging Strategies

Systematic debugging strategies help you find and fix bugs efficiently and methodically. Start by understanding the problem clearly and reproducing it consistently. Isolate the problematic code section, then use printf() statements to narrow down the issue location. Break complex problems into smaller, manageable parts, test each part independently, and verify assumptions about variable values. Document your findings as you debug, review code carefully for logical errors, and use compiler warnings to catch potential issues early.

// Systematic debugging example
#include <stdio.h>

int divide_numbers(int a, int b) {
    // Step 1: Check inputs
    printf("DEBUG: Inputs a=%d, b=%d\n", a, b);
    
    // Step 2: Check for edge cases
    if (b == 0) {
        printf("DEBUG: Division by zero detected!\n");
        return -1;  // Error code
    }
    
    // Step 3: Perform calculation
    int result = a / b;
    printf("DEBUG: Division result = %d\n", result);
    
    return result;
}

int main() {
    // Test different cases
    printf("=== Test 1: Normal case ===\n");
    divide_numbers(10, 2);
    
    printf("\n=== Test 2: Division by zero ===\n");
    divide_numbers(10, 0);
    
    return 0;
}