What is runtime_error in C++: Explanation and Example

runtime_error in C++ is a standard exception class used to report errors that happen during program execution. It signals problems that cannot be detected before running the program, like invalid operations or logic errors.

How It Works

Imagine you are baking a cake, and suddenly you realize you ran out of sugar. You can't fix this before starting, but you need to stop and handle the problem. In C++, runtime_error works like this: it tells the program that something unexpected happened while it was running.

When your program encounters a situation it cannot handle normally, it can "throw" a runtime_error. This stops the current flow and looks for a place that knows how to "catch" and fix the problem. If no one catches it, the program stops with an error message.

This mechanism helps keep your program safe and clear by separating normal work from error handling.

Example

This example shows how to throw and catch a runtime_error when a function detects a problem.

cpp

#include <iostream>
#include <stdexcept>

void checkAge(int age) {
    if (age < 0) {
        throw std::runtime_error("Age cannot be negative");
    }
    std::cout << "Age is valid: " << age << std::endl;
}

int main() {
    try {
        checkAge(25);  // Valid age
        checkAge(-5);  // Invalid age, throws runtime_error
    } catch (const std::runtime_error& e) {
        std::cout << "Caught an error: " << e.what() << std::endl;
    }
    return 0;
}

Output

Age is valid: 25
Caught an error: Age cannot be negative

When to Use

Use runtime_error when your program encounters an error that only appears while running and cannot be predicted before. For example:

• Invalid user input like negative age or wrong file format.
• Failed operations such as opening a missing file or network errors.
• Logical errors that break program rules during execution.

This helps you separate normal code from error handling and makes your program more reliable and easier to debug.

Key Points

• runtime_error is part of C++ standard exceptions for runtime problems.
• It inherits from std::exception, so you can catch it using standard exception handlers.
• Throw it when your program detects an error it cannot fix immediately.
• Use the what() method to get a description of the error.

Key Takeaways

runtime_error signals errors detected during program execution.

Throw runtime_error to stop normal flow and handle unexpected problems.

Catch runtime_error to respond to runtime issues gracefully.

Use what() to get error details from the exception.

It helps keep error handling separate from normal code logic.