<random>

Mendefinisikan fasilitas untuk pembuatan angka acak, memungkinkan pembuatan angka acak yang didistribusikan secara seragam.

Persyaratan

Header: <random>

Namespace: std

Catatan

Pustaka <random> menggunakan pernyataan '#include <initializer_list>'.

Ringkasan

Generator angka acak adalah objek yang menghasilkan urutan nilai pseudo-random. Generator yang menghasilkan nilai yang didistribusikan secara seragam dalam rentang tertentu adalah Uniform Random Number Generator (URNG). Templat kelas yang dirancang untuk berfungsi sebagai URNG disebut sebagai mesin jika kelas tersebut memiliki sifat umum tertentu, yang dibahas nanti dalam artikel ini. URNG dapat—dan biasanya—dikombinasikan dengan distribusi dengan meneruskan URNG sebagai argumen ke distribusi operator() untuk menghasilkan nilai yang didistribusikan dengan cara yang didefinisikan oleh distribusi.

Tautan ini melompat ke bagian utama artikel ini:

• Contoh

• Daftar Terkategori

• Mesin dan Distribusi

• Keterangan

Tips Cepat

Berikut adalah beberapa tips yang perlu diingat saat menggunakan <random>:

• Untuk sebagian besar tujuan, URNG menghasilkan bit mentah yang harus dibentuk oleh distribusi. (Pengecualian penting untuk ini adalah std::shuffle() karena menggunakan URNG secara langsung.)

• Satu instansiasi URNG atau distribusi tidak dapat dipanggil secara aman secara bersamaan karena menjalankan URNG atau distribusi adalah operasi modifikasi. Untuk informasi selengkapnya, lihat Keamanan Utas di Pustaka Standar C++.

• Typedefs yang telah ditentukan sebelumnya dari beberapa mesin disediakan; ini adalah cara yang disukai untuk membuat URNG jika mesin sedang digunakan.

• Pasangan yang paling berguna untuk sebagian besar aplikasi adalah mt19937 mesin dengan uniform_int_distribution, seperti yang ditunjukkan dalam contoh kode nanti di artikel ini.

Ada banyak opsi untuk dipilih di <random> header, dan salah satunya lebih disukai daripada fungsi rand()Runtime C yang kedaluarsa . Untuk informasi tentang apa yang salah dengan rand() dan bagaimana <random> mengatasi kekurangan ini, lihat video ini.

Contoh

Contoh kode berikut menunjukkan cara menghasilkan beberapa angka acak dalam hal ini lima di antaranya menggunakan generator yang dibuat dengan benih non-deterministik.

#include <random>
#include <iostream>

using namespace std;

int main()
{
    random_device rd;   // non-deterministic generator
    mt19937 gen(rd());  // to seed mersenne twister.
                        // replace the call to rd() with a
                        // constant value to get repeatable
                        // results.

    for (int i = 0; i < 5; ++i) {
        cout << gen() << " "; // print the raw output of the generator.
    }
    cout << endl;
}

2430338871 3531691818 2723770500 3252414483 3632920437

Meskipun ini adalah angka acak berkualitas tinggi dan berbeda setiap kali program ini dijalankan, mereka belum tentu dalam rentang yang berguna. Untuk mengontrol rentang, gunakan distribusi seragam seperti yang ditunjukkan dalam kode berikut:

#include <random>
#include <iostream>

using namespace std;

int main()
{
    random_device rd;   // non-deterministic generator
    mt19937 gen(rd());  // to seed mersenne twister.
    uniform_int_distribution<> dist(1,6); // distribute results between 1 and 6 inclusive.

    for (int i = 0; i < 5; ++i) {
        cout << dist(gen) << " "; // pass the generator to the distribution.
    }
    cout << endl;
}

5 1 6 1 2

Contoh kode berikutnya menunjukkan serangkaian kasus penggunaan yang lebih realistis dengan generator angka acak yang didistribusikan secara seragam mengacak konten vektor dan array.

// cl.exe /EHsc /nologo /W4 /MTd
#include <algorithm>
#include <array>
#include <iostream>
#include <random>
#include <string>
#include <vector>
#include <functional> // ref()

using namespace std;

template <typename C> void print(const C& c) {
    for (const auto& e : c) {
        cout << e << " ";
    }

    cout << endl;
}

