C++ C++；通过std:：experimental:：apply函数从元组获取参数包

我有以下关于std：：实验：：应用的问题。据我所知，它接受函数对象和元组，然后将元组扩展为参数包，应用于给定的函子。不幸的是，当我试图编译（函数调用）时，下面的代码中存在类型不匹配

模板
constexpr自动优化（Func函数，const std:：pair…range）{//检查函数是否为函子，待定！
静态断言（sizeof…（range）>2，“函数至少需要两个参数”）；
//随机数发生器与校验算法类型
constexpr decltype（自动）生成_编号=[&]（标准：：对范围）{
静态_断言（std:：is_算术（），
“std:：pair的第一个参数必须是算术！”；
静态_断言（std:：is_算术（），
“std:：pair的第二个参数必须是算术参数！”；
返回std:：bind（分布（range.first，range.second），Generator（））；
};
//单个随机个体发生器
decltype（auto）generate_random_individual=[&]（）{//异步运行此函数，待定！
auto-genype=std:：make_tuple（generate_number（range））；//工作正常
//关键功能和本文的主题
自动键=标准：：实验：：应用（功能，基因型）；
//关键功能和本文的主题
//返回std：：make_对（键，基因型）；
};
生成随机个体（）；
}

这是我的测试用例（在没有实验：：apply的情况下应该可以很好地编译）

#包括
#包括
#包括“优化.hpp”
类函数{
公众：
函数（）=默认值；
双运算符（）（双x、双y、双z）{
返回（std:：exp（x+1.25）*std:：pow（y，z））/std:：exp（（x*y）/z）；
}
};
int main（）{
函数f{}；
double x=优化（f，std：：make_pair（-21,37），std：：make_pair（22.5,88.11），std：：make_pair（-13,37））；
std:：cout问题的核心是
Function:：operator（）
不是
const

另外请注意，在您使用的两个位置中，
decltype（auto）
，都可以使用
auto
。
修复您的代码格式。是的，我的错，谢谢您的输入，对于询问堆栈溢出问题，已经太晚了。
        template<std::size_t population_size, std::size_t generations, typename Func,
            class Compare=std::greater<>,
            class Generator=std::default_random_engine,
            class Distribution=std::uniform_real_distribution<>>

                constexpr auto optimize(Func function, const std::pair<auto,auto>... range){ //CHECKING IF FUNCTION IS A FUNCTOR, TBD!

                    static_assert(sizeof...(range)>2, "Function needs at least two arguments");

                    //RANDOM NUMBER GENERATOR AND CHECKING ARITHMETIC TYPES
                    constexpr decltype(auto) generate_number=[&](std::pair<auto,auto> range){
                                static_assert(std::is_arithmetic<std::tuple_element_t<0, decltype(range)>>(),
                                        "First argument of std::pair has to be arithmetic!");
                                static_assert(std::is_arithmetic<std::tuple_element_t<1, decltype(range)>>(),
                                        "Second argument of std::pair has to be arithmetic!");
                                return std::bind(Distribution(range.first,range.second),Generator());
                    };

                    //SINGLE RANDOM INDIVIDUAL GENERATOR
                    decltype(auto) generate_random_individual=[&](){ //RUN THIS FUNCTION ASYNCHRONOUSLY, TBD!
                        auto genotype=std::make_tuple(generate_number(range)()...); //WORKS FINE


    //CRITICAL FUNCTION AND THE TOPIC OF THIS POST
                         auto key=std::experimental::apply(function,genotype);
    //CRITICAL FUNCTION AND THE TOPIC OF THIS POST

                        //return std::make_pair(key,genotype);
                    };
                    generate_random_individual();
}

#include<utility>
#include<iostream>
#include"optimalization.hpp"

class Function{
    public:
        Function()=default;
        double operator()(double x, double y, double z){
            return (std::exp(x+1.25)*std::pow(y,z))/std::exp((x*y)/z);
        }
};

int main(){
    Function f{};
    double x=optimize<100, 200>(f, std::make_pair(-21, 37), std::make_pair(22.5, 88.11), std::make_pair(-13, 37));
    std::cout << x << std::endl;

}

#include <cstddef>
#include <functional>
#include <random>
#include <experimental/tuple>
#include <type_traits>
#include <utility>

template<
    std::size_t population_size, std::size_t generations,
    typename Func,
    typename Compare = std::greater<>,
    typename Generator = std::default_random_engine,
    typename Distribution = std::uniform_real_distribution<>,
    typename... RangeElemT
>
auto optimize(Func function, std::pair<RangeElemT, RangeElemT> const... range) {
    static_assert(sizeof...(range) > 2, "Function needs at least two arguments");

    auto generate_number = [&](auto range) {
        static_assert(
            std::is_arithmetic<std::tuple_element_t<0, decltype(range)>>{},
            "First argument of std::pair has to be arithmetic!"
        );
        static_assert(
            std::is_arithmetic<std::tuple_element_t<1, decltype(range)>>{},
            "Second argument of std::pair has to be arithmetic!"
        );

        return std::bind(Distribution(range.first, range.second), Generator{});
    };

    auto genotype = std::make_tuple(generate_number(range)()...);
    auto key = std::experimental::apply(function, genotype);
    return std::make_pair(key, genotype);
}

#include <cmath>

struct Function {
    double operator ()(double x, double y, double z) const {
        return std::exp(x + 1.25) * std::pow(y, z) / std::exp(x * y / z);
    }
};

#include <iostream>
#include <boost/type_index.hpp>

int main() {
    namespace bti = boost::typeindex;

    Function f{};
    auto x = optimize<100, 200>(
        f,
        std::make_pair(-21, 37),
        std::make_pair(22.5, 88.11),
        std::make_pair(-13, 37)
    );
    std::cout
        << bti::type_id_with_cvr<decltype(x)>().pretty_name() << '\n'
        << x.first << " :: "
        << std::get<0>(x.second) << ", "
        << std::get<1>(x.second) << ", "
        << std::get<2>(x.second) << '\n';
}