<random>

  • Artykuł

Definiuje obiekty do generowania liczb losowych, umożliwiając tworzenie równomiernie rozproszonych liczb losowych.

Wymagania

Nagłówek: <random>

Przestrzeń nazw: std

Uwaga

Biblioteka <random> używa instrukcji "#include initializer_list<>".

Podsumowanie

Generator liczb losowych to obiekt, który tworzy sekwencję pseudolosowych wartości. Generator, który generuje wartości równomiernie rozłożone w określonym zakresie, jest generatorem jednolitych liczb losowych (URNG). Szablon klasy przeznaczony do działania jako URNG jest określany jako aparat , jeśli ta klasa ma pewne typowe cechy, które zostały omówione w dalszej części tego artykułu. Adres URLNG może być — i zwykle — w połączeniu z rozkładem przez przekazanie urNG jako argumentu do rozkładu operator() w celu wygenerowania wartości, które są dystrybuowane w sposób zdefiniowany przez rozkład.

Te linki przeskoczą do głównych sekcji tego artykułu:

Szybkie wskazówki

Poniżej przedstawiono kilka wskazówek, które należy wziąć pod uwagę podczas korzystania z programu <random>:

  • W większości celów grupy URNG generują nieprzetworzone bity, które muszą być kształtowane przez dystrybucje. (Wyjątkiem jest to std::shuffle() , że korzysta bezpośrednio z urNG).

  • Pojedyncze wystąpienie urNG lub dystrybucji nie może być bezpiecznie wywoływane współbieżnie, ponieważ uruchomienie urNG lub dystrybucji jest operacją modyfikującą. Aby uzyskać więcej informacji, zobacz Thread Sejf ty w standardowej bibliotece języka C++.

  • Podano wstępnie zdefiniowane definicje typów kilku aparatów . Jest to preferowany sposób tworzenia URNG, jeśli jest używany aparat.

  • Najbardziej przydatną parą dla większości aplikacji jest mt19937 aparat z elementem uniform_int_distribution, jak pokazano w przykładzie kodu w dalszej części tego artykułu.

Istnieje wiele opcji do wyboru w nagłówku <random> , a każda z nich jest preferowana do nieaktualnej funkcji rand()środowiska uruchomieniowego języka C . Aby uzyskać informacje o błędach i <random> sposobach rozwiązywania tych niedociągnięćrand(), zobacz ten film wideo.

Przykłady

Poniższy przykład kodu pokazuje, jak wygenerować kilka losowych liczb w tym przypadku pięć z nich przy użyciu generatora utworzonego z inicjacją niedeterministyczną.

#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

Chociaż są to wysokiej jakości liczby losowe i różne za każdym razem, gdy ten program jest uruchamiany, nie muszą być w przydatnym zakresie. Aby kontrolować zakres, użyj równomiernego rozkładu, jak pokazano w poniższym kodzie:

#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

W następnym przykładzie kodu przedstawiono bardziej realistyczny zestaw przypadków użycia z jednolicie rozproszonymi generatorami liczb losowych mieszania zawartości wektora i tablicy.

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

Ten kod demonstruje dwie różne losowe operacje — losowanie wektora liczb całkowitych i mieszania tablicy indeksowanych danych — z funkcją szablonu testowego. Pierwsze wywołanie funkcji testowej korzysta z bezpiecznego kryptograficznie, niedeterministycznego, niewymiennego, nie powtarzalnego urNG random_device. Drugi przebieg testu używa mersenne_twister_engine jako URNG z deterministycznym 32-bitowym stałym inicjatorem, co oznacza, że wyniki są powtarzalne. Trzeci test uruchamia nasiona mersenne_twister_engine z 32-bitowym wynikiem niedeterministycznym z random_device. Czwarty przebieg testu rozszerza się na to przy użyciu sekwencji nasion wypełnionej wynikami random_device , co skutecznie daje więcej niż 32-bitową losowość niedeterministyczną (ale nadal nie zabezpiecza kryptograficzną). Aby uzyskać więcej informacji, przeczytaj na ten temat.

Lista skategoryzowana

Jednolite generatory liczb losowych

Grupy URNG są często opisywane pod względem tych właściwości:

  1. Długość okresu: ile iteracji trwa, aby powtórzyć sekwencję wygenerowanych liczb. Tym dłużej lepiej.

  2. Wydajność: jak szybko można wygenerować liczby i ile pamięci potrzeba. Tym mniejsza jest lepsza.

  3. Jakość: Jak blisko prawdziwych losowych liczb jest wygenerowana sekwencja. Jest to często nazywane "losowością".