template <class URNG>
void test(URNG& urng) {

    // Uniform distribution used with a vector
    // Distribution is [-5, 5] inclusive
    uniform_int_distribution<int> dist(-5, 5);
    vector<int> v;

    for (int i = 0; i < 20; ++i) {
        v.push_back(dist(urng));
    }

    cout << "Randomized vector: ";
    print(v);

    // Shuffle an array
    // (Notice that shuffle() takes a URNG, not a distribution)
    array<string, 26> arr = { { "H", "He", "Li", "Be", "B", "C", "N", "O", "F",
        "Ne", "Na", "Mg", "Al", "Si", "P", "S", "Cl", "Ar", "K", "Ca", "Sc",
        "Ti", "V", "Cr", "Mn", "Fe" } };

    shuffle(arr.begin(), arr.end(), urng);

    cout << "Randomized array: ";
    print(arr);
    cout << "--" << endl;
}

int main()
{
    // First run: non-seedable, non-deterministic URNG random_device
    // Slower but crypto-secure and non-repeatable.
    random_device rd;
    cout << "Using random_device URNG:" << endl;
    test(rd);

    // Second run: simple integer seed, repeatable results
    cout << "Using constant-seed mersenne twister URNG:" << endl;
    mt19937 engine1(12345);
    test(engine1);

    // Third run: random_device as a seed, different each run
    // (Desirable for most purposes)
    cout << "Using non-deterministic-seed mersenne twister URNG:" << endl;
    mt19937 engine2(rd());
    test(engine2);

    // Fourth run: "warm-up" sequence as a seed, different each run
    // (Advanced uses, allows more than 32 bits of randomness)
    cout << "Using non-deterministic-seed \"warm-up\" sequence mersenne twister URNG:" << endl;
    array<unsigned int, mt19937::state_size> seed_data;
    generate_n(seed_data.begin(), seed_data.size(), ref(rd));
    seed_seq seq(begin(seed_data), end(seed_data));
    mt19937 engine3(seq);
    test(engine3);
}

Using random_device URNG:
Randomized vector: 5 -4 2 3 0 5 -2 0 4 2 -1 2 -4 -3 1 4 4 1 2 -2
Randomized array: O Li V K C Ti N Mg Ne Sc Cl B Cr Mn Ca Al F P Na Be Si Ar Fe S He H
--
Using constant-seed mersenne twister URNG:
Randomized vector: 3 -1 -5 0 0 5 3 -4 -3 -4 1 -3 0 -3 -2 -4 5 1 -1 -1
Randomized array: Al O Ne Si Na Be C N Cr Mn H V F Sc Mg Fe K Ca S Ti B P Ar Cl Li He
--
Using non-deterministic-seed mersenne twister URNG:
Randomized vector: 5 -4 0 2 1 -2 4 4 -4 0 0 4 -5 4 -5 -1 -3 0 0 3
Randomized array: Si Fe Al Ar Na P B Sc H F Mg Li C Ti He N Mn Be O Ca Cr V K Ne Cl S
--
Using non-deterministic-seed "warm-up" sequence mersenne twister URNG:
Randomized vector: -1 3 -2 4 1 3 0 -5 5 -5 0 0 5 0 -3 3 -4 2 5 0
Randomized array: Si C Sc H Na O S Cr K Li Al Ti Cl B Mn He Fe Ne Be Ar V P Ca N Mg F
--

Kode ini menunjukkan dua pengacakan yang berbeda—mengacak vektor bilangan bulat dan mengacak array data terindeks—dengan fungsi templat pengujian. Panggilan pertama ke fungsi pengujian menggunakan URNG random_deviceyang aman kripto, tidak deterministik, tidak dapat disemai, dan tidak dapat diulang. Eksekusi pengujian kedua menggunakan sebagai URNG, dengan benih konstanta mersenne_twister_engine 32-bit deterministik, yang berarti hasilnya dapat diulang. Seed mersenne_twister_engine eksekusi pengujian ketiga dengan hasil non-deterministik 32-bit dari random_device. Eksekusi pengujian keempat diperluas pada ini dengan menggunakan urutan benih yang diisi dengan random_device hasil, yang secara efektif memberikan keacakan non-deterministik lebih dari 32-bit (tetapi masih belum aman kripto). Untuk informasi selengkapnya, baca.

Daftar Terkategori

Generator Angka Acak Seragam

URNG sering dijelaskan dalam hal properti ini:

1. Panjang periode: Berapa banyak iterasi yang diperlukan untuk mengulangi urutan angka yang dihasilkan. Semakin lama semakin baik.

2. Performa: Seberapa cepat angka dapat dihasilkan dan berapa banyak memori yang diperlukan. Semakin kecil semakin baik.

