c++ - 在运行时基于底层元组类型生成元素

Question

我如何在编译时推断类型或对元素？我需要它根据参数类型进行正确的实例化(例如，对于 Integer_random_generator，它们可能是 long、int、unsigned int 等，对于 real_random_generator double、float 和其他 float )。我需要制作具有特定界限的生成器，如您在注释掉的第 63-77 行中所见。

#ifndef OPTIMALIZATION_HPP
#define OPTIMALIZATION_HPP

    #include<utility>
    #include<random>
    #include<experimental/random>
    #include<functional>
    #include<experimental/functional>
    #include<experimental/tuple>
    #include<algorithm>
    #include<type_traits>
    #include<iostream>

    #include"tuple_for_each.hpp"

    //ZNAJDZ/ZROB INDEKSOWANY DOSTEP DO TUPLI W CZASIE RUN-TIME'U
    namespace numerics{
        template<
            std::size_t population_size, std::size_t generations,
            typename Func,
            typename Compare, //GREATER, LESS, TYPE RETURNED BY FUNCTION
            typename Generator=std::default_random_engine,
            template<typename>
                typename RealDistribution=std::uniform_real_distribution,
            template<typename>
                typename IntegerDistribution=std::uniform_int_distribution,
            typename ...Ts
        >
        auto optimize(
                const Func& function, const Compare& comp,
                const std::pair<Ts,Ts>&... range
        ){

            std::size_t range_argument_count=sizeof...(range);
            static_assert(range_argument_count>2,
                    "Function needs at least two range arguments"
            );

            //RANDOM NUMBER GENERATORS
            auto real_random_generator=[&](const std::pair<auto,auto> range){
                std::cout << "DOUBLE" << std::endl;
                return std::bind(
                        RealDistribution<long double>(range.first,range.second),
                        //RealDistribution<decltype(range.first)>(range.first,range.second);
                        //HOW TO DEDUCE TYPE OF DISTRIBUTION FROM PAIR DURING COMPILE-TIME???
                        Generator()
                );
            };

            auto integer_random_generator=[&](const std::pair<auto,auto>& range){
            std::cout << "INTEGER" << std::endl;
                return std::bind(
                        IntegerDistribution<long long>(range.first,range.second),
                        //IntegerDistribution<decltype(range.first)>(range.first,range.second);
                        //HOW TO DEDUCE TYPE OF DISTRIBUTION FROM PAIR DURING COMPILE-TIME???
                        Generator()
                );
            };
            std::cout << integer_random_generator(std::get<0>(std::make_tuple(range...)))() << std::endl;
            std::cout << real_random_generator(std::get<1>(std::make_tuple(range...)))()<<std::endl;
            std::cout << integer_random_generator(std::get<2>(std::make_tuple(range...)))()<<std::endl;

            //GENERATORS DEPENDING ON TYPE, USED THROUGH WHOLE PROGRAM
            /*std::tuple<> generators;
            numerics::for_each(std::make_tuple(range...), [&](std::pair<auto,auto>& x){ //FOR_EACH SPRAWDZENIA
                    try{
                        generators=std::tuple_cat(
                                generators,
                                std::make_tuple(integer_random_generator(x.first)));
                    }
                    catch(...){
                        generators=std::tuple_cat(
                                generators,
                                std::make_tuple(real_random_generator(x.first)));
                    }
                }
            );*/
            return "pls work";
        }
    }
    #endif  

测试用例:

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

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

int main(){
    Function f{};
    auto comp=std::less<double>();
    auto x=numerics::optimize<100, 200>(
            f, comp,
            std::make_pair(-21, 37),
            std::make_pair(14.88, 88.41),
            std::make_pair(-13, 37)
    );
    std::cout << x << std::endl;

}

Answer 1

编写一个辅助函数来确定是制作一个实数生成器还是一个整数生成器。在这种情况下，它将基于范围中第一个参数的类型。我将留给您来确定如何检查第二个参数。 (我没有测试过这段代码，但我相信这个想法可行)。

template <class Range>
auto get_distribution(Range range, std::true_type)
{
    return real_random_generator(range);
}

template <class Range>
auto get_distribution(Range range, std::false_type)
{
    return integer_random_generator(range);
}

只需使用包扩展语法在每个范围内调用您的辅助函数

auto generators = std::make_tuple(get_distribution(ranges, 
                      std::is_floating_point<decltype(ranges.first)>{})...);

std::is_floating_point 决定了为每个范围调用哪个重载。

如果你喜欢棘手但更简洁的代码，你可以试试这个:

auto fs = std::make_tuple(integer_random_generator, real_random_generator);
auto generator = std::make_tuple(std::get<std::is_floating_point<decltype(ranges.first)>::value>(fs)(ranges)...);

构造一个由生成器生成的 lambda 的元组(如果它们不是对象，这将不起作用)并将条件用作元组的索引并立即调用它。我不提倡使用它，但我想我还是会分享它。