在 C++ 中，是否有一种惯用的方法来防止运行操作集合导致集合发生变异的情况？

Question

假设您有一个 class foo 包装了某种可调用对象的集合。 foo 有一个成员函数 run() 遍历集合并调用每个函数对象。 foo 还有一个成员 remove(...)，它将从集合中删除一个可调用对象。

是否有可以放入 foo.run() 和 foo.remove(...) 的惯用的 RAII 式守卫，以便由对 foo.run() 的调用驱动的删除会被推迟到守卫的析构函数触发？可以用标准库中的东西来完成吗？这个图案有名字吗？

我当前的代码似乎不够优雅，所以我正在寻找最佳实践类型的解决方案。

注意：这与并发无关。非线程安全的解决方案很好。问题在于重入和自引用。

这是一个问题示例，没有不雅的 "defer remove" 守卫。

class ActionPlayer
{
private:
    std::vector<std::pair<int, std::function<void()>>> actions_;
public:
    void addAction(int id, const std::function<void()>& action)
    {
        actions_.push_back({ id, action });
    }

    void removeAction(int id)
    {
        actions_.erase(
            std::remove_if(
                actions_.begin(),
                actions_.end(),
                [id](auto& p) { return p.first == id; }
            ),
            actions_.end()
        );
    }

    void run()
    {
        for (auto& item : actions_) {
            item.second();
        }
    }
};

然后在其他地方：

...

ActionPlayer player;

player.addAction(1, []() {
    std::cout << "Hello there" << std::endl;
});

player.addAction(42, [&player]() {
    std::cout << "foobar" << std::endl;
    player.removeAction(1);
});

player.run(); // boom

编辑...好吧，这就是我如何通过 RAII 锁对象做到这一点。以下内容应该处理在运行内抛出和重新调用运行的操作，假设递归最终终止（如果不是，那是用户的错）。我使用了缓存 std::functions 因为在这段代码的真实版本中，addAction 和 removeAction 的等价物是模板函数，不能只存储在普通的同类容器中。

class ActionPlayer
{
private:

    std::vector<std::pair<int, std::function<void()>>> actions_;
    int run_lock_count_;
    std::vector<std::function<void()>> deferred_ops_;

    class RunLock
    {
    private:
        ActionPlayer* parent_;
    public:
        RunLock(ActionPlayer* parent) : parent_(parent) { (parent_->run_lock_count_)++; }
        ~RunLock()
        {
            if (--parent_->run_lock_count_ == 0) {
                while (!parent_->deferred_ops_.empty()) {
                    auto do_deferred_op = parent_->deferred_ops_.back();
                    parent_->deferred_ops_.pop_back();
                    do_deferred_op();
                }
            }
        }
    };

    bool isFiring() const
    {
        return run_lock_count_ > 0;
    }

public:
    ActionPlayer() : run_lock_count_(0)
    {
    }

    void addAction(int id, const std::function<void()>& action)
    {
        if (!isFiring()) {
            actions_.push_back({ id, action });
        } else {
            deferred_ops_.push_back(
                [&]() {
                    addAction(id, action);
                }
            );
        }
    }

    void removeAction(int id)
    {
        if (!isFiring()) {
            actions_.erase(
                std::remove_if(
                    actions_.begin(),
                    actions_.end(),
                    [id](auto& p) { return p.first == id; }
                ),
                actions_.end()
            );
        } else {
            deferred_ops_.push_back(
                [&]() {
                    removeAction(id); 
                }
            );
        }
    }

    void run()
    {
        RunLock lock(this);
        for (auto& item : actions_) {
            item.second();
        }
    }
};

Answer 1

通常的方法是创建 vector 的副本。但是这可能会导致被移除的动作再次运行。

void run()
{
    auto actions_copy{actions_};
    for (auto& item : actions_copy) {
        item.second();
    }
}

其他选项，如果运行不允许删除操作

如果删除了某些操作，则添加一个布尔值来存储
使用shared/weak ptr
如果知道当前操作不会被删除，请使用std::list。