3. Kualitas: Seberapa dekat dengan angka acak benar urutan yang dihasilkan. Ini sering disebut "acak".

Bagian berikut mencantumkan generator angka acak seragam (URNG) yang disediakan di <random> header.

Generator Non-Deterministik

random_device Kelas
Menghasilkan urutan acak yang tidak deterministik dan aman secara kriptografis dengan menggunakan perangkat eksternal. Biasanya digunakan untuk menyemai mesin. Performa rendah, kualitas sangat tinggi. Untuk informasi selengkapnya, lihat Keterangan.

Typedefs Mesin dengan Parameter yang Telah Ditentukan Sebelumnya

Untuk membuat instans mesin dan adaptor mesin. Untuk informasi selengkapnya, lihat Mesin dan Distribusi.

• default_random_engine Mesin default.

  typedef mt19937 default_random_engine;
  

• knuth_b Mesin knuth.

  typedef shuffle_order_engine<minstd_rand0, 256> knuth_b;
  

• minstd_rand0 Mesin standar minimal 1988 (Lewis, Goodman, dan Miller, 1969).

  typedef linear_congruential_engine<unsigned int, 16807, 0, 2147483647> minstd_rand0;
  

• minstd_rand Mesin standar minstd_rand0 minimal yang diperbarui (Park, Miller, dan Stockmeyer, 1993).

  typedef linear_congruential_engine<unsigned int, 48271, 0, 2147483647> minstd_rand;
  

• mt19937 Mesin twister Mersenne 32-bit (Matsumoto dan Nishimura, 1998).

  typedef mersenne_twister_engine<
      unsigned int, 32, 624, 397,
      31, 0x9908b0df,
      11, 0xffffffff,
      7, 0x9d2c5680,
      15, 0xefc60000,
      18, 1812433253> mt19937;
  

• mt19937_64 Mesin twister Mersenne 64-bit (Matsumoto dan Nishimura, 2000).

  typedef mersenne_twister_engine<
      unsigned long long, 64, 312, 156,
      31, 0xb5026f5aa96619e9ULL,
      29, 0x5555555555555555ULL,
      17, 0x71d67fffeda60000ULL,
      37, 0xfff7eee000000000ULL,
      43, 6364136223846793005ULL> mt19937_64;
  

• ranlux24 Mesin RANLUX 24-bit (Martin Lüscher dan Fred James, 1994).

  typedef discard_block_engine<ranlux24_base, 223, 23> ranlux24;
  

• ranlux24_base Digunakan sebagai basis untuk ranlux24.

  typedef subtract_with_carry_engine<unsigned int, 24, 10, 24> ranlux24_base;
  

• ranlux48 Mesin RANLUX 48-bit (Martin Lüscher dan Fred James, 1994).

  typedef discard_block_engine<ranlux48_base, 389, 11> ranlux48;
  

• ranlux48_base Digunakan sebagai basis untuk ranlux48.

  typedef subtract_with_carry_engine<unsigned long long, 48, 5, 12> ranlux48_base;
  

Templat Mesin

Templat mesin digunakan sebagai URNG mandiri atau sebagai mesin dasar yang diteruskan ke adaptor mesin. Biasanya ini dibuat dengan typedef mesin yang telah ditentukan sebelumnya dan diteruskan ke distribusi. Untuk informasi selengkapnya, lihat bagian Mesin dan Distribusi .

Nama	Deskripsi
linear_congruential_engine Kelas	Menghasilkan urutan acak dengan menggunakan algoritma congruential linier. Kualitas paling sederhana dan terendah.
mersenne_twister_engine Kelas	Menghasilkan urutan acak dengan menggunakan algoritma twister Mersenne. Paling kompleks, dan berkualitas tertinggi kecuali untuk kelas random_device. Performa yang sangat cepat.
subtract_with_carry_engine Kelas	Menghasilkan urutan acak dengan menggunakan algoritma pengurangan-dengan-carry. Peningkatan pada linear_congruential_engine, tetapi kualitas dan performa yang jauh lebih rendah daripada mersenne_twister_engine.

Templat Adaptor Mesin

Adaptor mesin adalah templat yang mengadaptasi mesin (dasar) lainnya. Biasanya ini dibuat dengan typedef mesin yang telah ditentukan sebelumnya dan diteruskan ke distribusi. Untuk informasi selengkapnya, lihat bagian Mesin dan Distribusi .