W poniższych sekcjach wymieniono jednolite generatory liczb losowych (URNG) podane w nagłówku <random> .

Generator niedeterministyczny

random_device Klasa
Generuje niedeterministyczną, kryptograficznie bezpieczną sekwencję losową przy użyciu urządzenia zewnętrznego. Zwykle używane do inicjowania silnika. Niska wydajność, bardzo wysoka jakość. Aby uzyskać więcej informacji, zobacz Uwagi.

Definicje typów aparatu ze wstępnie zdefiniowanymi parametrami

Do tworzenia wystąpień silników i adapterów silnika. Aby uzyskać więcej informacji, zobacz Aparaty i dystrybucje.

  • default_random_engine Aparat domyślny.

    typedef mt19937 default_random_engine;

  • knuth_b Silnik Knuth.

    typedef shuffle_order_engine<minstd_rand0, 256> knuth_b;

  • minstd_rand0 1988 minimalny standardowy silnik (Lewis, Goodman i Miller, 1969).

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

  • minstd_rand Zaktualizowano minimalny standardowy silnik minstd_rand0 (Park, Miller i Stockmeyer, 1993).

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

  • mt19937 32-bitowy silnik twister Mersenne (Matsumoto i 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-bitowy silnik twister Mersenne (Matsumoto i 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-bitowy silnik RANLUX (Martin Lüscher i Fred James, 1994).

    typedef discard_block_engine<ranlux24_base, 223, 23> ranlux24;

  • ranlux24_base Używany jako podstawa dla elementu ranlux24.

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

  • ranlux48 48-bitowy silnik RANLUX (Martin Lüscher i Fred James, 1994).

    typedef discard_block_engine<ranlux48_base, 389, 11> ranlux48;

  • ranlux48_base Używany jako podstawa dla elementu ranlux48.

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

Szablony aparatu

Szablony silników są używane jako autonomiczne grupy URNG lub jako aparaty podstawowe przekazywane do adapterów silnika. Zazwyczaj są one tworzone za pomocą wstępnie zdefiniowanego aparatu definicji typów i przekazywane do dystrybucji. Aby uzyskać więcej informacji, zobacz sekcję Aparaty i dystrybucje .

Nazwa/nazwisko opis
linear_congruential_engine Klasa Generuje sekwencję losową przy użyciu liniowego algorytmu kongruentalnego. Większość uproszczonych i najniższych jakości.
mersenne_twister_engine Klasa Generuje losową sekwencję przy użyciu algorytmu twister Mersenne. Najbardziej złożone i jest najwyższej jakości z wyjątkiem klasy random_device. Bardzo szybka wydajność.
subtract_with_carry_engine Klasa Generuje losową sekwencję przy użyciu algorytmu odejmowego z przenoszeniem. Poprawa w zakresie linear_congruential_engine, ale znacznie niższa jakość i wydajność niż mersenne_twister_engine.

Szablony adaptera aparatu

Adaptery silnika to szablony, które dostosowują inne (podstawowe) silniki. Zazwyczaj są one tworzone za pomocą wstępnie zdefiniowanego aparatu definicji typów i przekazywane do dystrybucji. Aby uzyskać więcej informacji, zobacz sekcję Aparaty i dystrybucje .

Nazwa/nazwisko opis
discard_block_engine Klasa Generuje losową sekwencję, odrzucając wartości zwracane przez aparat podstawowy.
independent_bits_engine Klasa Generuje losową sekwencję z określoną liczbą bitów przez ponowne spakowanie bitów z wartości zwracanych przez aparat podstawowy.
shuffle_order_engine Klasa Generuje losową sekwencję, zmieniając kolejność wartości zwracanych z aparatu podstawowego.

[Szablony aparatu]

Losowe rozkłady liczb

W poniższych sekcjach wymieniono dystrybucje podane w nagłówku <random> . Rozkłady są mechanizmem przetwarzania końcowego, zwykle przy użyciu danych wyjściowych URNG jako danych wejściowych i dystrybucji danych wyjściowych przez zdefiniowaną funkcję gęstości prawdopodobieństwa statystycznego. Aby uzyskać więcej informacji, zobacz sekcję Aparaty i dystrybucje .

Rozkłady jednolite

Nazwa/nazwisko opis
uniform_int_distribution Klasa Tworzy jednolity rozkład wartości całkowitych w całym zakresie w zamkniętym interwale [a, b] (włącznie).
uniform_real_distribution Klasa Tworzy jednolity rozkład wartości rzeczywistych (zmiennoprzecinkowych) w zakresie w interwale półwartym [a, b) (wykluczające się).
generate_canonical Tworzy równomierny rozkład rzeczywistych (zmiennoprzecinkowych) wartości danej precyzji w zakresie [0, 1) (włącznie z wyłącznościami).

[Losowe dystrybucje liczb]

Rozkłady Bernoulli

Nazwa/nazwisko opis
bernoulli_distribution Klasa Tworzy rozkład bool wartości Bernoulli.
binomial_distribution Klasa Tworzy rozkład dwumianowy wartości całkowitych.
geometric_distribution Klasa Tworzy geometryczny rozkład wartości całkowitych.
negative_binomial_distribution Klasa Tworzy ujemny rozkład dwumianowy wartości całkowitych.

[Losowe dystrybucje liczb]

Rozkłady normalne

Nazwa/nazwisko opis
cauchy_distribution Klasa Tworzy rozkład cauchy wartości rzeczywistych (zmiennoprzecinkowych).
chi_squared_distribution Klasa Tworzy rozkład chi kwadrat wartości rzeczywistych (zmiennoprzecinkowych).
fisher_f_distribution Klasa Tworzy rozkład F (znany również jako rozkład F Snedecor lub rozkład Fisher-Snedecor) wartości rzeczywistych (zmiennoprzecinkowych).
lognormal_distribution Klasa Tworzy rozkład normalny dziennika wartości rzeczywistych (zmiennoprzecinkowych).
normal_distribution Klasa Tworzy normalny (gaussański) rozkład wartości rzeczywistych (zmiennoprzecinkowych).
student_t_distribution Klasa Tworzy rozkład t-studenta wartości rzeczywistych (zmiennoprzecinkowych).

[Losowe dystrybucje liczb]

Rozkłady Poissona

Nazwa/nazwisko opis
exponential_distribution Klasa Tworzy rozkład wykładniczy wartości rzeczywistych (zmiennoprzecinkowych).
extreme_value_distribution Klasa Tworzy skrajny rozkład wartości rzeczywistych (zmiennoprzecinkowych).
gamma_distribution Klasa Tworzy rozkład gamma wartości rzeczywistych (zmiennoprzecinkowych).
poisson_distribution Klasa Tworzy rozkład wartości całkowitych poissona.
weibull_distribution Klasa Tworzy rozkład Weibull wartości rzeczywistych (zmiennoprzecinkowych).

[Losowe dystrybucje liczb]

Rozkłady próbkowania

Nazwa/nazwisko opis
discrete_distribution Klasa Tworzy dyskretny rozkład liczb całkowitych.
piecewise_constant_distribution Klasa Tworzy stały rozkład częściowych wartości rzeczywistych (zmiennoprzecinkowych).
piecewise_linear_distribution Klasa Tworzy liniowy rozkład fragmentaryzowy wartości rzeczywistych (zmiennoprzecinkowych).

[Losowe dystrybucje liczb]

Funkcje narzędziowe

Ta sekcja zawiera listę ogólnych funkcji narzędzi dostępnych w nagłówku <random> .

Nazwa/nazwisko opis
seed_seq Klasa Generuje sekwencję inicjowaną bez stronniczą. Służy do unikania replikacji losowych strumieni wariancji. Przydatne, gdy wiele urNG jest tworzone z aparatów.

Operatory

W tej sekcji wymieniono operatory podane w nagłówku <random> .

Nazwa/nazwisko opis
operator== Sprawdza, czy urNG po lewej stronie operatora jest równe silnikowi po prawej stronie.
operator!= Sprawdza, czy urNG po lewej stronie operatora nie jest równa silnikowi po prawej stronie.
operator<< Zapisuje informacje o stanie do strumienia.
operator>> Wyodrębnia informacje o stanie ze strumienia.

Aparaty i dystrybucje

Zapoznaj się z poniższymi sekcjami, aby uzyskać informacje na temat każdej z tych kategorii szablonów klas zdefiniowanych w programie <random>. Obie te kategorie szablonów klas przyjmują typ jako argument i używają udostępnionych nazw parametrów szablonu do opisania właściwości typu, które są dozwolone jako rzeczywisty typ argumentu, w następujący sposób:

  • IntTypeshortwskazuje , , int, unsigned shortlong longunsigned intlongunsigned longlub .unsigned long long

  • UIntType wskazuje unsigned short, unsigned int, , unsigned longlub unsigned long long.

  • RealTypewskazuje , floatdoublelub long double.

Silniki

Szablony aparatu i szablony adaptera aparatu to szablony, których parametry dostosowują utworzony generator.

Aparat jest szablonem klasy lub klasy, którego wystąpienia (generatory) działają jako źródło liczb losowych równomiernie rozłożone między minimalną i maksymalną wartością. Adapter silnika dostarcza sekwencję wartości, które mają różne właściwości losowości, przyjmując wartości generowane przez inny aparat liczb losowych i stosując algorytm pewnego rodzaju do tych wartości.

Każdy silnik i adapter silnika mają następujące elementy członkowskie:

  • typedefnumeric-typeresult_typejest typem zwracanym przez generator .operator() Parametr numeric-type jest przekazywany jako parametr szablonu podczas tworzenia wystąpienia.

  • result_type operator() zwraca wartości równomiernie rozłożone między min() i max().

  • result_type min()Zwraca wartość minimalną zwracaną przez generator .operator() Adaptery silnika używają wyniku silnika min() podstawowego.

  • result_type max()Zwraca wartość maksymalną zwracaną przez generator .operator() Jeśli result_type jest typem całkowitolicztnym (całkowitowartym), jest wartość maksymalna, max() którą można faktycznie zwrócić (włącznie); gdy result_type jest typem zmiennoprzecinkowym (wartość rzeczywista), jest najmniejszą wartością większą niż wszystkie wartości, max() które mogą być zwracane (bez włącznie). Adaptery silnika używają wyniku silnika max() podstawowego.

  • void seed(result_type s) wysieje generator z wartością snasion . W przypadku aparatów podpis jest void seed(result_type s = default_seed) przeznaczony do obsługi parametrów domyślnych (adaptery aparatu definiują oddzielną void seed()podsekcję ).

  • template <class Seq> void seed(Seq& q)nasion generatora przy użyciu .seed_seqSeq

  • Jawny konstruktor z argumentem result_type x , który tworzy generator rozstawiony tak, jakby przez wywołanie metody seed(x).

  • Jawny konstruktor z argumentem seed_seq& seq , który tworzy generator rozstawiony tak, jakby przez wywołanie metody seed(seq).

  • void discard(unsigned long long count) skutecznie wywołuje operator()count czasy i odrzuca każdą wartość.

Adaptery silnika dodatkowo obsługują te elementy członkowskie (Engine jest pierwszym parametrem szablonu adaptera silnika, wyznaczającym typ silnika podstawowego):

  • Domyślny konstruktor do inicjowania generatora tak, jakby z domyślnego konstruktora aparatu bazowego.

  • Jawny konstruktor z argumentem const Engine& eng. Ma to na celu obsługę konstrukcji kopii przy użyciu aparatu podstawowego.

  • Jawny konstruktor z argumentem Engine&& eng. Jest to wspieranie przenoszenia konstrukcji przy użyciu silnika podstawowego.

  • void seed() inicjuje generator z domyślną wartością inicjatora aparatu bazowego.

  • const Engine& base() funkcja właściwości zwracająca aparat podstawowy, który został użyty do konstruowania generatora.

Każdy aparat zachowuje stan określający sekwencję wartości, które zostaną wygenerowane przez kolejne wywołania funkcji operator(). Stany dwóch generatorów utworzone z silników tego samego typu można porównać za pomocą poleceń operator== i operator!=. Jeśli dwa stany są porównywane jako równe, wygenerują tę samą sekwencję wartości. Stan obiektu można zapisać w strumieniu jako sekwencję 32-bitowych wartości niepodpisanych przy użyciu operator<< generatora. Stan nie jest zmieniany przez zapisanie go. Zapisany stan można odczytać do generatora utworzonego z aparatu tego samego typu przy użyciu polecenia operator>>.

Dystrybucji

Rozkłady liczb losowych to szablon klasy lub klasy, którego wystąpienia przekształcają strumień równomiernie rozproszonych liczb losowych uzyskanych z aparatu w strumień liczb losowych, które mają określony rozkład. Każda dystrybucja ma następujące elementy członkowskie:

  • typedefnumeric-typeresult_typejest typem zwracanym przez rozkład .operator() Parametr numeric-type jest przekazywany jako parametr szablonu podczas tworzenia wystąpienia.

  • template <class URNG> result_type operator()(URNG& gen) zwraca wartości, które są dystrybuowane zgodnie z definicją rozkładu, przy użyciu gen jako źródła równomiernie rozproszonych wartości losowych i przechowywanych parametrów rozkładu.

  • template <class URNG> result_type operator()(URNG& gen, param_type p) zwraca wartości rozproszone zgodnie z definicją rozkładu, używając gen jako źródła jednolicie rozproszonych wartości losowych i struktury pparametrów .

  • typedefunspecified-typeparam_type to pakiet parametrów opcjonalnie przekazywanych do operator() parametrów i jest używany zamiast przechowywanych parametrów w celu wygenerowania wartości zwracanej.

  • Konstruktor const param& inicjuje przechowywane parametry z argumentu.

  • param_type param() const pobiera przechowywane parametry.

  • void param(const param_type&) Ustawia przechowywane parametry z jego argumentu.

  • result_type min()Zwraca wartość minimalną zwracaną przez rozkład .operator()

  • result_type max()Zwraca wartość maksymalną zwracaną przez rozkład .operator() Jeśli result_type jest typem całkowitolicztnym (całkowitowartym), jest wartość maksymalna, max() którą można faktycznie zwrócić (włącznie); gdy result_type jest typem zmiennoprzecinkowym (wartość rzeczywista), jest najmniejszą wartością większą niż wszystkie wartości, max() które mogą być zwracane (bez włącznie).

  • void reset() odrzuca wszystkie buforowane wartości, dzięki czemu wynik następnego wywołania operator() nie zależy od żadnych wartości uzyskanych z aparatu przed wywołaniem.

Struktura parametrów to obiekt, który przechowuje wszystkie parametry wymagane do dystrybucji. Zawiera:

  • typedefdistribution-typedistribution_type, który jest typem jego rozkładu.

  • Co najmniej jeden konstruktor, który przyjmuje te same listy parametrów co konstruktory dystrybucji.

  • Te same funkcje dostępu do parametrów co dystrybucja.

  • Operatory porównania równości i nierówności.

Aby uzyskać więcej informacji, zobacz podtopy referencyjne poniżej tego, połączone wcześniej w tym artykule.

Uwagi

W programie Visual Studio istnieją dwie wysoce przydatne grupy URING —mt19937 i random_device— jak pokazano w poniższej tabeli porównania:

URNG Szybkie przetwarzanie Zabezpieczanie kryptograficzne Możliwe do rozmieszczania Deterministyczny
mt19937 Tak Nie Tak Tak*
random_device Nie Tak Nie. Nie.

* W przypadku podania znanego nasion.

Mimo że standard ISO C++ nie wymaga random_device kryptograficznego bezpieczeństwa, w programie Visual Studio jest implementowany w celu zapewnienia bezpieczeństwa kryptograficznego. (Termin "kryptograficznie bezpieczny" nie oznacza gwarancji, ale odnosi się do minimalnego poziomu entropii — a zatem poziomu przewidywalności — zapewnia dany algorytm randomizacji. Aby uzyskać więcej informacji, zobacz artykuł Wikipedia Kryptograficznie bezpieczny generator numerów pseudorandom. Ponieważ standard ISO C++ nie wymaga tego, inne platformy mogą implementować random_device jako prosty generator liczb pseudolosowych (nie kryptograficznie bezpieczny) i mogą być odpowiednie tylko jako źródło nasion dla innego generatora. Zapoznaj się z dokumentacją tych platform podczas korzystania z random_device kodu międzyplatformowego.

Z definicji random_device wyniki nie są powtarzalne, a efekt uboczny jest taki, że może działać znacznie wolniej niż inne grupy URNG. Większość aplikacji, które nie są wymagane do kryptograficznego bezpiecznego użycia mt19937 lub podobnego aparatu, chociaż można zainicjować je za pomocą wywołania metody random_device, jak pokazano w przykładzie kodu.

Zobacz też

Odwołanie do plików nagłówka