Debugging and Error Handling in C++

Hey! Welcome back. Today, we’re covering a topic that is just as important as writing code: Debugging and Error Handling.

There’s a famous joke in programming: “Debugging is like being the detective in a crime movie where you are also the murderer.”

No matter how experienced you are, you will write bugs. That’s just a fact of developer life. The secret to being a great developer isn’t writing perfect code on the first try; it’s knowing how to track down errors, identify why they happened, and write resilient code that recovers gracefully without crashing.

---

The Four Types of Errors

Before we start hunting down bugs, we need to know what species we’re dealing with. In C++, errors generally fall into one of four stages:

graph TD
    subgraph C++ Error Classification Pipeline
        direction TB
        stage_comp[1. Writing & Compiling] -->|Typo / Syntax check| err_syn[Syntax Errors <br/> e.g., missing ';', typos]
        stage_link[2. Linking Binary] -->|Checking declarations| err_link[Linker Errors <br/> e.g., undefined reference]
        stage_run[3. Program Execution] -->|Invalid operations| err_run[Runtime Errors <br/> e.g., division by zero, null deref]
        stage_logic[4. Valid Output Audit] -->|Faulty math/logic| err_logic[Logical Errors <br/> e.g., multiplying instead of adding]
    end

1. Syntax Errors (Compile-Time Typos)

These are spelling or grammar mistakes in your code. The compiler reads your file, doesn’t understand the syntax, and throws an error immediately, halting compilation.

• Example: Forgetting a semicolon ; at the end of a line, or misspelling std::cout as std::count.

2. Linker Errors (Missing Blocks)

These happen after your code compiles successfully but before it gets packaged into an executable. The linker checks if all functions you declared actually exist somewhere in the libraries or object files. If it can’t find one, it fails.

• Example: Declaring a function void saveRecord(); in a header file but forgetting to write its implementation block in any source file.

3. Logical Errors (Silent Math Bugs)

These are the trickiest bugs of all because your program builds and runs perfectly without warning, but it produces incorrect results. For the compiler, the code makes complete sense; it just doesn’t do what you wanted it to do.

• Example: Writing double average = sum * count; instead of sum / count;.

4. Runtime Errors (Sudden Crashes)

These are errors that compile fine, but crash while the program is running when encountering invalid operations.

• Example: Trying to divide by a variable that happens to evaluate to 0, dereferencing a nullptr, or trying to read a text file that was deleted from the hard disk.

---

Debugging Techniques: Tracking Down Bugs

When a bug sneaks into your code, how do you find it? Here are three common techniques:

1. Manual Code Walkthrough

Simple but highly effective. You print your code, or open it in your editor, and trace the execution path line-by-line with a pen and paper. You manually track variable values at each step. This is great for catching logical slips.

2. Print Debugging (std::cout Breadcrumbs)

The most common approach for quick audits. You insert temporary std::cout prints throughout your code to print out variable values at key milestones:

std::cout << "[DEBUG] Current index: " << index << ", value: " << value << std::endl;

This lets you track how values change in loops. Just remember to clean up and remove these print lines before committing your code!

3. Using an IDE Debugger

For complex projects, print statements become messy. Modern IDEs (like VS Code or Visual Studio) come with built-in debuggers that let you:

• Set Breakpoints: Pause program execution at a specific line.
• Step Over/Into: Step through your code line-by-line in real-time.
• Inspect Watches: View a live panel showing values of variables currently in scope.

---

Error Handling Strategies

When your program detects a runtime error, how should it react?

graph TD
    subgraph Error Handling Strategies
        direction LR
        ignore[1. Ignore <br/> 'Silently fails' <br/> DANGEROUS]
        flag[2. Flag <br/> Return error status <br/> e.g. return -1]
        terminate[3. Terminate <br/> Print error and exit <br/> std::exit]
        repair[4. Repair <br/> Prompt retry/fallbacks <br/> IDEAL]
        
        ignore -.->|Worst| flag
        flag --> terminate
        terminate -->|Best for production| repair
    end

---

1. Flagging the Error (Status Indicators)

Instead of crashing, your function returns a special value (like -1, nullptr, or false) to tell the caller that something failed.

