如何在容器中返回不同的函数及其参数？ 我试图在C++中实现类似于ReDux的一些东西。这个想法是，对于发生的每个事件，我都有一个动作映射到它。每个动作都是一个纯函数，它接受一个状态作为输入，它将返回一个新的状态，也有新的副作用。我有一个分派函数，当一个事件发生时，它调用动作，获取新的状态和副作用，它更新状态，并实现副作用

在伪代码中，分派函数可能如下所示：

template <class F, class... Args>
void Store::dispatch(F&& f, Args&&... args)
{
    auto [newState, effect] = std::forward<F>(f)(_state, std::forward<Args>(args)...);
    _state = newState;
    if (effect)
       effect(*this)
}

std::pair<State, Effect> fellOnFloor(State state)
{
    auto effect = [isDead = state.isDead](auto& ctx) {
        ctx.rollOver();
        if (isDead) {
            ctx.bury(feet(6));
        }
    };

    state.isBuried = true;
    return {state, effect};
}

模板
空存储区：：分派（F&&F，参数&&…参数）
{
auto[newState，effect]=std:：forward（f）（状态，std:：forward（args）…）；
_状态=新闻状态；
如果（影响）
效果（*本）
}

操作如下所示：

template <class F, class... Args>
void Store::dispatch(F&& f, Args&&... args)
{
    auto [newState, effect] = std::forward<F>(f)(_state, std::forward<Args>(args)...);
    _state = newState;
    if (effect)
       effect(*this)
}

std::pair<State, Effect> fellOnFloor(State state)
{
    auto effect = [isDead = state.isDead](auto& ctx) {
        ctx.rollOver();
        if (isDead) {
            ctx.bury(feet(6));
        }
    };

    state.isBuried = true;
    return {state, effect};
}

std:：结对地板（状态）
{
自动效果=[isDead=state.isDead]（自动和ctx）{
ctx.rollOver（）；
如果（isDead）{
ctx.bury（英尺（6））；
}
};
state.isburned=true；
返回{state，effect}；
}

目前，对于效果，我只返回一个lambda块。但我希望它可以是某种数据结构，这样我就可以简单地检查返回的数据，看看它是否具有单元测试中生成的正确副作用

std::pair<State, Effects> fellOnFloor(State state)
{
    auto effects = Effects();
    effects.insert(rollOver);
    if (state.isDead)
        effects.insert(bury, feet(6));

    state.isBuried = true;
    return {state, effects};
}

void testFellOnFloor()
{
    State state{.isDead = true};
    State expectedState{.isDead = true, .isBuried = true};
    auto expectedEffects = Effects{Effect(rollOver), Effect(bury, feet(6))};

    auto [newState, effects] = fellOnFloor(state);
    assert_equal(expectedState, newState);
    assert_equal(expectedEffects, effects);
}

std:：结对地板（状态）
{
自动效果=效果（）；
效果。插入（滚动）；
如果（state.ishead）
效果。插入（埋，脚（6））；
state.isburned=true；
返回{state，effects}；
}
void testFellOnFloor（）
{
状态{.isDead=true}；
状态expectedState{.isDead=true，.isBulled=true}；
自动预期效果=效果{效果（翻滚），效果（掩埋，脚（6））}；
自动[新闻状态，效果]=fellOnFloor（状态）；
断言_等于（expectedState，newState）；
断言相等（预期效果、效果）；
}

为了实现这一点，我需要一个

Effects

容器，它包含不同类型的副作用函数及其参数。这在JavaScript或Culjure中是很直观的，但是它在C++中非常困难。

---

首先，函数具有不同的签名，因此它们已经是不同的类型。不同的签名具有不同的参数。有一个好的数据结构来保存它们吗？

因此，在我看来，这是一个很好的问题，但也是一个很难简明扼要、笼统而准确地回答的问题。在我看来，您需要的是“C++命令模式实现”。甚至这也是有争议的。但这是一个不错的开始。另一件你可以看到的是<代码>变量的参数，并且记住C++中的<>代码>对象< /> >是“代码>空洞*/CODE >。尽管您始终可以为所有参数或参数容器（或两者）创建自己的基类型。任何类型的安全，你可以保持是伟大的。但是我会先尝试第一个建议。要编辑我自己，

void*

和

Object

是不等价的。但是……为了“让被叫方决定这是什么类型的对象”，它们在某种程度上是可以互换的。