Megosztás:

<random>

A véletlenszerű számgenerálási lehetőségeket határozza meg, lehetővé téve az egységesen elosztott véletlenszerű számok létrehozását.

Követelmények

Fejléc: <random>

Névtér: std

Megjegyzés:

A <random> kódtár az utasítást #include <initializer_list> használja.

Összefoglalás

A véletlenszerű számgenerátor egy olyan objektum, amely pszeudo-véletlenszerű értékek sorozatát hozza létre. Egy adott tartományban egységesen elosztott értékeket létrehozó generátor egy egységes véletlenszerű számgenerátor (URNG). Az URNG-ként való működésre tervezett osztálysablonokat motornak nevezzük, ha az osztály bizonyos közös tulajdonságokkal rendelkezik, amelyeket a cikk későbbi részében tárgyalunk. Az URNG-k kombinálhatók egy eloszlással úgy, hogy argumentumként adják át az URNG-t a disztribúciónak, hogy a disztribúció operator() által meghatározott módon elosztott értékeket állítsunk elő.

Ezek a hivatkozások a cikk főbb szakaszaira ugornak:

Gyors tippek

Íme néhány tipp, amelyeket szem előtt kell tartani a következő használatakor <random>:

  • A legtöbb esetben az URNG-k olyan nyers biteket hoznak létre, amelyeket eloszlások alapján kell formázni. (Ez alól az egyik jelentős kivétel az, std::shuffle() hogy közvetlenül URNG-t használ.)

  • Az URNG vagy a disztribúció egyetlen példánya nem hívható meg biztonságosan egyidejűleg, mert az URNG vagy a disztribúció futtatása módosító művelet. További információ: Szálbiztonság a C++ Standard kódtárban.

  • Több motor előre definiált típusdefef-jei vannak megadva; ez az előnyben részesített módszer az URNG létrehozásához, ha motort használnak.

  • A legtöbb alkalmazás esetében a leghatékonyabb párosítás a mt19937 motor, uniform_int_distributionahogyan az a jelen cikk későbbi , kód példájában is látható.

A fejlécben <random> számos lehetőség közül választhat, és ezek közül bármelyik előnyösebb az elavult C Futtatókörnyezet függvényhez rand(). Ebből a rand() megtudhatja, hogy mi a <random> probléma, és hogyan oldja meg ezeket a hiányosságokat.

Példák

Az alábbi példakód bemutatja, hogyan hozhat létre véletlenszerű számokat ebben az esetben öten egy nem determinisztikus maggal létrehozott generátor használatával.

#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

Bár ezek kiváló minőségű véletlenszerű számok, és minden alkalommal, amikor ez a program fut, nem feltétlenül hasznos tartományban. A tartomány szabályozásához használjon egységes eloszlást az alábbi kódban látható módon:

#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

A következő példakód egy reálisabb használati esetkészletet mutat be, amely egységesen elosztott véletlenszerű számgenerátorokkal osztja el a vektor és a tömb tartalmát.

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

Ez a kód két különböző randomizációt mutat be – egész számok vektorának véletlenszerűsítését és indexelt adatok tömbjének véletlenszerűsítését – egy tesztsablonfüggvénnyel. A tesztfüggvény első hívása a titkosítással védett, nem determinisztikus, nem magozható, nem megismételhető URNG-t random_devicehasználja. A második tesztfuttatás URNG-ként működik mersenne_twister_engine , determinisztikus 32 bites állandó maggal, ami azt jelenti, hogy az eredmények megismételhetők. A harmadik teszt a magokat mersenne_twister_engine 32 bites, nem determinisztikus eredménnyel random_devicefuttatja. A negyedik tesztfuttatás egy eredményekkel teli magütemezésselrandom_device bővül, amely hatékonyan több mint 32 bites nem determinisztikus véletlenszerűséget ad (de még mindig nem titkosítással biztonságos). További információkért olvassa el a cikket.

Kategorizált lista

Egységes véletlenszám-generátorok

