Exception Safety

Exception Safety ensures that when an exception is thrown, the program does not leak resources (like memory or file handles) and maintains a consistent state. It is classified into four levels of guarantees.

Implementing the Strong Guarantee: Copy-and-Swap

To achieve the Strong Exception Safety Guarantee, developers often use the "copy-and-swap" idiom. Instead of modifying the object directly:

1. Create a local copy of the target object.
2. Perform the risky, throwing operations on the copy.
3. If successful, swap the state of the current object with the copy using a non-throwing swap operation.
4. If an exception is thrown, the temporary copy is cleaned up automatically, and the original object remains unchanged.

Code Walkthrough

This class uses copy-and-swap to guarantee strong exception safety on assignment.

#include <iostream>
#include <vector>
#include <algorithm>
class SafeArray {
private:
    int* m_data = nullptr;
    size_t m_size = 0;
public:
    SafeArray(size_t size) : m_data(new int[size]()), m_size(size) {}
    ~SafeArray() { delete[] m_data; }
// Copy Constructor (might throw)
    SafeArray(const SafeArray& other) 
        : m_data(new int[other.m_size]), m_size(other.m_size) {
        std::copy(other.m_data, other.m_data + other.m_size, m_data);
    }
// Non-throwing Swap (no-throw guarantee)
    friend void swap(SafeArray& first, SafeArray& second) noexcept {
        using std::swap;
        swap(first.m_data, second.m_data);
        swap(first.m_size, second.m_size);
    }
// Assignment Operator providing Strong Exception Safety
    SafeArray& operator=(SafeArray other) { // Passed by value, creates a copy (might throw)
        swap(*this, other); // Swaps with temp copy (no-throw)
        return *this;       // Temp object containing old data destroyed here safely
    }
};
int main() {
    SafeArray a(5);
    SafeArray b(10);
    a = b; // Assignment is exception-safe!
    return 0;
}

Interview-Relevant Information