C++类成员函数如何实现异常安全

异常安全通过RAII、拷贝交换和事务机制确保对象状态一致；RAII用智能指针管理资源，拷贝交换提供强保证，事务操作确保多步更改的原子性。

异常安全在 C++ 类成员函数中意味着，即使函数抛出异常，对象也能保持有效状态，资源不会泄漏。实现异常安全需要仔细考虑函数可能抛出异常的地方，并采取措施保证状态的一致性和资源的管理。

在 C++ 中，异常安全主要通过以下几个级别来衡量：

• 不提供任何保证 (No-guarantee): 函数可能导致资源泄漏或对象状态损坏。
• 基本保证 (Basic guarantee): 如果抛出异常，对象仍然处于可用状态，没有资源泄漏。
• 强烈保证 (Strong guarantee): 如果函数完成，它就完全成功；如果抛出异常，对象状态与调用前完全一样。
• 无异常保证 (No-throw guarantee): 函数永远不会抛出异常。

解决方案：

1. 资源获取即初始化 (RAII): 使用 RAII 智能指针（如 std::unique_ptr, std::shared_ptr）来管理资源，确保资源在异常发生时也能被正确释放。

2. 拷贝构造与交换 (Copy-and-Swap): 实现强烈保证的常用方法。创建一个对象的临时拷贝，执行所有可能抛出异常的操作，如果一切顺利，再与原对象进行交换。

3. 非抛出交换 (No-throw swap): 确保交换操作本身不会抛出异常。通常通过自定义交换函数并使用 std::move 来实现。

4. 事务性操作 (Transactional operations): 将操作分解为一系列步骤，只有所有步骤都成功完成才提交更改。如果任何步骤失败，则回滚到原始状态。

5. 异常说明 (Exception specifications): 虽然在 C++11 中已被弃用，但了解其概念有助于理解函数可能抛出的异常类型。

6. 使用强类型别名 (Strong typedefs): 可以避免类型错误，减少潜在的异常源。

如何使用 RAII 确保资源安全？

RAII 的核心思想是将资源的生命周期与对象的生命周期绑定。当对象离开作用域时（无论是正常离开还是由于异常），对象的析构函数会被调用，从而释放资源。例如：

#include 
#include 

class MyClass {
public:
  MyClass() : resource(new int(42)) {
    std::cout << "Resource allocated" << std::endl;
  }

  ~MyClass() {
    std::cout << "Resource deallocated" << std::endl;
    delete resource;
  }

private:
  int* resource;
};

void foo() {
  MyClass obj;
  // 可能抛出异常的代码
  throw std::runtime_error("Something went wrong");
}

int main() {
  try {
    foo();
  } catch (const std::exception& e) {
    std::cerr << "Exception caught: " << e.what() << std::endl;
  }
  return 0;
}

在这个例子中，如果 foo() 函数抛出异常，obj 的析构函数仍然会被调用，释放 resource 指向的内存。但是，更好的做法是使用智能指针：

#include 
#include 

class MyClass {
public:
  MyClass() : resource(std::make_unique(42)) {
    std::cout << "Resource allocated" << std::endl;
  }

private:
  std::unique_ptr resource;
};

使用 std::unique_ptr 可以自动管理内存，避免手动 delete，从而简化代码并提高安全性。

Copy-and-Swap 如何实现强烈保证？

Copy-and-Swap 技术通过创建一个对象的副本，对副本进行修改，然后在修改成功后与原对象进行交换，从而实现强烈保证。如果修改副本的过程中抛出异常，原对象的状态不会受到影响。

#include 
#include 
#include 

class MyVector {
public:
    MyVector(std::initializer_list init) : data(init) {}

    MyVector& operator+=(int value) {
        // 创建副本
        MyVector temp = *this;
        // 在副本上执行可能抛出异常的操作
        temp.data.push_back(value);
        // 如果一切顺利，交换副本和原对象
        swap(temp);
        return *this;
    }

