Error Handling and Exception Safety

9.4 Modern Error Handling: std::optional and std::expected

Traditional exceptions are excellent for exceptional, unexpected events (like hardware failure), but using them for expected errors (like a file not found or invalid user input) degrades performance. Modern C++ provides lightweight, monadic alternatives that avoid exceptions entirely.

Let's look at std::optional and C++23 std::expected.

Nullable States: `std::optional` (C++17)

A std::optional<T> is a stack allocated wrapper that holds either a valid value of type T or nothing (std::nullopt). It represents a function that can fail to return a value, without using exceptions or magic null values:

#include <iostream>
#include <optional>
#include <string>

std::optional<int> parseAge(const std::string& str) {
    try {
        return std::stoi(str); // Convert string to integer
    } catch (...) {
        return std::nullopt; // Return empty state on failure!
    }
}

int main() {
    auto age = parseAge("invalid");
    if (age.has_value()) {
        std::cout << "Age: " << age.value() << '\n';
    } else {
        std::cout << "Invalid age string!\n";
    }
    return 0;
}

Returning nullable states using std::optional.

Value or Error: `std::expected` (C++23)

Often, returning an empty state is not enough; you want to return a detailed error code on failure. C++23 solved this by introducing std::expected<T, E>. It holds either the expected value of type T or an error object of type E:

#include <iostream>
#include <expected>
#include <string>

enum class FileError {
    NotFound,
    AccessDenied
};

std::expected<std::string, FileError> readFile(const std::string& filename) {
    if (filename == "secret.txt") {
        return std::unexpected(FileError::AccessDenied); // Return error object
    }
    if (filename != "log.txt") {
        return std::unexpected(FileError::NotFound); // Return error object
    }
    return "File content data..."; // Return expected value
}

int main() {
    auto result = readFile("secret.txt");
    if (result) {
        std::cout << "Content: " << *result << '\n';
    } else {
        if (result.error() == FileError::AccessDenied) {
            std::cout << "Error: Access Denied!\n";
        }
    }
    return 0;
}

Returning values or error codes using std::expected.

Both std::optional and std::expected are stored on the stack and compile to simple machine branches, ensuring zero exception table overhead.

* The Mailbox Metaphor: Using optional is like checking your physical mailbox. Instead of screaming and calling the post office (throwing an exception) if there is no mail, you simply open the box and find it empty (std::nullopt). It is a normal, expected result that you check calmly.

Monadic Chaining: and_then and transform

C++23 introduces monadic operations for std::optional and std::expected. Instead of writing deeply nested if statements to check value statuses, you can chain operations cleanly using .and_then() (which maps functions returning optionals/expecteds) and .transform() (which maps functions returning raw values):

#include <iostream>
#include <optional>
#include <string>

std::optional<int> getUserId() { return 42; }
std::optional<std::string> getUsername(int id) { return "Alice"; }

int main() {
    // Clean pipeline: chains operations without checks!
    auto result = getUserId()
        .and_then(getUsername)
        .transform([](const std::string& name) { return "User: " + name; });

    if (result) {
        std::cout << *result << '\n'; // Prints: User: Alice
    }
    return 0;
}

Chaining monadic operations in C++23.