Nama	Deskripsi
discard_block_engine Kelas	Menghasilkan urutan acak dengan membuang nilai yang dikembalikan oleh mesin dasarnya.
independent_bits_engine Kelas	Menghasilkan urutan acak dengan jumlah bit tertentu dengan mengemas ulang bit dari nilai yang dikembalikan oleh mesin dasarnya.
shuffle_order_engine Kelas	Menghasilkan urutan acak dengan menyusun ulang nilai yang dikembalikan dari mesin dasarnya.

[Templat Mesin]

Distribusi Angka Acak

Bagian berikut mencantumkan distribusi yang disediakan di <random> header. Distribusi adalah mekanisme pasca-pemrosesan, biasanya menggunakan output URNG sebagai input dan mendistribusikan output oleh fungsi kerapatan probabilitas statistik yang ditentukan. Untuk informasi selengkapnya, lihat bagian Mesin dan Distribusi .

Distribusi Seragam

Nama	Deskripsi
uniform_int_distribution Kelas	Menghasilkan distribusi nilai bilangan bulat seragam di seluruh rentang dalam interval tertutup [a, b] (inklusif-inklusif).
uniform_real_distribution Kelas	Menghasilkan distribusi nilai nyata yang seragam (floating-point) di seluruh rentang dalam interval setengah terbuka [a, b) (inklusif-eksklusif).
generate_canonical	Menghasilkan distribusi nilai nyata (floating point) yang merata dari presisi tertentu di [0, 1) (inklusif-eksklusif).

[Distribusi Angka Acak]

Distribusi Bernoulli

Nama	Deskripsi
bernoulli_distribution Kelas	Menghasilkan distribusi bool nilai Bernoulli.
binomial_distribution Kelas	Menghasilkan distribusi binomial nilai bilangan bulat.
geometric_distribution Kelas	Menghasilkan distribusi geometrik nilai bilangan bulat.
negative_binomial_distribution Kelas	Menghasilkan distribusi binomial negatif dari nilai bilangan bulat.

[Distribusi Angka Acak]

Distribusi Normal

Nama	Deskripsi
cauchy_distribution Kelas	Menghasilkan distribusi Cauchy dari nilai riil (floating point).
chi_squared_distribution Kelas	Menghasilkan distribusi khi-kuadrat dari nilai riil (floating point).
fisher_f_distribution Kelas	Menghasilkan distribusi F (juga dikenal sebagai distribusi F Snedecor atau distribusi Fisher-Snedecor) dari nilai nyata (floating point).
lognormal_distribution Kelas	Menghasilkan distribusi log normal dari nilai riil (floating point).
normal_distribution Kelas	Menghasilkan distribusi normal (Gaussian) dari nilai riil (floating point).
student_t_distribution Kelas	Menghasilkan nilai distribusi t siswa dari nilai nyata (floating point).

[Distribusi Angka Acak]

Distribusi Poisson

Nama	Deskripsi
exponential_distribution Kelas	Menghasilkan distribusi eksponensial dari nilai riil (floating point).
extreme_value_distribution Kelas	Menghasilkan distribusi nilai ekstrem dari nilai riil (floating point).
gamma_distribution Kelas	Menghasilkan distribusi gamma dari nilai nyata (floating point).
poisson_distribution Kelas	Menghasilkan distribusi Poisson nilai bilangan bulat.
weibull_distribution Kelas	Menghasilkan distribusi Weibull dari nilai nyata (floating point).

[Distribusi Angka Acak]

Distribusi Pengambilan Sampel

Nama	Deskripsi
discrete_distribution Kelas	Menghasilkan distribusi bilangan bulat diskrit.
piecewise_constant_distribution Kelas	Menghasilkan distribusi nilai riil (floating point) konstanta sepotong.
piecewise_linear_distribution Kelas	Menghasilkan distribusi linier sepotong dari nilai riil (floating point).

[Distribusi Angka Acak]

Fungsi Utilitas

Bagian ini mencantumkan fungsi utilitas umum yang disediakan di <random> header.

Nama	Deskripsi
seed_seq Kelas	Menghasilkan urutan awal orak-arik yang tidak bias. Digunakan untuk menghindari replikasi aliran variasi acak. Berguna ketika banyak URNG dibuat dari mesin.

Operator

Bagian ini mencantumkan operator yang disediakan di <random> header.

Nama	Deskripsi
operator==	Menguji apakah URNG di sisi kiri operator sama dengan mesin di sisi kanan.
operator!=	Menguji apakah URNG di sisi kiri operator tidak sama dengan mesin di sisi kanan.
operator<<	Menulis informasi status ke aliran.
operator>>	Mengekstrak informasi status dari aliran.