Az URNG-ket gyakran az alábbi tulajdonságok jellemzik:

  1. Időszak hossza: Hány iteráció szükséges a létrehozott számok sorozatának megismétléséhez. Minél tovább, annál jobb.

  2. Teljesítmény: Milyen gyorsan hozhatók létre számok, és mennyi memóriát igényel. Minél kisebb a jobb.

  3. Minőség: Milyen közel van a valós véletlenszerű számokhoz a generált sorozat. Ezt gyakran nevezik "véletlenszerűségnek".

Az alábbi szakaszok a fejlécben megadott egységes véletlenszám-generátorokat (URNG-ket) sorolják fel <random> .

Nem determinisztikus generátor

random_device osztály
Nem determinisztikus, kriptográfiailag biztonságos véletlenszerű sorozatot hoz létre külső eszköz használatával. Általában motor vetésére használják. Alacsony teljesítmény, nagyon jó minőség. További információ: Megjegyzések.

Motortípus-definíciók előre definiált paraméterekkel

Motorok és motoradaposok példányosításához. További információ: Motorok és disztribúciók.

  • default_random_engine Az alapértelmezett motor.

    typedef mt19937 default_random_engine;

  • knuth_b Knuth motor.

    typedef shuffle_order_engine<minstd_rand0, 256> knuth_b;

  • minstd_rand0 1988 minimális standard motor (Lewis, Goodman és Miller, 1969).

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

  • minstd_rand Frissített minimális standard motor minstd_rand0 (Park, Miller, and Stockmeyer, 1993).

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

  • mt19937 32 bites Mersenne twister motor (Matsumoto és Nishimura, 1998).

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

  • mt19937_64 64 bites Mersenne twister motor (Matsumoto és 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 24 bites RANLUX motor (Martin Lüscher és Fred James, 1994).

    typedef discard_block_engine<ranlux24_base, 223, 23> ranlux24;

  • ranlux24_base A .-hez ranlux24alapként szolgál.

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

  • ranlux48 48 bites RANLUX motor (Martin Lüscher és Fred James, 1994).

    typedef discard_block_engine<ranlux48_base, 389, 11> ranlux48;

  • ranlux48_base A .-hez ranlux48alapként szolgál.

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

Motorsablonok

A motorsablonokat önálló URIG-kként vagy alapmotorként használják, amelyeket a motoradapászoknak adnak át. Ezeket általában egy előre definiált motortípussal példányosítjuk, és átadjuk egy disztribúciónak. További információt a Motorok és disztribúciók című szakaszban talál.

Név Leírás
linear_congruential_engine osztály Véletlenszerű sorozatot hoz létre a lineáris egybefüggő algoritmus használatával. A legegyszerűbb és legalacsonyabb minőség.
mersenne_twister_engine osztály Véletlenszerű sorozatot hoz létre a Mersenne twister algoritmus használatával. A legösszetettebb, és a legmagasabb minőség, kivéve a random_device osztályt. Nagyon gyors teljesítmény.
subtract_with_carry_engine osztály Véletlenszerű sorozatot hoz létre a kivonási és átviteles algoritmus használatával. Javulás a linear_congruential_engine, de sokkal alacsonyabb a minőség és a teljesítmény, mint mersenne_twister_engine.

Motoradafósablonok

A motoradafótorok olyan sablonok, amelyek más (alap) motorokat is adaptálnak. Ezeket általában egy előre definiált motortípussal példányosítjuk, és átadjuk egy disztribúciónak. További információt a Motorok és disztribúciók című szakaszban talál.

Név Leírás
discard_block_engine osztály Véletlenszerű sorrendet hoz létre az alapmotor által visszaadott értékek elvetésével.
independent_bits_engine osztály Véletlenszerű sorozatot hoz létre megadott számú bittel úgy, hogy újracsomagolja a biteket az alapmotor által visszaadott értékekből.
shuffle_order_engine osztály Véletlenszerű sorrendet hoz létre az alapmotorból visszaadott értékek átrendezésével.

[Motorsablonok]

Véletlenszerű számeloszlások

A következő szakaszok a fejlécben megadott eloszlásokat sorolják fel <random> . Az eloszlások utófeldolgozási mechanizmusnak minősülnek, általában urNG-kimenetet használnak bemenetként, és a kimenetet egy meghatározott statisztikai sűrűségfüggvénnyel osztják el. További információt a Motorok és disztribúciók című szakaszban talál.

Egységes eloszlások

Név Leírás
uniform_int_distribution osztály Egységes egész számértékeloszlást hoz létre egy tartományon belül a zárt intervallumban [a, b] (befogadó-befogadó).
uniform_real_distribution osztály Egységes valós (lebegőpontos) értékeloszlást hoz létre egy tartományon belül a félig nyitott intervallumban [a, b) (inkluzív-kizárólagos).
generate_canonical Egy adott pontosságú valós (lebegőpontos) értékek egyenletes eloszlását állítja elő [0, 1) között (inkluzív-kizárólagos).

[Véletlenszerű számeloszlások]

Bernoulli-disztribúciók

Név Leírás
bernoulli_distribution osztály Az értékek Bernoulli-eloszlását bool hozza létre.
binomial_distribution osztály Egész számértékek binomiális eloszlását hozza létre.
geometric_distribution osztály Egész számértékek geometriai eloszlását hozza létre.
negative_binomial_distribution osztály Az egész számértékek negatív binomiális eloszlását hozza létre.

[Véletlenszerű számeloszlások]

Normál eloszlások

Név Leírás
cauchy_distribution osztály Valós (lebegőpontos) értékek Cauchy-eloszlását hozza létre.
chi_squared_distribution osztály Valós (lebegőpontos) értékek khi-négyzet eloszlását hozza létre.
fisher_f_distribution osztály Valós (lebegőpontos) értékek F-eloszlását (más néven Snedecor F eloszlását vagy Fisher-Snedecor eloszlását) állítja elő.
lognormal_distribution osztály A valós (lebegőpontos) értékek log-normal eloszlását hozza létre.
normal_distribution osztály Valós (lebegőpontos) értékek normál (Gauss-) eloszlását állítja elő.
student_t_distribution osztály Valós (lebegőpontos) értékek student-eloszlását állítja elő.

[Véletlenszerű számeloszlások]

Poisson-disztribúciók

Név Leírás
exponential_distribution osztály Valós (lebegőpontos) értékek exponenciális eloszlását hozza létre.
extreme_value_distribution osztály A valós (lebegőpontos) értékek szélsőséges értékeloszlását hozza létre.
gamma_distribution osztály Valós (lebegőpontos) értékek gammaeloszlását állítja elő.
poisson_distribution osztály Egész számértékek Poisson-eloszlását hozza létre.
weibull_distribution osztály Valós (lebegőpontos) értékek Weibull-eloszlását hozza létre.

[Véletlenszerű számeloszlások]

Mintavételezési eloszlások

Név Leírás
discrete_distribution osztály Diszkrét egész számeloszlást hoz létre.
piecewise_constant_distribution osztály A valós (lebegőpontos) értékek darabenkénti állandó eloszlását hozza létre.
piecewise_linear_distribution osztály A valós (lebegőpontos) értékek darabenkénti lineáris eloszlását hozza létre.

[Véletlenszerű számeloszlások]

Segédprogramfüggvények

Ez a szakasz a fejlécben található általános segédprogramfüggvényeket sorolja fel <random> .

Név Leírás
seed_seq osztály Nem elfogult magütemezést hoz létre. A véletlenszerű variátumfolyamok replikációjának elkerülésére szolgál. Akkor hasznos, ha sok URIG-t példányosít a motor.

Működtetők

Ez a szakasz a fejlécben megadott operátorokat sorolja fel <random> .

Név Leírás
operator== Ellenőrzi, hogy a kezelő bal oldalán lévő URNG egyenlő-e a jobb oldalon lévő motorral.
operator!= Ellenőrzi, hogy a kezelő bal oldalán lévő URNG nem egyenlő-e a jobb oldalon lévő motorral.
operator<< Állapotinformációkat ír egy streambe.
operator>> Állapotinformációkat nyer ki egy streamből.

Motorok és disztribúciók

A következő szakaszokban további információt talál a következő szakaszban meghatározott <random>osztálysablon-kategóriákról. Mindkét osztálysablon-kategória argumentumként használ típust, és megosztott sablonparaméter-nevek használatával írja le a tényleges argumentumtípusként engedélyezett típus tulajdonságait az alábbiak szerint:

  • IntTypeegy short, , int, longlong long, unsigned short, unsigned intunsigned long, vagy unsigned long long.

  • UIntType azt unsigned shortjelzi , unsigned int, unsigned longvagy unsigned long long.

  • RealType egy float, doublevagy long double.

Hajtómű

A motorsablonok és a motoradasztorral rendelkező sablonok olyan sablonok, amelyek paraméterei testre szabják a létrehozott generátort.

A motor olyan osztály- vagy osztálysablon, amelynek példányai (generátorai) véletlenszerű számok forrásaként szolgálnak, amelyek egyenletesen oszlanak el a minimális és a maximális érték között. A motoradapter különböző véletlenszerűségi tulajdonságokkal rendelkező értékek sorozatát biztosítja azáltal, hogy más véletlenszerű számmotor által előállított értékeket vesz fel, és valamilyen algoritmust alkalmaz ezekre az értékekre.

Minden motornak és motoradapedátornak a következő tagjai vannak:

  • typedef numeric-type result_type a generátor operator()által visszaadott típus. A numeric-type rendszer sablonparaméterként adja át a példányosításkor.

  • result_type operator() az és a között egységesen elosztott értékeket ad min()max()vissza.

  • result_type min() a generátor operator()által visszaadott minimális értéket adja vissza. A motoradaszok az alapmotor min() eredményét használják.

  • result_type max() a generátor operator()által visszaadott maximális értéket adja vissza. Ha result_type egy integrál (egész számértékkel rendelkező) típus, az a maximális érték, max() amely ténylegesen visszaadható (beleértve); ha result_type lebegőpontos (valós értékű) típusról van szó, akkor a legkisebb érték nagyobb, max() mint az összes visszaadható érték (nem inkluzív). A motoradaszok az alapmotor max() eredményét használják.

  • void seed(result_type s) mag a generátort magértékkel s. A motorok esetében az aláírás az alapértelmezett paramétertámogatáshoz tartozik void seed(result_type s = default_seed) (a motoradappák külön-külön void seed()definiálnak, lásd a következő alszakaszt).

  • template <class Seq> void seed(Seq& q) magok a generátor segítségével egy seed_seqSeq.

  • Explicit konstruktor argumentummal result_type x , amely egy olyan generátort hoz létre, amely úgy van kialakítva, mintha meghívja seed(x).

  • Explicit konstruktor argumentummal seed_seq& seq , amely egy olyan generátort hoz létre, amely úgy van kialakítva, mintha meghívja seed(seq).

  • void discard(unsigned long long count) hatékonyan meghívja operator()count az időpontokat, és elveti az egyes értékeket.

A motoradabrátorok ezen tagok mellett támogatják aEngine motoradapedátor első sablonparaméterét, amely az alapmotor típusát választja ki):

  • Alapértelmezett konstruktor, amely úgy inicializálja a generátort, mintha az alapmotor alapértelmezett konstruktorából származik.

  • Explicit konstruktor argumentummal const Engine& eng. Ennek célja, hogy támogassa a másolási konstrukciót az alapmotor használatával.

  • Explicit konstruktor argumentummal Engine&& eng. Ez az alapmotorral történő mozgatás támogatása.

  • void seed() amely inicializálja a generátort az alapmotor alapértelmezett magértékével.

  • const Engine& base() tulajdonságfüggvény, amely a generátor létrehozásához használt alapmotort adja vissza.

