异常安全通过RAII、拷贝交换和事务机制确保对象状态一致；RAII用智能指针管理资源，拷贝交换提供强保证，事务操作确保多步更改的原子性。
异常安全在 C++ 类成员函数中意味着，即使函数抛出异常，对象也能保持有效状态，资源不会泄漏。实现异常安全需要仔细考虑函数可能抛出异常的地方，并采取措施保证状态的一致性和资源的管理。
在 C++ 中，异常安全主要通过以下几个级别来衡量：
- 不提供任何保证 (No-guarantee): 函数可能导致资源泄漏或对象状态损坏。
- 基本保证 (Basic guarantee): 如果抛出异常，对象仍然处于可用状态，没有资源泄漏。
- 强烈保证 (Strong guarantee): 如果函数完成，它就完全成功；如果抛出异常，对象状态与调用前完全一样。
- 无异常保证 (No-throw guarantee): 函数永远不会抛出异常。
解决方案：
-
资源获取即初始化 (RAII): 使用 RAII 智能指针（如
std::unique_ptr
,std::shared_ptr
）来管理资源，确保资源在异常发生时也能被正确释放。立即学习“C++免费学习笔记（深入）”；
拷贝构造与交换 (Copy-and-Swap): 实现强烈保证的常用方法。创建一个对象的临时拷贝，执行所有可能抛出异常的操作，如果一切顺利，再与原对象进行交换。
非抛出交换 (No-throw swap): 确保交换操作本身不会抛出异常。通常通过自定义交换函数并使用
std::move
来实现。事务性操作 (Transactional operations): 将操作分解为一系列步骤，只有所有步骤都成功完成才提交更改。如果任何步骤失败，则回滚到原始状态。
异常说明 (Exception specifications): 虽然在 C++11 中已被弃用，但了解其概念有助于理解函数可能抛出的异常类型。
使用强类型别名 (Strong typedefs): 可以避免类型错误，减少潜在的异常源。
如何使用 RAII 确保资源安全？
RAII 的核心思想是将资源的生命周期与对象的生命周期绑定。当对象离开作用域时（无论是正常离开还是由于异常），对象的析构函数会被调用，从而释放资源。例如：
#include <memory>
#include <iostream>
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 <memory>
#include <iostream>
class MyClass {
public:
MyClass() : resource(std::make_unique<int>(42)) {
std::cout << "Resource allocated" << std::endl;
}
private:
std::unique_ptr<int> resource;
};使用
std::unique_ptr可以自动管理内存，避免手动
delete，从而简化代码并提高安全性。
Copy-and-Swap 如何实现强烈保证？
Copy-and-Swap 技术通过创建一个对象的副本，对副本进行修改，然后在修改成功后与原对象进行交换，从而实现强烈保证。如果修改副本的过程中抛出异常，原对象的状态不会受到影响。
#include <algorithm>
#include <iostream>
#include <vector>
class MyVector {
public:
MyVector(std::initializer_list<int> 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<int> 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 <iostream>
#include <vector>
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 和事务性操作是常用的技术，可以帮助实现不同级别的异常安全保证。
