针对高复制成本对象，Copy-and-swap模式的异常安全替代方案探讨

复杂操作的回滚困境 #

简单的容器修改（比如vector::push_back）可以通过pop_back轻松撤销，但像erase+remove_if、sort、stable_partition这类不可逆的复杂操作，或者多对象状态修改的场景，一旦后续操作抛出异常，要回滚到初始状态就很棘手——你没法直接“取消排序”或“恢复被删除的元素”。全量复制容器后在副本操作、成功后swap的方案虽然可行，但对大容器或复制成本高的对象来说，性能开销难以接受。

优化回滚的可行方案 #

1. 为操作定制可逆逻辑 #

针对每个复杂操作，提前记录撤销所需的关键信息，而非复制整个容器：

• 删除操作：执行remove_if时，先收集所有被移除的元素及其原位置，异常时将这些元素插回原位置。
• 排序操作：排序前记录元素的原始索引映射（比如用一个vector<size_t>保存每个元素的初始位置），异常时根据这个映射恢复原始顺序。
• 分区操作：如果是稳定分区，可以记录分区边界和元素的原始排列；如果是非稳定分区，可能需要提前复制容器的关键部分，或者记录每个元素的原始位置。

这种方式避免了全量复制的开销，但需要为每个操作编写定制化的撤销逻辑，代码量会增加。

2. 事务型包装器统一管理撤销 #

设计一个事务类，集中注册所有修改操作对应的撤销逻辑，异常时自动按逆序执行撤销：

class Transaction {
public:
    template<typename Obj, typename UndoFunc>
    void register_undo(Obj& obj, UndoFunc undo) {
        undo_ops.emplace_back([&obj, undo]() { undo(obj); });
    }

    ~Transaction() {
        if (!committed) {
            // 逆序执行撤销操作，保证先恢复最后修改的对象
            for (auto it = undo_ops.rbegin(); it != undo_ops.rend(); ++it) {
                (*it)();
            }
        }
    }

    void commit() { committed = true; }

private:
    bool committed = false;
    std::vector<std::function<void()>> undo_ops;
};

使用示例（以容器操作为例）：

Transaction tx;

// 处理vec1的erase操作
std::vector<MyType> removed_elems;
auto new_end = std::remove_if(vec1.begin(), vec1.end(), [&](const MyType& elem) {
    if (/* 删除条件 */) {
        removed_elems.push_back(elem);
        return true;
    }
    return false;
});
// 注册撤销逻辑：将元素插回原位置
tx.register_undo(vec1, [new_end, elems=std::move(removed_elems)](auto& v) {
    v.insert(new_end, elems.begin(), elems.end());
});
vec1.erase(new_end, vec1.end());

// 处理vec2的排序
std::vector<size_t> orig_indices(vec2.size());
std::iota(orig_indices.begin(), orig_indices.end(), 0);
// 先根据原始索引排序，记录映射关系
std::sort(orig_indices.begin(), orig_indices.end(), [&vec2](size_t a, size_t b) {
    return vec2[a] < vec2[b];
});
// 注册撤销逻辑：恢复原始顺序
tx.register_undo(vec2, [temp=vec2, orig_indices](auto& v) {
    for (size_t i = 0; i < v.size(); ++i) {
        v[i] = temp[orig_indices[i]];
    }
});
std::sort(vec2.begin(), vec2.end());

// 执行stable_partition
auto part_point = std::stable_partition(vec3.begin(), vec3.end(), [](const auto& elem) {
    return /* 分区条件 */;
});
// 注册撤销逻辑：恢复原始状态
tx.register_undo(vec3, [orig=vec3](auto& v) { v = orig; });

// 所有操作完成后提交事务
tx.commit();

3. 利用写时复制（COW）容器 #

如果使用支持COW的容器（第三方库或自定义封装），修改操作不会立刻复制整个容器，而是在真正修改数据时才生成副本。操作过程中原始容器的状态会被保留，只有当所有操作成功后，才切换到修改后的版本。不过C++标准库容器原生不支持COW，需要额外实现或引入第三方依赖。

多对象方法调用的回滚处理 #

对于多个对象的状态修改方法调用，要求每个对象提供状态保存与恢复的接口：

Transaction tx;

// 保存object1的原始状态并注册撤销
auto obj1_orig = object1.save_state();
tx.register_undo(object1, [state=std::move(obj1_orig)](auto& obj) {
    obj.restore_state(state);
});
object1.modify_state();

// 同理处理object2
auto obj2_orig = object2.save_state();
tx.register_undo(object2, [state=std::move(obj2_orig)](auto& obj) {
    obj.restore_state(state);
});
object2.modify_state();

// 执行可能抛出异常的操作
object3.modify_state();

tx.commit();

这里的save_state()只需保存对象修改的关键部分，而非全量复制，能有效降低开销。如果对象状态无法拆分保存，才需要全量复制状态。

方案权衡 #

• 全量复制+swap：实现最简单，但性能开销大，适合小容器或非性能敏感场景。
• 定制可逆逻辑：性能最优，但需要为每个操作编写撤销代码，复杂度高，适合性能敏感场景。
• 事务包装器：降低撤销逻辑的耦合度，集中管理回滚操作，但仍需定制每个操作的undo逻辑，兼顾了性能与可维护性。

内容的提问来源于stack exchange，提问作者Alexey104