    void swap(MyVector& other) noexcept {
        std::swap(data, other.data);
    }

private:
    std::vector data;
};

std::ostream& operator<<(std::ostream& os, const MyVector& vec) {
    for (int i : vec.data) {
        os << i << " ";
    }
    return os;
}

int main() {
    MyVector vec = {1, 2, 3};
    try {
        vec += 4;
        std::cout << vec << std::endl; // 输出 1 2 3 4
        vec += 5;
        std::cout << vec << std::endl; // 输出 1 2 3 4 5
    } catch (const std::exception& e) {
        std::cerr << "Exception caught: " << e.what() << std::endl;
    }
    return 0;
}

在这个例子中，operator+= 首先创建一个 MyVector 对象的副本 temp，然后在 temp 上执行 push_back 操作。如果 push_back 抛出异常，原对象 vec 的状态不会受到影响。只有当 push_back 成功后，才会调用 swap 函数交换 temp 和 vec 的数据。swap 函数被声明为 noexcept，表示它不会抛出异常，这对于保证异常安全至关重要。

如何处理函数内部多个可能抛出异常的操作？

当函数内部有多个可能抛出异常的操作时，需要仔细考虑异常处理的策略，确保对象状态的一致性和资源的释放。一种常用的方法是使用事务性操作，将操作分解为一系列步骤，只有所有步骤都成功完成才提交更改。

#include 
#include 

class DataBase {
public:
    void connect() {
        std::cout << "Connecting to database..." << std::endl;
        // 模拟可能抛出异常的连接操作
        if (rand() % 5 == 0) {
            throw std::runtime_error("Failed to connect to database");
        }
        connected = true;
    }

    void executeQuery(const std::string& query) {
        if (!connected) {
            throw std::runtime_error("Not connected to database");
        }
        std::cout << "Executing query: " << query << std::endl;
        // 模拟可能抛出异常的查询操作
        if (rand() % 5 == 0) {
            throw std::runtime_error("Failed to execute query");
        }
    }

    void commitTransaction() {
        if (!connected) {
            throw std::runtime_error("Not connected to database");
        }
        std::cout << "Committing transaction..." << std::endl;
        // 模拟可能抛出异常的提交操作
        if (rand() % 5 == 0) {
            throw std::runtime_error("Failed to commit transaction");
        }
        transactionCommitted = true;
    }

    void rollbackTransaction() {
        std::cout << "Rolling back transaction..." << std::endl;
        // 执行回滚操作
        transactionCommitted = false;
    }

    ~DataBase() {
        if (connected && !transactionCommitted) {
            rollbackTransaction();
        }
    }

private:
    bool connected = false;
    bool transactionCommitted = false;
};

void processData(DataBase& db, const std::string& query) {
    try {
        db.connect();
        db.executeQuery(query);
        db.commitTransaction();
    } catch (const std::exception& e) {
        std::cerr << "Exception caught: " << e.what() << std::endl;
        db.rollbackTransaction();
        throw; // 重新抛出异常，让调用者处理
    }
}

int main() {
    DataBase db;
    try {
        processData(db, "SELECT * FROM users");
    } catch (const std::exception& e) {
        std::cerr << "Main: Exception caught: " << e.what() << std::endl;
    }
    return 0;
}

在这个例子中，processData 函数模拟了一个数据库事务。它首先尝试连接到数据库，然后执行查询，最后提交事务。如果在任何一个步骤中抛出异常，就会调用 rollbackTransaction 函数回滚事务，确保数据库的状态保持一致。processData 函数重新抛出异常，让调用者有机会处理异常。DataBase 类的析构函数确保在对象销毁时，如果事务没有提交，就会执行回滚操作。

实现异常安全是一个复杂的问题，需要仔细考虑函数可能抛出异常的地方，并采取适当的措施来保证对象状态的一致性和资源的释放。RAII、Copy-and-Swap 和事务性操作是常用的技术，可以帮助实现不同级别的异常安全保证。