C++如何在类成员函数中实现异常安全-C++-PHP中文网

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

P粉602998670

发布： 2025-09-19 16:48:02

原创

627人浏览过

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

c++如何在类成员函数中实现异常安全

异常安全在 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): 可以避免类型错误，减少潜在的异常源。

腾讯智影-AI数字人
基于AI数字人能力，实现7*24小时AI数字人直播带货，低成本实现直播业务快速增增，全天智能在线直播

73

查看详情

如何使用 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;
}

登录后复制

在这个例子中，