C++异常安全代码编写原则

try-catch

void process_data(const std::string& filename) {
    FILE* file = fopen(filename.c_str(), "r");
    if (!file) {
        throw std::runtime_error("Failed to open file");
    }
    // ... 处理文件数据 ...
    // 如果这里抛出异常，file就不会被关闭
    fclose(file); // 很容易忘记，或者在异常路径上被跳过
}

std::unique_ptr

class FileHandle {
public:
    FileHandle(const std::string& filename, const char* mode) {
        file_ = fopen(filename.c_str(), mode);
        if (!file_) {
            throw std::runtime_error("Failed to open file");
        }
    }
    ~FileHandle() {
        if (file_) {
            fclose(file_); // 析构函数保证被调用
        }
    }
    // 禁止拷贝，确保唯一所有权
    FileHandle(const FileHandle&) = delete;
    FileHandle& operator=(const FileHandle&) = delete;
    // 移动构造和赋值
    FileHandle(FileHandle&& other) noexcept : file_(other.file_) {
        other.file_ = nullptr;
    }
    FileHandle& operator=(FileHandle&& other) noexcept {
        if (this != &other) {
            if (file_) fclose(file_);
            file_ = other.file_;
            other.file_ = nullptr;
        }
        return *this;
    }

    FILE* get() const { return file_; }

private:
    FILE* file_;
};

void process_data_raii(const std::string& filename) {
    FileHandle file(filename, "r"); // 资源获取
    // ... 处理文件数据 ...
    // 无论这里发生什么，file_的析构函数都会被调用，文件会被安全关闭
} // file对象生命周期结束，析构函数被调用

std::unique_ptr

std::lock_guard

MyVector

push_back

#include <algorithm> // For std::swap
#include <stdexcept>
#include <vector> // For internal use, or imagine a raw array

class MyVector {
public:
    MyVector() : data_(nullptr), size_(0), capacity_(0) {}
    ~MyVector() { delete[] data_; }

    MyVector(const MyVector& other)
        : data_(new int[other.capacity_]), size_(other.size_), capacity_(other.capacity_) {
        std::copy(other.data_, other.data_ + other.size_, data_);
    }

    MyVector(MyVector&& other) noexcept
        : data_(other.data_), size_(other.size_), capacity_(other.capacity_) {
        other.data_ = nullptr;
        other.size_ = 0;
        other.capacity_ = 0;
    }

    MyVector& operator=(MyVector other) noexcept { // 注意：这里参数是传值，利用了拷贝构造
        swap(*this, other);
        return *this;
    }

    friend void swap(MyVector& first, MyVector& second) noexcept {
        using std::swap;
        swap(first.data_, second.data_);
        swap(first.size_, second.size_);
        swap(first.capacity_, second.capacity_);
    }

    void push_back(int value) {
        if (size_ == capacity_) {
            // 1. 复制：创建一个新的、更大的MyVector副本
            //    这里我们直接创建一个新的内部数组
            size_t new_capacity = capacity_ == 0 ? 1 : capacity_ * 2;
            std::unique_ptr<int[]> new_data(new int[new_capacity]); // RAII管理新内存

            // 2. 修改：将旧数据复制到新数组，并添加新元素
            std::copy(data_, data_ + size_, new_data.get());
            new_data[size_] = value;

            // 如果 new int[new_capacity] 抛出异常，或者 std::copy 抛出异常
            // 原始 MyVector 对象不会受到任何影响，因为它还在使用旧的 data_

            // 3. 交换：所有操作成功后，原子性地交换数据
            //    这里我们利用了move语义和swap函数
            delete[] data_; // 释放旧内存
            data_ = new_data.release(); // 接管新内存
            capacity_ = new_capacity;
            size_++;
        } else {
            data_[size_] = value;
            size_++;
        }
    }

    size_t size() const { return size_; }
    size_t capacity() const { return capacity_; }
    int operator[](size_t index) const {
        if (index >= size_) throw std::out_of_range("Index out of bounds");
        return data_[index];
    }

private:
    int* data_;
    size_t size_;
    size_t capacity_;
};

push_back

unique_ptr

new int[new_capacity]

std::bad_alloc

std::copy

new_data

unique_ptr

MyVector

data_

size_

capacity_

MyVector

push_back