C++ 从模板参数包向函数对象的成员传递指针

下面是示例代码，它演示了我正在尝试做的事情

基本上，我希望向类方法传递多个指向成员的指针，该类方法接受

std:：function

对象和传递给目标函数对象的变量数或参数

这些变量参数可以是任何东西：变量、指向成员的指针等

我在使用普通变量时没有问题，但是如果参数是指向成员的指针，但函数对象需要POD数据类型，那么如何展开Parameter pack呢

如何获取参数包中指向成员的指针值并将其传递给函数对象

#include <cstddef>
#include <functional>


class Test
{
public:
    inline Test(std::uint32_t max);

    template<typename ReturnType, typename... Args>
    using Algorithm = std::function<ReturnType(Args...)>;

    // pointer to member
    // not used but would like to make use of it in 'RunTargetAlgo'
    template<typename T>
    using ParamType = T Test::*;

    // exectutor
    template<typename ReturnType, typename... Args, typename... Params>
    inline double RunTargetAlgo(Algorithm<ReturnType, Args...> target, Params... params);

    std::uint32_t mLoop = 0;
    const std::size_t mLoopMax;
    double mPrecision = 0;
};

Test::Test(std::uint32_t max) :
    mLoopMax(max)
{
}

template<typename ReturnType, typename ...Args, typename ...Params>
double Test::RunTargetAlgo(Algorithm<ReturnType, Args...> target, Params ...params)
{
    while (++mLoop <= mLoopMax)
        mPrecision += target(params...);    // How if Params == Test::ParamType ??

    // ... in real code we measure bunch of other stuff here...

    return mPrecision;
}

template<typename RetrunType>
RetrunType TestAlgorithm(std::uint32_t x, std::uint32_t y)
{
    // ...
    return RetrunType();
}

int main()
{
    namespace pl = std::placeholders;

    Test::Algorithm<double, std::uint32_t, std::uint32_t> algo =
        std::bind(TestAlgorithm<double>, pl::_1, pl::_2);

    Test t(50);

    // this works just fine!
    t.RunTargetAlgo(algo, 3u, 4u);

    // but how to run this?
    // I need pass fresh data to target algorithm, value of
    // pointer to members may change anytime.
    // but main issue here is how to extract these pointer from
    // parameter pack into actual values, but inside Test::RunTargetAlgo?
    t.RunTargetAlgo(algo, &Test::mLoop, &Test::mLoopMax);

    return 0;
}

#包括
#包括
课堂测试
{
公众：
在线测试（标准：uint32_t max）；
模板
使用算法=std:：函数；
//指向成员的指针
//未使用，但希望在“RunTargetAlgo”中使用
模板
使用ParamType=T检验：：*；
//执行导师
模板
内联双RunTargetAlgo（算法目标，参数…参数）；
std:：uint32_t mLoop=0；
const std:：size\u t mLoopMax；
双精度=0；
};
测试：测试（标准：uint32\u t最大值）：
mLoopMax（最大值）
{
}
模板
双重测试：：RunTargetAlgo（算法目标，参数…参数）
{
正如注释中所讨论的（++mLoop，假设所有参数都需要相同的操作，您只需在参数包扩展中应用任何解引用/成员访问操作即可。例如，对于应该访问
此
实例的成员指针：

target(this->*params...);

或者，如果您直接传递对象指针（我觉得这更直接）：

如注释中所述，假设所有参数都需要相同的操作，则只需在参数包扩展中应用任何解引用/成员访问操作即可。例如，对于应访问
此
实例的成员指针：

target(this->*params...);

或者，如果您直接传递对象指针（我觉得这更直接）：

为什么需要成员指针？您希望在
RunTargetAlgo
中引用哪个实例的成员？
t
？如果需要，为什么不只是普通的对象指针：
t.RunTargetAlgo（algo，&t.mLoop，&t.mLoopMax）
？@walnut是的，这也是可能的，但问题是这些参数仍然是地址而不是实际值，我需要将这些地址解引用为值，并从
RunTargetAlgo
内的参数包中展开它们；
target（*params…）；
？嗯，我给你一杯啤酒为什么需要成员指针？您希望在
RunTargetAlgo
中引用哪个实例的成员？
t
？如果需要，为什么不只是普通的对象指针：
t.RunTargetAlgo（algo，&t.mLoop，&t.mLoopMax）
？@walnut是的，这也是可能的，但问题是这些参数仍然是地址而不是实际值，我需要将这些地址解引用为值，并从
RunTargetAlgo
内的参数包中展开它们；
target（*params…）；
？嗯，我给你一杯啤酒