Exceptions, optional, variant & expected

Classify failure first

A precondition states what a caller must provide; a postcondition states what success guarantees; an invariant must remain true for valid objects. Expected absence is not exceptional, while a disk failure or malformed external document may be recoverable. A violated internal invariant often indicates a bug rather than a normal runtime outcome.

Throwing, catching, and unwinding

throw creates an exception that propagates until a matching handler is found. As stack frames unwind, destructors run for fully constructed automatic objects. Catch standard and custom exceptions by const& to preserve dynamic type and avoid copies.

#include <iostream>
#include <stdexcept>
#include <string>

int parse_port(const std::string& text) {
    std::size_t consumed{};
    int port{std::stoi(text, &consumed)};
    if (consumed != text.size() || port < 1 || port > 65535) {
        throw std::out_of_range{"invalid port"};
    }
    return port;
}

int main() {
    try {
        std::cout << parse_port("8080") << '\n';
    } catch (const std::exception& error) {
        std::cerr << error.what() << '\n';
        return 1;
    }
}

Safety guarantees and noexcept

The basic guarantee preserves invariants and prevents resource leaks. The strong guarantee also leaves the operation's observable state unchanged on failure. The no-throw guarantee promises completion without emitting an exception. RAII, work-on-a-copy, and commit steps make these guarantees practical.

noexcept is part of a function's contract. If an exception escapes anoexcept function, the program terminates. Apply it only when the implementation and every operation it calls can uphold the promise.

• Destructors and cleanup operations should normally be no-throw
• Move operations should be noexcept when their member moves are noexcept
• Validate or allocate before mutating committed state
• Prefer swap-based commit for strong exception safety

Optional values

std::optional<T> contains either a T or no value. It is ideal for lookup and parsing where absence is a normal result and needs no detailed error. Test before dereferencing, use value_or for a natural fallback, or use value()when an empty state should throw.

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

std::optional<std::size_t> locate(const std::vector<std::string>& names,
                                  const std::string& target) {
    for (std::size_t index{}; index < names.size(); ++index) {
        if (names[index] == target) return index;
    }
    return std::nullopt;
}

int main() {
    std::vector<std::string> names{"Ada", "Maya", "Noah"};
    if (auto found{locate(names, "Maya")}) {
        std::cout << "index " << *found << '\n';
    }
}

Closed alternatives with variant

std::variant stores exactly one value from a fixed list of types. Usestd::visit to process it, often with an overloaded visitor. Unlike a base pointer, a variant has value semantics and makes the complete alternative set visible in its type.

#include <iostream>
#include <string>
#include <variant>

struct Loading {};
struct Success { std::string value; };
struct Failure { std::string message; };
using State = std::variant<Loading, Success, Failure>;

int main() {
    State state{Success{"profile loaded"}};
    std::visit([](const auto& current) {
        using T = std::decay_t<decltype(current)>;
        if constexpr (std::is_same_v<T, Loading>) std::cout << "loading";
        else if constexpr (std::is_same_v<T, Success>) std::cout << current.value;
        else std::cout << "error: " << current.message;
    }, state);
}

Typed results with expected

C++23 std::expected<T, E> stores either a success value or an error value. It keeps failure visible in the return type and is useful when callers routinely branch on an error category. It is not part of the C++20 baseline, so projects must confirm library support.

// C++23
#include <expected>
#include <iostream>
#include <string>

enum class ParseError { empty, invalid };

std::expected<int, ParseError> parse_positive(const std::string& text) {
    if (text.empty()) return std::unexpected{ParseError::empty};
    try {
        int value{std::stoi(text)};
        if (value <= 0) return std::unexpected{ParseError::invalid};
        return value;
    } catch (...) {
        return std::unexpected{ParseError::invalid};
    }
}

int main() {
    auto result{parse_positive("42")};
    if (result) std::cout << *result << '\n';
}