C++ C++；返回相同数字的STL随机数生成

我还没有发现类似的问题，所以如果已经有人问过，我道歉。无论如何，我的功能如下：

#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>

namespace numerics{
    template<
        std::size_t population_size, std::size_t generations,
        typename Func,
        typename Compare,
        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>&... ranges
    ){

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

        //RANDOM NUMBER GENERATORS LAMPDA FUNCTIONS
        auto real_random_generator=[&](const std::pair<auto,auto> range){
            return std::bind(
                    RealDistribution<decltype(range.first)>(range.first,range.second),
                    Generator()
            );
        };

        auto integer_random_generator=[&](const std::pair<auto,auto>& range){
            return std::bind(
                    IntegerDistribution<decltype(range.first)>(range.first,range.second),
                    Generator()
            );
        };

        //MAKING TUPLE OF GENERATORS FOR SPECIFIC RANGES ARGUMENTS
        auto generator_objects=std::make_tuple(
                integer_random_generator,
                real_random_generator
        );
        auto generators=std::make_tuple(
                std::get<std::is_floating_point<decltype(ranges.first)>::value> //UPDATE FOR C++17
                (generator_objects)(ranges)...
        );
        //RANDOMIZES NUMBERS FINE!
        std::cout << std::get<0>(generators)() << std::endl;
        std::cout << std::get<0>(generators)() << std::endl;

        //SINGLE RANDOM INDIVIDUAL GENERATOR
        auto generate_random_individual=[&](const auto& gen){
            auto genotype=std::experimental::apply(
                    [&](auto... x){
                        return std::make_tuple(x()...);
                    },
                    gen
            );
            return std::make_pair(
                    std::experimental::apply(function,genotype),
                    genotype
            );
        };
        //RETURN THE SAME NUMBER!
        auto foo=generate_random_individual(generators);
        auto foo2=generate_random_individual(generators);
        auto foo3=generate_random_individual(generators);
        auto foo4=generate_random_individual(generators);
        std::cout << std::get<0>(foo.second) << std::endl;
        std::cout << std::get<0>(foo2.second) << std::endl;
        std::cout << std::get<0>(foo3.second) << std::endl;
        std::cout << std::get<0>(foo4.second) << std::endl;
        return 1.;
}}
#endif

\ifndef优化\u水电站
#定义水电站优化
#包括
#包括
#包括
#包括
#包括
#包括
#包括
#包括
#包括
名称空间数字{
模板<
std:：size\u t population\u size，std:：size\u t generations，
typename Func，
类型名比较，
typename生成器=标准：：默认\u随机\u引擎，
模板
typename RealDistribution=std:：统一实分布，
模板
typename IntegerDistribution=std:：统一整数分布，
typename…Ts
>
自动优化(
常量函数和函数，常量比较和比较，
常数std:：pair&…ranges
){
constepr std:：size\u t range\u argument\u count=sizeof…（范围）；
静态断言（范围参数计数>2，
“函数至少需要两个范围参数”
);
//LAMPDA函数的随机数发生器
自动实数随机发生器=[&]（常数标准：：对范围）{
返回std:：bind(
重新分配（范围第一，范围第二），
发电机（）
);
};
自动整数\u随机\u生成器=[&]（常量标准：：对和范围）{
返回std:：bind(
整数分布（range.first，range.second），
发电机（）
);
};
//为特定范围参数生成生成器元组
自动生成器\u objects=std:：make\u元组(
整数随机发生器，
实随机发生器
);
自动生成器=标准：：生成元组(
std:：get//C++17的更新
（生成器对象）（范围）。。。
);
//随机数很好！
std:：cout每次你想使用随机数时，你都在创建新的生成器。我不知道这些生成器的种子是如何生成的，但很明显，你创建的每个生成器实例都使用相同的种子。你应该做的是创建一个所有发行版都使用的生成器

您可能想看看boost random类提供了什么，并检查其中的一些示例。
每次您想使用随机数时，都会创建新的生成器。我不知道这些生成器的种子是如何生成的，但很明显，您创建的每个生成器实例都使用相同的种子。您应该做什么ing正在创建所有发行版都使用的单一生成器

您可能想看看boost random类提供了什么，并检查其中的一些示例。
问题已解决-我在传入一个函数时忘了添加&即：

auto genotype=std::experimental::apply(
                    [&](auto&... x){ //THIS LINE!
                        return std::make_tuple(x()...);
                    },
                    gen
            );

结果，正如你们大多数人所说，它复制了生成器，谢谢你们的输入。
问题解决了-我在传递我的一个函数时忘了添加&即：

auto genotype=std::experimental::apply(
                    [&](auto&... x){ //THIS LINE!
                        return std::make_tuple(x()...);
                    },
                    gen
            );

结果，正如你们大多数人所说，它复制了生成器，谢谢你们的输入。
TL；DR；Seed只有一次。我看不出你们在哪里为生成器设置了种子（我可能错过了一些东西）-如果不进行种子设定，您将始终获得相同的序列。@JesperJuhl我必须对其进行种子设定吗？我使用随机库，我希望对generate_random_individual的每个调用都有不同的输出。似乎此lampda函数使用相同的生成器，因为它通过lampda调用获取这些生成器，因此它应该返回不同的随机值太长了，读不下去了，你需要去创建最小的例子。是的，你必须把它们种子化，或者每个程序的调用都有相同的值。你需要重用生成器，不要重新创建它们，因为它会再次重置随机序列。TL；DR；种子只有一次。我不知道你在哪里生成你的生成器。（我可能错过了什么）-如果不进行种子设定，您将始终获得相同的序列。@JesperJuhl我必须对其进行种子设定吗？我使用随机库，我希望对generate_random_individual的每个调用都有不同的输出。似乎此lampda函数使用相同的生成器，因为它通过lampda调用获取这些生成器，因此它应该返回不同的随机值（请参阅两个调用：std:：cout您需要创建最少的示例。是的，您必须对它们进行种子设定，否则程序的每次调用都将具有相同的值。此外，您需要重用生成器，而不要重新创建它们，因为这将再次重置随机序列。“您可能想看看boost random类提供了什么。”没有比当前标准IMO更好的了。是的。不要重新生成生成器。重新使用它们（并正确地为它们设定种子-一次）。我真的重新生成了生成器？如果你能为我指出，我应该在哪里这样做？你调用构造函数生成器（）的每个地方您正在创建一个新的生成器。您应该传递一个生成器作为引用，而不是调用构造函数。@并且我仅在创建generators变量时使用generator（）。之后，我使用lampda函数generate_random_individual中重载（）的每个生成器…“您可能想看看boost random类提供了什么”没有比当前标准IMO更好的了。是的。不要重新生成生成器。重新使用它们（并正确地为它们设定种子-一次）。我真的重新生成了生成器？如果你能为我指出，我应该在哪里这样做？你调用构造函数生成器（）的每个地方您正在创建一个新的生成器。您应该传递一个生成器作为引用，而不是调用构造函数。@AND并且我仅在创建generators变量时使用generator（）。之后，我使用lampda函数generate\u random\u individual中重载（）的每个生成器。。。