C++ 当一个函数接受多个参数时，如何组合两个函数？

我正在研究一个小的快速测试类，它将执行一个函数/函子，以及生成要执行的函数输入的函数/函子

例如，如果第一个函数是

sqrt（x）

，而第二个函数有一个状态并且正在进行计数，我希望类 执行

sqrt(0.0);  
sqrt(1.0);
...

对于一些迭代次数

我可以相对容易地做到这一点（2

std:：function

s或模板），但是 若第一个函数包含多个参数，那个么如何实现呢？我只能考虑强制一个函数使用

tuple

，并强制另一个函数返回

tuple

，但这看起来很难看，并强制测试函数使用接口

编辑：我现在拥有的：

template <typename Func, typename ArgGen>
class Magic
{
    std::function<double (time_t)> time_to_frequency;
    std::set<decltype(Func()(ArgGen()()))> results_ok;
    std::set<decltype(Func()(ArgGen()()))> results_fail;
    ArgGen ag;
    Func f;
public:
    Magic(std::set<decltype(Func()(ArgGen()()))> results_ok, std::set<decltype(Func()(ArgGen()()))> results_fail,  std::function<double (const time_t)> time_to_frequency) : 
               results_ok(results_ok), results_fail(results_fail),  time_to_frequency(time_to_frequency)
    {}
    Magic() 
    {}
    void run(const int n)
    {
       bool success=true;
       for (int i=0; i< n; ++i)
       {
           auto rv = f(ag());
           const bool result_ok = results_ok.count(rv);
           if (result_ok)
           {
               printf(".");
           }
           else
           {
               success = false;
               std::cout << i <<": value unexpected "<< std::endl;
           }

       }
       std::cout << "run succeeded: " << std::boolalpha << success;
    }

};

模板
课堂魔术
{
std：：功能时间到频率；
std：：设置结果_ok；
std：：设置结果\u失败；
ArgGen ag；
函数f；
公众：
魔术（标准：：设置结果\u正常，标准：：设置结果\u失败，标准：：功能时间\u至\u频率）：
结果正常（结果正常）、结果失败（结果失败）、时间到频率（时间到频率）
{}
魔术
{}
无效运行（常数整数n）
{
布尔成功=真；
对于（int i=0；istd:：cout我会让ArgGen返回一个元组，然后用以下内容解压元组：

    #include <tuple>
    #include <iostream>

    template <class Func, class ... Args>
    struct invoke_from_tuple_helper
    {
        typedef decltype(std::declval<Func>()(std::declval<Args>()...)) return_type;

        template <unsigned total, std::size_t ... Indices>

        static return_type apply_helper(Func && f, std::tuple<Args...> && params,
                                 typename std::enable_if<total == sizeof...(Indices)>::type* =NULL)
        {
            return f(std::forward<Args>(std::get<Indices>(params))...);
        }

        template <unsigned total, std::size_t ... Indices>
        static return_type apply_helper(Func && f, std::tuple<Args...> && params,
                                 typename std::enable_if<(total > sizeof...(Indices)) >::type* =NULL)
        {
            return apply_helper<
                total, Indices..., sizeof...(Indices)>
                (std::forward<Func>(f), std::forward<std::tuple<Args...> >(params));
        }

        static return_type apply(Func && f, std::tuple<Args...> && params)
        {
            return apply_helper<sizeof...(Args)>(std::forward<Func>(f),
                                                 std::forward<std::tuple<Args...> >(params));
        }

    };

    template <class Func, class ... Args>
    typename invoke_from_tuple_helper<Func,Args...>::return_type
    invoke_from_tuple(Func && f, std::tuple<Args...>&&params)
    {
        return invoke_from_tuple_helper<Func,Args...>::apply(std::forward<Func>(f),
                                                             std::forward<std::tuple<Args...> >(params));
    }

    void f(int, long, std::tuple<int,long>)
    {
        std::cout << "I'm on the inside\n";
    }

    int main()
    {
        invoke_from_tuple(f, std::tuple<int,long,std::tuple<int,long> >());
        return 0;
    }

#包括
#包括
模板
结构从\u元组\u助手调用\u
{
typedef decltype（std：：declval（）（std：：declval（）…）返回类型；
模板
静态返回类型应用辅助程序（Func&&f，std:：tuple&¶ms，
typename std:：enable_如果：：type*=NULL）
{
返回f（std:：forward（std:：get（params））…）；
}
模板
静态返回类型应用辅助程序（Func&&f，std:：tuple&¶ms，
typename std:：enable_if sizeof…（索引））>：：type*=NULL）
{
返回应用辅助程序<
总计，指数…，规模…（指数）>
（std：：forward（f），std：：forward（params））；
}
静态返回类型应用（Func&&f，std:：tuple&¶ms）
{
返回apply_helper（标准：：forward（f），
std：：转发（params））；
}
};
模板
typename从\u元组调用\u帮助程序：：返回\u类型
从元组调用（Func&&f，std:：tuple&¶ms）
{
返回invoke_from_tuple_helper:：apply（std:：forward（f）），
std：：转发（params））；
}
void f（int，long，std:：tuple）
{
STD:：也许是用模板？！你能提供一个你想要达到的代码样例吗？你的问题不清楚。举一个你想使用的非一元函数的例子，以及你想用它来做什么。@ No.NethEthEnter，C++不支持多个返回值，所以像<>代码> STD:：tuple < /C> >似乎是你最好的选择。如果我现在正确理解了您的问题，那么它不是将值放入
Func
，而是从
Gen
@nosenseal中检索多个值，正如nijansen所说，如果没有元组，您的生成函数不能返回多个值。尽管您可以使用so解压元组以调用测试函数方法。避免修改测试函数。