Exception Safety: Guarantees, Copy-and-Swap, and noexcept

// No guarantee: the second allocation may throw after the first succeeded
struct NaiveOwner {
    T1* a;
    T2* b;
    NaiveOwner() : a(new T1), b(new T2) {}  // if T2 throws, T1 leaks
    ~NaiveOwner() { delete a; delete b; }
};

// Basic guarantee via RAII:
struct RaiiedOwner {
    std::unique_ptr<T1> a;
    std::unique_ptr<T2> b;
    RaiiedOwner() : a(std::make_unique<T1>()), b(std::make_unique<T2>()) {}
    // If make_unique<T2> throws: a is destroyed by unique_ptr, no leak.
};

// Strong guarantee: transaction-style
void safe_push(std::vector<T>& v, const T& x) {
    // Make a copy (might throw) — but v is untouched:
    std::vector<T> temp = v;
    temp.push_back(x);         // might throw — but temp is a local copy
    v = std::move(temp);       // swap is nothrow; only this mutates v
}

// Simpler alternative: std::vector::push_back already provides
// the strong guarantee when T's move constructor doesn't throw.

void swap(MyType& a, MyType& b) noexcept {
    using std::swap;
    swap(a.data_, b.data_);   // pointer swap — nothrow
    swap(a.size_, b.size_);   // int swap — nothrow
}

MyType(MyType&& other) noexcept
    : data_(std::exchange(other.data_, nullptr))
    , size_(std::exchange(other.size_, 0))
{}

template<typename T>
class Container {
    T* data_;
    std::size_t size_;
public:
    Container(Container&& other)
        noexcept(std::is_nothrow_move_constructible_v<T>)
        : data_(other.data_), size_(other.size_)
    { other.data_ = nullptr; other.size_ = 0; }
};

// This triggers copies instead of moves on vector reallocation:
class SlowWidget {
    std::vector<int> data_;
public:
    // compiler generates a non-noexcept move constructor
    // because std::vector's move constructor is noexcept but
    // the compiler doesn't always infer this automatically
    SlowWidget(SlowWidget&&) = default;  // check: is this noexcept?
};

// Verify:
static_assert(std::is_nothrow_move_constructible_v<SlowWidget>,
              "move constructor must be noexcept for vector efficiency");

class Buffer {
    uint8_t* data_;
    std::size_t size_;

public:
    Buffer(std::size_t n) : data_(new uint8_t[n]), size_(n) {}

    ~Buffer() { delete[] data_; }

    // Copy constructor: may throw (allocation)
    Buffer(const Buffer& other)
        : data_(new uint8_t[other.size_])
        , size_(other.size_)
    { std::copy_n(other.data_, size_, data_); }

    // nothrow swap: only pointer/integer swaps
    void swap(Buffer& other) noexcept {
        std::swap(data_, other.data_);
        std::swap(size_, other.size_);
    }

    // Copy assignment with STRONG guarantee:
    // Pass by value triggers copy constructor → if that throws, *this is unchanged
    Buffer& operator=(Buffer other) noexcept {  // 'other' is already constructed
        swap(other);    // nothrow commit
        return *this;   // 'other' (holding old data) is destroyed here
    }

    // Move assignment (nothrow):
    Buffer& operator=(Buffer&& other) noexcept {
        swap(other);
        return *this;
    }
};

class Widget {
    T1 t1_;
    T2 t2_;
public:
    Widget& operator=(const Widget& other) {
        t1_ = other.t1_;   // might throw — t1_ is modified
        t2_ = other.t2_;   // might throw — t1_ is already changed, can't undo
        return *this;
    }
};

class Widget {
    struct Impl { T1 t1; T2 t2; };
    std::unique_ptr<Impl> pimpl_;

public:
    explicit Widget() : pimpl_(std::make_unique<Impl>()) {}
    ~Widget() = default;

    void swap(Widget& other) noexcept {
        std::swap(pimpl_, other.pimpl_);   // pointer swap — nothrow
    }

    // Strong guarantee: copy constructs a new Impl, then swaps
    Widget& operator=(Widget other) noexcept {
        swap(other);
        return *this;
    }

    Widget(const Widget& other)
        : pimpl_(std::make_unique<Impl>(*other.pimpl_))
    {}
};

std::vector<T> v;