Minden motor olyan állapotot tart fenn, amely meghatározza a következő hívások által generált értékek sorrendjét operator(). Az azonos típusú motorokból példányosított két generátor állapota összehasonlítható az és a .operator==operator!= Ha a két állapot egyenlőként hasonlít össze, akkor ugyanazt az értéksorozatot generálják. Az objektum állapota 32 bites aláíratlan értékek sorozataként menthető a streambe a operator<< generátor használatával. Az állapot mentése nem változik. A mentett állapot beolvasható egy azonos típusú motorról példányosított generátorba a használatával operator>>.

Disztribúciók

A véletlenszerű számeloszlások olyan osztály- vagy osztálysablonok, amelyek példányai egy motorból származó, egységesen elosztott véletlenszerű számok adatfolyamát egy adott eloszlású véletlenszerű számok adatfolyamává alakítják át. Minden disztribúciónak a következő tagjai vannak:

  • typedef numeric-type result_type az a típus, amelyet a disztribúció operator()visszaad. A numeric-type rendszer sablonparaméterként adja át a példányosításkor.

  • template <class URNG> result_type operator()(URNG& gen) Az eloszlás definíciója szerint elosztott értékeket ad vissza egységesen gen elosztott véletlenszerű értékek és az eloszlás tárolt paramétereinek forrásaként.

  • template <class URNG> result_type operator()(URNG& gen, param_type p)az eloszlás definíciójának megfelelően elosztott értékeket ad vissza, egységesen elosztott véletlenszerű értékek forrásaként és a paraméterek szerkezetének genfelhasználásávalp.

  • typedef unspecified-type param_type az a paramétercsomag, amelyet opcionálisan átadnak operator() , és a tárolt paraméterek helyett használják annak visszatérési értékének létrehozásához.

  • A const param& konstruktor inicializálja a tárolt paramétereket az argumentumából.

  • param_type param() const lekéri a tárolt paramétereket.

  • void param(const param_type&) a tárolt paramétereket az argumentumából állítja be.

  • result_type min() A eloszlás operator()által visszaadott minimális értéket adja vissza.

  • result_type max() a eloszlás operator()által visszaadott maximális értéket adja vissza. Ha result_type egy integrál (egész számértékkel rendelkező) típus, az a maximális érték, max() amely ténylegesen visszaadható (beleértve); ha result_type lebegőpontos (valós értékű) típusról van szó, akkor a legkisebb érték nagyobb, max() mint az összes visszaadható érték (nem inkluzív).

  • void reset() elveti a gyorsítótárazott értékeket, így a következő hívás operator() eredménye nem függ a motortól a hívás előtt kapott értékektől.