Example:

#include <iostream>

// Returns index if found, otherwise flags error with -1
int findIndex(int arr[], int size, int target) {
    for (int i = 0; i < size; ++i) {
        if (arr[i] == target) return i;
    }
    return -1; // Flagging the error
}

int main() {
    int arr[] = {10, 20, 30};
    int result = findIndex(arr, 3, 99);
    
    if (result == -1) {
        std::cout << "Element not found in database (flag caught)." << std::endl;
    }
    return 0;
}

Output:

Element not found in database (flag caught).

---

2. Displaying an Error and Terminating (std::exit)

If the error is catastrophic (e.g., your game can’t load its graphics files), continuing is pointless. You should print a clean error message to the error stream (cerr) and shut down the program safely using std::exit().

Example:

#include <iostream>
#include <fstream>
#include <cstdlib> // Required for std::exit

void loadAssets() {
    std::ifstream assetFile("assets.json");
    if (!assetFile) {
        std::cerr << "[CRITICAL ERROR] assets.json file is missing! Shutting down." << std::endl;
        std::exit(EXIT_FAILURE); // Terminates program immediately
    }
}

int main() {
    loadAssets();
    std::cout << "Assets loaded successfully. Starting game loop..." << std::endl;
    return 0;
}

Output:

[CRITICAL ERROR] assets.json file is missing! Shutting down.

---

3. Repairing the Error (Graceful Recovery)

This is the gold standard of production software. Instead of crashing, your program detects the issue and attempts to resolve it—either by prompting the user for correct input or loading default fallback values.

Example:

#include <iostream>
#include <string>

int getValidAge() {
    int age;
    while (true) {
        std::cout << "Enter your age (0 - 120): ";
        
        // Check if input is a valid integer and within bounds
        if (std::cin >> age && age >= 0 && age <= 120) {
            return age; // Input is valid, exit loop
        }
        
        // Input failed (user entered text instead of number) or out of bounds
        std::cout << "Invalid input! Please enter a valid number." << std::endl;
        
        std::cin.clear(); // Clear error flags on std::cin
        std::cin.ignore(10000, '\n'); // Discard invalid characters from stream buffer
    }
}

int main() {
    int userAge = getValidAge();
    std::cout << "Registered Age: " << userAge << std::endl;
    return 0;
}

Output:

Enter your age (0 - 120): ten
Invalid input! Please enter a valid number.
Enter your age (0 - 120): 150
Invalid input! Please enter a valid number.
Enter your age (0 - 120): 21
Registered Age: 21

---

Level Up: Extra Practice & Interview Questions

Q1. Identify and correct the syntax error in the following C++ code.

#include <iostream>

int main() {
    int x = 10
    std::cout << "Value of x: " << x << std::endl;
    return 0;
}

Answer:

A semicolon ; is missing at the end of line 4 (int x = 10). In C++, statements must end with a semicolon to tell the compiler where the instruction terminates.

Corrected Code:

#include <iostream>

int main() {
    int x = 10; // Added semicolon
    std::cout << "Value of x: " << x << std::endl;
    return 0;
}

---

Q2. Identify and correct the logical error in the following C++ code.

#include <iostream>

double calculateAverage(int sum, int count) {
    return sum / count;
}

int main() {
    int sum = 15;
    int count = 2;
    std::cout << "Average: " << calculateAverage(sum, count) << std::endl;
    return 0;
}

Answer:

• The Error: The function is doing integer division (sum / count), which discards the fractional part. Even though the return type is double, dividing an int (15) by an int (2) results in the integer 7 before it is converted to double (7.0).
• The Fix: We must explicitly cast at least one of the integer operands to double (e.g., static_cast<double>(sum)) to trigger floating-point division.

Corrected Code:

#include <iostream>

double calculateAverage(int sum, int count) {
    if (count == 0) return 0.0; // Added check to prevent runtime division-by-zero error!
    return static_cast<double>(sum) / count; // Cast to double
}

int main() {
    int sum = 15;
    int count = 2;
    std::cout << "Average: " << calculateAverage(sum, count) << std::endl;
    return 0;
}

Output:

Average: 7.5