Mesin dan Distribusi

Lihat bagian berikut untuk informasi tentang masing-masing kategori templat kelas ini yang ditentukan dalam <random>. Kedua kategori templat kelas ini mengambil jenis sebagai argumen dan menggunakan nama parameter templat bersama untuk menjelaskan properti jenis yang diizinkan sebagai jenis argumen aktual, sebagai berikut:

• IntTypeshortmenunjukkan , , intlong, long long, unsigned short, unsigned int, unsigned long, atau unsigned long long.

• UIntTypeunsigned shortmenunjukkan , unsigned int, unsigned long, atau unsigned long long.

• RealTypefloatmenunjukkan , , doubleatau long double.

Mesin

Templat Mesin dan Templat Adaptor Mesin adalah templat yang parameternya menyesuaikan generator yang dibuat.

Mesin adalah templat kelas atau kelas yang instansnya (generator) bertindak sebagai sumber angka acak yang didistribusikan secara seragam antara nilai minimum dan maksimum. Adaptor mesin memberikan urutan nilai yang memiliki properti keacakan yang berbeda dengan mengambil nilai yang dihasilkan oleh beberapa mesin angka acak lainnya dan menerapkan algoritma semacam ke nilai tersebut.

Setiap adaptor mesin dan mesin memiliki anggota berikut:

• typedefnumeric-type result_type adalah jenis yang dikembalikan oleh generator operator(). numeric-type diteruskan sebagai parameter templat pada instansiasi.

• result_type operator() mengembalikan nilai yang didistribusikan secara seragam antara min() dan max().

• result_type min() mengembalikan nilai minimum yang dikembalikan oleh generator operator(). Adaptor mesin menggunakan hasil mesin min() dasar.

• result_type max() mengembalikan nilai maksimum yang dikembalikan oleh generator operator(). Ketika result_type adalah jenis integral (bernilai bilangan bulat), max() adalah nilai maksimum yang benar-benar dapat dikembalikan (inklusif); ketika result_type adalah jenis floating-point (real-valued), max() adalah nilai terkecil yang lebih besar dari semua nilai yang dapat dikembalikan (non-inklusif). Adaptor mesin menggunakan hasil mesin max() dasar.

• void seed(result_type s) benih generator dengan nilai sbenih . Untuk mesin, tanda tangan adalah void seed(result_type s = default_seed) untuk dukungan parameter default (adaptor mesin menentukan terpisah void seed(), lihat sub bagian berikutnya).

• template <class Seq> void seed(Seq& q) benih generator dengan menggunakan seed_seqSeq.

• Konstruktor eksplisit dengan argumen result_type x yang membuat benih generator seolah-olah dengan memanggil seed(x).

• Konstruktor eksplisit dengan argumen seed_seq& seq yang membuat benih generator seolah-olah dengan memanggil seed(seq).

• void discard(unsigned long long count) secara efektif memanggil operator() count waktu dan membuang setiap nilai.

Adaptor mesin juga mendukung anggota ini (Engine adalah parameter templat pertama dari adaptor mesin, yang menunjuk jenis mesin dasar):

• Konstruktor default untuk menginisialisasi generator seolah-olah dari konstruktor default mesin dasar.

• Konstruktor eksplisit dengan argumen const Engine& eng. Ini untuk mendukung konstruksi salinan menggunakan mesin dasar.

• Konstruktor eksplisit dengan argumen Engine&& eng. Ini untuk mendukung konstruksi pemindahan menggunakan mesin dasar.

• void seed() yang menginisialisasi generator dengan nilai benih default mesin dasar.

• const Engine& base() fungsi properti yang mengembalikan mesin dasar yang digunakan untuk membangun generator.

Setiap mesin mempertahankan status yang menentukan urutan nilai yang akan dihasilkan oleh panggilan berikutnya ke operator(). Status dua generator yang dibuat dari mesin dengan jenis yang sama dapat dibandingkan dengan menggunakan operator== dan operator!=. Jika kedua status dibandingkan sebagai sama, mereka akan menghasilkan urutan nilai yang sama. Status objek dapat disimpan ke aliran sebagai urutan nilai yang tidak ditandatangani 32-bit dengan menggunakan operator<< generator. Status tidak diubah dengan menyimpannya. Status tersimpan dapat dibaca ke dalam generator yang dibuat dari mesin dengan jenis yang sama dengan menggunakan operator>>.

