C++ c++；-如何使用<；随机>；填充std：：数组的步骤

我正在尝试新的方法来生成随机数并将其填充到数组中。到目前为止，我已经做到了

template<size_t SIZE>
void fill_array(array<int, SIZE>& a)
{
    default_random_engine dre;
    uniform_int_distribution<int> uid1(0, 1000);

    for (int i = 0; i < a.size(); i++)
    {
        a[i] = uid1(dre);

    }

}

模板
空白填充数组（数组和a）
{
默认\u随机\u引擎dre；
均匀分布uid1（0，1000）；
对于（int i=0；i

我的主文件非常简单，如下所示

    array<int, 10> a;

    Array3 a1;

    a1.fill_array(a);
    a1.print_array(a);

数组a；
阵列3 a1；
a1.填充阵列（a）；
a1.打印阵列（a）；

---

我以为每次调试时都能得到随机数，但每次都得到相同的数。奇怪的是，有时我会得到不同的数字，但同样的事情是，我必须调试多次才能得到新的数字。我做错了什么？

您没有将种子初始化为随机值。所以你的随机发生器总是从同一个位置开始

下面是一个如何初始化种子以从某个地方开始的示例。本质上，您需要一些不总是相同的源，以便生成器生成随机结果，时间是最常用的值

#include <iostream>
#include <chrono>
#include <random>

int main ()
{
  typedef std::chrono::high_resolution_clock clock;


  std::default_random_engine generator(clock::now().time_since_epoch().count());
  std::uniform_int_distribution<int> rand(0,1000);

  for(int i = 0;i < 10;i++)
 {
    std::cout << rand(generator) << std::endl;
 }

  return 0;
}

#包括
#包括
#包括
int main（）
{
typedef std:：chrono:：高分辨率时钟；
std:：默认的随机引擎生成器（时钟：：现在（）.time\u自\u历元（）.count（））；
标准：统一国际分布兰特（01000）；
对于（int i=0；i<10；i++）
{
std:：cout您没有将种子初始化为随机值。因此，您的随机生成器总是从同一位置启动

下面是一个如何从某个地方开始初始化种子的示例。本质上，您需要一些不总是相同的源，以便生成器生成随机结果，时间是最常用的值

#include <iostream>
#include <chrono>
#include <random>

int main ()
{
  typedef std::chrono::high_resolution_clock clock;


  std::default_random_engine generator(clock::now().time_since_epoch().count());
  std::uniform_int_distribution<int> rand(0,1000);

  for(int i = 0;i < 10;i++)
 {
    std::cout << rand(generator) << std::endl;
 }

  return 0;
}

#包括
#包括
#包括
int main（）
{
typedef std:：chrono:：高分辨率时钟；
std:：默认的随机引擎生成器（时钟：：现在（）.time\u自\u历元（）.count（））；
标准：统一国际分布兰特（01000）；
对于（int i=0；i<10；i++）
{
std:：cout即使使用，也不能保证每次都获得不同的序列：

std:：random_设备可以按照
实现定义的伪随机数引擎，如果
非确定性源（如硬件设备）不可用于
在这种情况下，每个std:：random_设备对象可能
生成相同的数字序列

例如，在Windows上较旧的stdlibc++的g++实现中就出现了这种情况

此外，由于性能问题，
random_设备
通常仅用于（一次）为伪随机位生成器（如Mersenne twister引擎）播种（）

填充函数的实现方式如下：

#include <iostream>
#include <array>
#include <iterator>
#include <random>
#include <algorithm>

template< class Iter >
void fill_with_random_int_values( Iter start, Iter end, int min, int max)
{
    static std::random_device rd;    // you only need to initialize it once
    static std::mt19937 mte(rd());   // this is a relative big object to create

    std::uniform_int_distribution<int> dist(min, max);

    std::generate(start, end, [&] () { return dist(mte); });
}

int main()
{
    std::array<int, 10> a;

    fill_with_random_int_values(a.begin(), a.end(), 0, 1000);

    for ( int i : a ) std::cout << i << ' ';
    std::cout << '\n';
}

#包括
#包括。
即使使用，也不能保证每次都获得不同的序列：

std:：random_设备可以按照
实现定义的伪随机数引擎，如果
非确定性源（如硬件设备）不可用于
在这种情况下，每个std:：random_设备对象可能
生成相同的数字序列

例如，在Windows上较旧的stdlibc++的g++实现中就出现了这种情况

此外，由于性能问题，
random_设备
通常仅用于（一次）为伪随机位生成器（如Mersenne twister引擎）播种（）

填充函数的实现方式如下：

#include <iostream>
#include <array>
#include <iterator>
#include <random>
#include <algorithm>

template< class Iter >
void fill_with_random_int_values( Iter start, Iter end, int min, int max)
{
    static std::random_device rd;    // you only need to initialize it once
    static std::mt19937 mte(rd());   // this is a relative big object to create

    std::uniform_int_distribution<int> dist(min, max);

    std::generate(start, end, [&] () { return dist(mte); });
}

int main()
{
    std::array<int, 10> a;

    fill_with_random_int_values(a.begin(), a.end(), 0, 1000);

    for ( int i : a ) std::cout << i << ' ';
    std::cout << '\n';
}

#包括
#包括。
以下内容：

#include <random>
#include <array>
#include <algorithm>

template<class Engine, class Integer, size_t SIZE>
void fill_array(Engine& eng, std::array<Integer, SIZE>& a, Integer lower = 0, Integer upper = 1000)
{
    std::uniform_int_distribution<Integer> uid1(lower, upper);

    std::generate(a.begin(), a.end(), [&]
    {
        return uid1(eng);
    });
}

int main()
{
    std::random_device rnd;  // a source of machine-wide entropy
    std::default_random_engine eng(rnd()); // use it to initialise the psuedo-random engine

    std::array<int, 100> arr;
    fill_array(eng, arr);
}

#包括
#包括
#包括
样板
空填充数组（引擎和工程，标准：：数组和a，整数下限=0，整数上限=1000）
{
标准：均匀分布uid1（下、上）；
std:：generate（a.begin（），a.end（），[&]
{
返回uid1（英语）；
});
}
int main（）
{
std:：random_device rnd；//机器范围熵的来源
std:：default_random_engine eng（rnd（））；//使用它初始化psuedo随机引擎
std：：阵列arr；
填充阵列（eng、arr）；
}
大致如下：

#include <random>
#include <array>
#include <algorithm>

template<class Engine, class Integer, size_t SIZE>
void fill_array(Engine& eng, std::array<Integer, SIZE>& a, Integer lower = 0, Integer upper = 1000)
{
    std::uniform_int_distribution<Integer> uid1(lower, upper);

    std::generate(a.begin(), a.end(), [&]
    {
        return uid1(eng);
    });
}

int main()
{
    std::random_device rnd;  // a source of machine-wide entropy
    std::default_random_engine eng(rnd()); // use it to initialise the psuedo-random engine

    std::array<int, 100> arr;
    fill_array(eng, arr);
}

#包括
#包括
#包括
样板
空填充数组（引擎和工程，标准：：数组和a，整数下限=0，整数上限=1000）
{
标准：均匀分布uid1（下、上）；
std:：generate（a.begin（），a.end（），[&]
{
返回uid1（英语）；
});
}
int main（）
{
std:：random_device rnd；//机器范围熵的来源
std:：default_random_engine eng（rnd（））；//使用它初始化psuedo随机引擎
std：：阵列arr；
填充阵列（eng、arr）；
}
我是否可以建议使用std:：vector而不是数组。如果使用std:：rand函数，您可以使用
srand（time（NULL））；
为它添加时间种子。
当然，您需要为此包含time.h。您可以使用
generate（a.begin（），a.end（），rand）填充向量不使用循环。
每次都会给你一个新的随机数序列。
我可以建议使用std:：vector而不是数组。如果你使用std:：rand函数，你可以用
srand（time（NULL））；
给它加上时间种子。
当然你需要为此包含time.h。你可以用
generate填充向量（a.开始（），a.结束（），兰德）
不使用循环。这将每次为您提供一个新的随机数序列。
如果您想要非确定性结果，请使用
std:：random\u device
…并初始化例如在“std:：uniform\u int\u分布”中使用的“std:：mt19937”。此外，您不需要编写循环来填充
std:：array
或任何序列容器。见，谢谢，我将检查std:：generate out。为了记录在案，我承认我本可以更好地表述这个问题。感谢您的帮助。如果您想要非确定性结果，请使用
std:：random\u device
…并初始化例如“std:：mt19937”，您在“std:：uniform\u int\u分发”中使用它。此外，您还可以不需要编写循环来填充
std:：array
或任何序列容器。请参阅，谢谢