C++ 存储并调用具有未知参数的成员函数

我正在尝试存储一个未知类的成员函数，该类的参数未知，稍后将调用

我找到了以下代码片段以获取lambda：

template <auto Fn, typename T, typename R = void, typename... Args>
auto get_cb_inner(T* obj, R (T::*)(Args...) const) {
    return [obj](Args... args) -> R {
        return (obj->*Fn)(std::forward<Args>(args)...);
    };
}
template <auto Fn, typename T>
auto get_cb(T* obj) {
    return get_cb_inner<Fn, T>(obj, Fn);
}

模板
自动获取内部（T*obj，R（T:：*）（Args…）常量）{
返回[obj]（参数…参数）->R{
返回（obj->*Fn）（标准：向前（args）…）；
};
}
模板
自动获取cb（T*obj）{
返回get_cb_inner（obj，Fn）；
}

但我不知道如何存储它，然后在运行时使用正确的参数调用它

我有一个这样的结构：

struct Job {
    void execute(Data& data, const OtherData& otherData) const {
       // do job
    }
};

auto exe_fn = get_cb<&Job::execute>(new Job());

struct作业{
无效执行（数据和数据、常量其他数据和其他数据）常量{
//干
}
};
auto exe_fn=get_cb（new Job（））；

我想做的是将这个“execute”函数存储在lambda中，然后将它存储在一个类似向量的容器中（与其他可能具有不同参数的函数一起），该容器可以进行迭代和调用

编辑：

我使用@KamilCuk代码创建了这个包装器结构，没有内存泄漏/seg错误

template <typename... Args>
using exec_fn = std::function<void(Args...)>;
template <typename Job>
using job_ptr = std::unique_ptr<Job>;

template <typename J, typename R = void, typename... Args>
struct JobExecuteCaller {
    exec_fn<Args...> exec_fn;
    job_ptr<J> job_ptr;
    JobExecuteCaller (J* job, R (S::*f)(Args...) const)
        : job_ptr{job_ptr<J>(job)} {
        exec_fn = [this, f](Args... args) -> R {
            (job_ptr.get()->*f)(std::forward<Args>(args)...);
        };
    }
    void operator()(Args... args) { exec_fn(args...); }
};

auto process = JobExecuteCaller(new Job(), &Job::execute);
JobExecuteCaller(/*args ... */)

模板
使用exec_fn=std:：function；
模板
使用job_ptr=std:：unique_ptr；
模板
结构JobExecuteCaller{
行政长官;行政长官;；
作业(job)ptr作业(job)；
JobExecuteCaller（J*作业，R（S:：*f）（参数…）常量）
：job_ptr{job_ptr（job）}{
exec_fn=[this，f]（Args…Args）->R{
（job_ptr.get（）->*f）（std:：forward（args）…）；
};
}
void运算符（）（Args…Args）{exec_fn（Args…；}
};
自动处理=JobExecuteCaller（新作业（），&Job:：execute）；
JobExecuteCaller（/*参数…*/）

---

现在我只需要找出一种存储不同类型JobExecuteCaller的方法。

你是说你想要

std:：bind

#include <utility>
#include <new>
#include <iostream>
#include <functional>

struct Job {
    void execute(int a, int b) {
       std::cout << a << " " << b << std::endl;
    }
};

int main() {
    auto exe_fn = std::bind(&Job::execute, new Job(), 
        std::placeholders::_1, std::placeholders::_2);
    exe_fn(1, 2);
}

#包括
#包括
#包括
#包括
结构作业{
无效执行（整数a、整数b）{
std:：cout
自动my_lambda=[&]（）{my_obj.my_成员（my_arg1，my_arg2）；}
有什么问题吗？
#include <utility>
#include <new>
#include <iostream>
#include <functional>

template <typename T, typename R = void, typename... Args>
auto get_cb(T* obj, R (T::*f)(Args...)) {
    return [obj, f](Args... args) -> R {
        return (obj->*f)(std::forward<Args>(args)...);
    };
}

struct Job {
    void execute(int a, int b) {
        std::cout << a << " " << b << std::endl;
    }
};

int main() {
    auto exe_fn = get_cb(new Job(), &Job::execute);
    exe_fn(1, 2);
}