A paraméterstruktúra olyan objektum, amely az eloszláshoz szükséges összes paramétert tárolja. A következőket tartalmazza:

  • typedef distribution-type distribution_type, amely a eloszlás típusa.

  • Egy vagy több konstruktor, amely ugyanazokat a paraméterlistákat használja, mint a terjesztési konstruktorok.

  • Ugyanaz a paraméterelérési függvény, mint a disztribúció.

  • Egyenlőség és egyenlőtlenség összehasonlító operátorok.

További információkért tekintse meg a jelen cikkben korábban hivatkozott referencia-altopikát.

Megjegyzések

A Visual Studióban két rendkívül hasznos URL-cím található–mt19937 és random_device– ahogy az ebben az összehasonlító táblázatban látható:

URNG Gyors Titkosítás biztonságos Magozható Determinisztikus
mt19937 Igen Nem Igen Igen*
random_device Nem Igen Nem Nem

* Ha ismert vetőmagot ad meg.

Bár az ISO C++ Szabványnak nem kell random_device kriptográfiailag biztonságosnak lennie, a Visual Studióban kriptográfiailag biztonságosnak kell lennie. (A "kriptográfiailag biztonságos" kifejezés nem jelent garanciát, hanem az entrópia minimális szintjére – és ezért a kiszámíthatóság szintjére – utal egy adott randomizációs algoritmus. További információt a Cryptographly secure pseudorandom number generator című Wikipédia-cikkben talál.) Mivel az ISO C++ Standard nem követeli meg ezt, más platformok egyszerű pszeudo-véletlenszerű számgenerátorként implementálhatnak random_device (nem kriptográfiailag biztonságos), és csak egy másik generátor magforrásaként használhatók. Platformfüggetlen kód használata random_device esetén ellenőrizze a platformok dokumentációját.

A definíció szerint random_device az eredmények nem reprodukálhatók, és a mellékhatás az, hogy jelentősen lassabban fut, mint a többi URNG. A legtöbb alkalmazásnak nem kell kriptográfiailag biztonságosan használnia vagy hasonló motort használnia mt19937 , bár érdemes lehet meghívni random_device, ahogy a kódpéldában látható.

Lásd még

fejlécfájlokra vonatkozó referencia

  • Last updated on