如何使用 void* 参数列表调用通用 std::function？

Question

我有一个 std::map 存储一些我想稍后调用的任意方法。

map<string, function<void(void)>> methods;

template<typename R, typename ...P>
void storeMethod(const string& name, const function<R(P...)>& method) {
    methods[name] = method;
}    

在调用时，我在vector<void*> 中获取调用方法的参数，其中第一个元素是我将存储返回值的指针。
如何自动将这些参数转换为我要调用的方法的相应类型？
我应该以某种方式存储类型吗？

void callMethod(const string& name, vector<void*> parameters) {
    auto method = methods[name];
    // How to call 'method' with all the parameters casted to the required types?
}

例如，如果我最初用function<int(string a, float b)> 调用storeMethod()，我需要一个通用的方式在callMethod() 中调用它，如下所示：

*((int*)parameters[0]) = method(*((string*)parameters[1]), *((float*)parameters[2]));

Answer 1

您必须将method 包装在可以记住参数类型的东西中。

struct OpaqueFunction {
    virtual std::any call(const std::vector<std::any> &) = 0;
};

template <typename R, typename ... Args>
struct OpaqueFunctionImpl : OpaqueFunction {
    OpaqueFunctionImpl(std::function<R(Args...)> f) : f(std::move(f)) {}

    std::any call(const std::vector<std::any> & parameters) override {
        return call_impl(parameters, std::index_sequence_for<Args...>{});
    }
private:
    template <size_t... I>
    std::any call_impl(const std::vector<std::any> & parameters, std::index_sequence<I...>) {
        return f(std::any_cast<Args>(parameters.at(I))...);
    }
    std::function<R(Args...)> f;
};

class Methods {
    std::map<std::string, std::unique_ptr<OpaqueFunction>> methods;
public:
    template<typename R, typename ... Args>
    void storeMethod(std::string name, std::function<R(Args...)> method) {
        methods[std::move(name)] = std::make_unique<OpaqueFunctionImpl<R, Args...>>(std::move(method));
    }

    template<typename R>
    R callMethod(const std::string & name, const std::vector<std::any> & parameters) {
        return std::any_cast<R>(methods.at(name)->call(parameters));
    }
};

Answer 2

您可以为接受不同类型参数的函数创建 Callable 类型，然后将其存储在 vector 中（为简单起见，此处使用向量）：

struct Callable {
    Callable(std::function<void()> f) : zero_(std::move(f)) {}
    Callable(std::function<void(int)> f) : one_(std::move(f)) {}

    void operator()() { zero_(); }
    void operator()(int x) { one_(x); }

    std::function<void()> zero_;
    std::function<void(int)> one_;
};

//vector of methods
std::vector<Callable> methods;

要存储方法，您可以使用template-ized 函数或仅使用重载。我在这里使用重载：

void addMethod(std::function<void()> func)
{
    methods.push_back(Callable(func));
}

void addMethod(std::function<void(int)> func)
{
    methods.push_back(Callable(func));
}

然后最后调用一个函数：

template<typename ...Args>
void callMethod(int idx, Args ...args) {
    auto method = methods[idx];

    method(std::forward<Args>(args)...);
 }

主要：

int main()
{
    addMethod([](int x){
        std::cout << "I am function(int)" << x << '\n';
    });

    addMethod([](){
        std::cout << "I am just function()\n";
    });


    callMethod(0, 200);
    callMethod(1);
}

这是我能想到的最简单的实现方式。他们可能是更好的方法，我真的很好奇。

在这里试试：https://godbolt.org/z/HS5a7p