Distribusi

Distribusi Angka Acak adalah templat kelas atau kelas yang instansnya mengubah aliran angka acak yang didistribusikan secara seragam yang diperoleh dari mesin ke dalam aliran angka acak yang memiliki distribusi tertentu. Setiap distribusi memiliki anggota berikut:

• typedefnumeric-type result_type adalah jenis yang dikembalikan oleh distribusi operator(). numeric-type diteruskan sebagai parameter templat pada instansiasi.

• template <class URNG> result_type operator()(URNG& gen)mengembalikan nilai yang didistribusikan sesuai dengan definisi distribusi, dengan menggunakan gen sebagai sumber nilai acak yang didistribusikan secara seragam dan parameter distribusi yang disimpan.

• template <class URNG> result_type operator()(URNG& gen, param_type p) mengembalikan nilai yang didistribusikan sesuai dengan definisi distribusi, menggunakan gen sebagai sumber nilai acak yang didistribusikan secara seragam dan struktur pparameter .

• typedefunspecified-type param_type adalah paket parameter yang secara opsional diteruskan ke operator() dan digunakan sebagai pengganti parameter tersimpan untuk menghasilkan nilai pengembaliannya.

• const param& Konstruktor menginisialisasi parameter tersimpan dari argumennya.

• param_type param() const mendapatkan parameter tersimpan.

• void param(const param_type&) mengatur parameter tersimpan dari argumennya.

• result_type min() mengembalikan nilai minimum yang dikembalikan oleh distribusi operator().

• result_type max() mengembalikan nilai maksimum yang dikembalikan oleh distribusi operator(). Ketika result_type adalah jenis integral (bernilai bilangan bulat), max() adalah nilai maksimum yang benar-benar dapat dikembalikan (inklusif); ketika result_type adalah jenis floating-point (real-valued), max() adalah nilai terkecil yang lebih besar dari semua nilai yang dapat dikembalikan (non-inklusif).

• void reset() membuang nilai cache apa pun, sehingga hasil panggilan operator() berikutnya tidak bergantung pada nilai apa pun yang diperoleh dari mesin sebelum panggilan.

Struktur parameter adalah objek yang menyimpan semua parameter yang diperlukan untuk distribusi. Berisi:

• typedefdistribution-type distribution_type, yang merupakan jenis distribusinya.

• Satu atau beberapa konstruktor yang mengambil daftar parameter yang sama seperti yang diambil konstruktor distribusi.

• Fungsi akses parameter yang sama dengan distribusi.

• Operator perbandingan kesetaraan dan ketidaksetaraan.

Untuk informasi selengkapnya, lihat subtopik referensi di bawah ini, yang ditautkan sebelumnya dalam artikel ini.

Keterangan

Ada dua URNG yang sangat berguna di Visual Studio—mt19937 dan random_device—seperti yang ditunjukkan dalam tabel perbandingan ini:

URNG	Cepat	Crypto-secure	Dapat disemai	Deterministic
mt19937	Ya	No	Ya	Ya*
random_device	No	Ya	No	Tidak

^{* Ketika diberikan benih yang diketahui.}

Meskipun ISO C++ Standard tidak harus random_device aman secara kriptografis, di Visual Studio diimplementasikan agar aman secara kriptografis. (Istilah "aman secara kriptografis" tidak menyiratkan jaminan, tetapi mengacu pada tingkat entropi minimum—dan oleh karena itu, tingkat prediktabilitas—algoritma pengacakan tertentu menyediakan. Untuk informasi selengkapnya, lihat artikel Wikipedia Generator nomor pseudorandom aman secara kriptografis.) Karena ISO C++ Standard tidak memerlukan ini, platform lain dapat mengimplementasikan random_device sebagai generator angka pseudo-random sederhana (tidak aman secara kriptografis) dan mungkin hanya cocok sebagai sumber benih untuk generator lain. Periksa dokumentasi untuk platform tersebut saat menggunakan random_device dalam kode lintas platform.

Menurut definisi, random_device hasilnya tidak dapat direproduksi, dan efek sampingnya adalah dapat berjalan secara signifikan lebih lambat daripada URNG lainnya. Sebagian besar aplikasi yang tidak diperlukan untuk penggunaan mt19937 yang aman secara kriptografis atau mesin serupa, meskipun Anda mungkin ingin menyemainya dengan panggilan ke random_device, seperti yang ditunjukkan dalam contoh kode.

Lihat juga

Referensi File Header