// push_back:
// - strong guarantee if T is CopyInsertable and !noexcept(T::T(T&&))
// - otherwise basic guarantee
v.push_back(x);

// insert in the middle:
// - basic guarantee (elements may have been shifted, then insertion fails)
v.insert(v.begin() + 2, x);

// std::map::operator[]:
// - strong guarantee (inserts a default-constructed value; if that throws, map unchanged)
m["key"] = value;

// std::list::splice:
// - nothrow (only pointer manipulation, no allocation)
list1.splice(list1.begin(), list2);

Writing a class that manages a resource?
  → Use unique_ptr / RAII — basic guarantee for free

Writing an assignment operator?
  → Use copy-and-swap for strong guarantee
  → Or PIMPL + copy-and-swap for classes with multiple members

Writing a swap()?
  → Must be noexcept — document it, verify it

Writing a move constructor/assignment?
  → Mark noexcept if possible
  → If move can throw, vector falls back to copy

Writing a destructor?
  → Must be noexcept (default is noexcept; never let it throw)
  → Catch and swallow exceptions inside destructors

Documenting a function?
  → State which guarantee it provides
  → "Basic guarantee: object remains valid after exception"
  → "Strong guarantee: no observable change on failure"

#include <utility>   // std::move_if_noexcept

template<typename T>
void relocate(T* dest, T* src) {
    // Moves if T's move constructor is noexcept; copies otherwise.
    // This is exactly what std::vector uses internally during reallocation.
    new (dest) T(std::move_if_noexcept(*src));
}

// Example: a type whose move can throw
struct RiskyMove {
    std::vector<int> data;
    // std::vector's move is noexcept, but suppose we add a throwing log:
    RiskyMove(RiskyMove&& other) : data(std::move(other.data)) {
        log("moved");   // hypothetically may throw
    }
};
// std::vector<RiskyMove> will COPY elements on reallocation — O(n) overhead.
// Fix: mark the move constructor noexcept if the body truly cannot throw.

struct SafeMove {
    std::vector<int> data;
    SafeMove(SafeMove&&) noexcept = default;   // inherits noexcept from vector
};
// std::vector<SafeMove> moves elements — O(1) per element.
static_assert(std::is_nothrow_move_constructible_v<SafeMove>);

// Exception-neutral generic algorithm:
template<typename InputIt, typename OutputIt, typename UnaryOp>
OutputIt safe_transform(InputIt first, InputIt last,
                        OutputIt out, UnaryOp op) {
    // If op() throws, the output range is partially written —
    // that is the caller's problem. Our invariant is: no leak,
    // iterators left consistent.
    for (; first != last; ++first, ++out) {
        *out = op(*first);   // may throw — we do not catch it
    }
    return out;
}

// Exception-neutral node insertion in a linked list:
template<typename T>
void LinkedList<T>::push_front(const T& value) {
    // Construct node first (may throw) — list is untouched:
    auto node = std::make_unique<Node>(value);   // allocation + copy may throw
    // Only modify the list after all risky work is done:
    node->next = head_;
    head_ = node.release();   // nothrow pointer assignment — this is the commit
}

class ConfigRegistry {
    std::map<std::string, std::string> entries_;

public:
    // Strong guarantee WITHOUT copying the whole map:
    void update_batch(std::span<const std::pair<std::string,std::string>> updates) {
        // Stage: accumulate all changes in a local copy of ONLY the affected keys
        std::map<std::string, std::string> staged;
        for (auto& [key, value] : updates) {
            // Validate each entry (may throw on bad input)
            validate(key, value);
            staged[key] = value;   // may throw (allocation) — entries_ untouched
        }
        // Commit: merge staged changes — each insert/assign here is individually
        // fallible, but map::insert_or_assign provides the basic guarantee per-key.
        // For true strong guarantee on the commit step, swap the whole map:
        auto new_entries = entries_;          // copy (may throw) — entries_ still intact
        for (auto& [k, v] : staged)
            new_entries.insert_or_assign(k, v);  // may throw
        entries_ = std::move(new_entries);    // nothrow (map move is noexcept)
    }

private:
    static void validate(const std::string& key, const std::string& value) {
        if (key.empty()) throw std::invalid_argument("empty key");
        if (value.size() > 4096) throw std::length_error("value too long");
    }
};