Answer 2

向 run 添加一个标志，表示您正在枚举 actions_。然后，如果使用该标志集调用 removeAction，则将 id 存储在向量中以供以后删除。您可能还需要一个单独的向量来保存枚举时添加的操作。完成 actions_ 的所有迭代后，您可以删除要删除的那些并添加已添加的。

类似

// within class ActionPlayer, add these private member variables
private:
    bool running = false;
    std::vector<int> idsToDelete;

public:
    void run() {
        running = true;
        for (auto& item : actions_) {
            item.second();
        }
        running = false;
        for (d: idsToDelete)
            removeAction(d);
        idsToDelete.clear();
    }

    // ...

您可以对延迟的 addAction 调用进行类似的更改（如果任何操作可以添加操作，您将需要这样做，因为添加可能会导致向量分配更多存储空间，从而使无效向量的所有迭代器）。

Answer 3

我会稍微修改结构。我不允许直接修改 ActionPlayer，而是通过外部修饰符 class 强制所有修改。在这个例子中，我将它设为抽象修饰符 class，它可以有不同的具体实现（例如 DeferredModifier、InstantModifier、NullModifier、LoggedModifier、TestModifier 。ETC。）。您的操作现在只需要引用修饰符的抽象基 class 并调用任何 add/remove .etc。根据需要在其上运行。这允许将修改策略与操作实现分开，并将不同的修改策略注入到操作中。

这也应该允许更简单地支持并发修改，因为您不再需要切换运行 / not 运行ning 状态来延迟修改。

此示例展示了一种按顺序重播操作的简单方法（这是属性我假设您想要维护的）。更高级的实现可以向后扫描修改列表，删除所有 add/remove 对，然后对修改/删除进行分组，以最大限度地减少修改操作列表时的复制。

类似于：

class ActionPlayer {
friend class Modifier;
...

    void run(Modifier &modifier) { }
private:
    void addAction(...) { ... }
    void removeAction(...) { ... }
}

class Modifier
{
public:
    virtual ~Modifier() {}
    virtual addAction(...) = 0;
    virtual removeAction(...) = 0;
}

class DelayedModifier : public Modifier
{
    struct Modification { virtual void run(ActionPlayer&) = 0; }

    struct RemoveAction : public Modification
    {
        int id;

        Removal(int _id) : id(_id) {} 
        virtual void run(ActionPlayer &player) { player.removeAction(id); }
    }

    struct AddAction : public Modification
    {
        int id;
        std::function<void(Modifier&)>> action;

        AddAction(int _id, const std::function<void(Modifier&)> &_action) : id(_id), action(_action)  {}
        virtual void run(ActionPlayer &player) { player.addAction(id, action) };
    }

    ActionPlayer &player;
    std::vector<Modification> modifications;

public:
    DelayedModifier(ActionPlayer &_player) player(_player) {}
    virtual ~DelayedModifier() { run(); }

    virtual void addAction(int id, const std::function<void(Modifier&)> &action) { modifications.push_back(AddAction(id, action)); }
    virtual void removeAction(int id) { modifications.push_back(RemoveAction(id)); }

    void run()
    {
        for (auto &modification : modifications)
            modification.run(player);
        modifications.clear();
    }
};

所以你现在写：

ActionPlayer player;

{
    DelayedModifier modifier(player);

    modifier.addAction(...);
    modifier.addAction(...);
    modifier.run();
    actions.run(modifier);
}

在 C++ 中，是否有一种惯用的方法来防止运行操作集合导致集合发生变异的情况？

In C++ is there an idiomatic way to guard against the situation in which running a collection of actions causes the collection to be mutated?

c++

raii

在 C++ 中，是否有一种惯用的方法来防止 运行 操作集合导致集合发生变异的情况？

In C++ is there an idiomatic way to guard against the situation in which running a collection of actions causes the collection to be mutated?

c++

raii

在 C++ 中，是否有一种惯用的方法来防止运行操作集合导致集合发生变异的情况？