// Public API with explicit exception annotations:
class FileStream {
public:
    // May throw std::system_error on I/O failure:
    explicit FileStream(std::filesystem::path path);

    // Nothrow — always safe to call in destructors and finally-blocks:
    void close() noexcept;
    ~FileStream() noexcept;

    // May throw std::ios_base::failure:
    void write(std::span<const std::byte> data);

    // Nothrow: returns false on failure instead of throwing:
    [[nodiscard]] bool try_write(std::span<const std::byte> data) noexcept;

    // Conditionally noexcept — propagates T's moveability:
    template<typename T>
    void write_object(T&& obj)
        noexcept(noexcept(serialize(std::forward<T>(obj))));
};

// At a call site, callers can verify statically:
static_assert(noexcept(std::declval<FileStream>().close()),
              "FileStream::close must be noexcept for use in destructors");

// 1. An exception escapes a noexcept function:
void must_not_throw() noexcept {
    throw std::runtime_error("oops");  // → std::terminate
}

// 2. An exception is thrown while another is already propagating
//    (a destructor throws during stack unwinding):
struct Bad {
    ~Bad() { throw std::runtime_error("destructor threw"); }  // → std::terminate
};

// 3. A pure virtual function is called (during construction/destruction):
struct Base {
    virtual void f() = 0;
    Base() { f(); }  // calls pure virtual → std::terminate
};

// 4. An exception escapes main() (implementation-defined, often terminate):
// int main() { throw 42; }

// 5. std::thread's thread function throws:
std::thread t([] { throw std::runtime_error("thread threw"); });
t.join();  // → std::terminate (exception escaped the thread function)

#include <exception>
#include <cstdlib>

void my_terminate_handler() noexcept {
    // Attempt to log the current exception:
    if (auto eptr = std::current_exception()) {
        try {
            std::rethrow_exception(eptr);
        } catch (const std::exception& e) {
            std::fprintf(stderr, "FATAL: unhandled exception: %s\n", e.what());
        } catch (...) {
            std::fprintf(stderr, "FATAL: unknown unhandled exception\n");
        }
    } else {
        std::fprintf(stderr, "FATAL: std::terminate called (no active exception)\n");
    }
    std::abort();  // generate a core dump for post-mortem analysis
}

// Install at program startup:
int main() {
    std::set_terminate(my_terminate_handler);
    // ...
}

#include <stdexcept>
#include <cassert>

// A type that throws on the Nth copy:
struct ThrowOnCopy {
    static int copy_count;
    static int throw_at;

    int value;
    explicit ThrowOnCopy(int v = 0) : value(v) {}

    ThrowOnCopy(const ThrowOnCopy& other) : value(other.value) {
        if (++copy_count == throw_at)
            throw std::runtime_error("injected copy failure");
    }

    ThrowOnCopy& operator=(const ThrowOnCopy& other) {
        if (++copy_count == throw_at)
            throw std::runtime_error("injected copy failure");
        value = other.value;
        return *this;
    }
};
int ThrowOnCopy::copy_count = 0;
int ThrowOnCopy::throw_at   = -1;

// Test framework: run op(), injecting a throw at each copy step
template<typename Container, typename Op, typename Invariant>
void assert_strong_guarantee(Container& c, Op op, Invariant check_invariant) {
    // Snapshot the container state before the operation:
    Container before = c;

    for (int n = 1; ; ++n) {
        ThrowOnCopy::copy_count = 0;
        ThrowOnCopy::throw_at   = n;

        try {
            op(c);
            // If op() succeeded without throwing, we're done:
            break;
        } catch (const std::runtime_error&) {
            // Verify strong guarantee: container must equal pre-op state:
            assert(check_invariant(c, before)
                   && "strong guarantee violated: container changed on exception");
            // Restore and try the next injection point:
            c = before;
        }
    }
}

// Usage:
void test_push_back_strong_guarantee() {
    std::vector<ThrowOnCopy> v = { ThrowOnCopy{1}, ThrowOnCopy{2} };

    assert_strong_guarantee(
        v,
        [](auto& vec) { vec.push_back(ThrowOnCopy{99}); },
        [](const auto& vec, const auto& snapshot) {
            return vec.size() == snapshot.size();
        }
    );
}