<random>
Definiuje obiekty do generowania liczb losowych, umożliwiając tworzenie równomiernie rozproszonych liczb losowych.
Nagłówek: <random>
Przestrzeń nazw: std
Uwaga
Biblioteka <random>
używa instrukcji "#include initializer_list<>".
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:
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 Bezpieczeństwo wątków 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 elementemuniform_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.
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.
Grupy URNG są często opisywane pod względem tych właściwości:
Długość okresu: ile iteracji trwa, aby powtórzyć sekwencję wygenerowanych liczb. Tym dłużej lepiej.
Wydajność: jak szybko można wygenerować liczby i ile pamięci potrzeba. Tym mniejsza jest lepsza.
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>
.
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.
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 silnikminstd_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 elementuranlux24
.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 elementuranlux48
.typedef subtract_with_carry_engine<unsigned long long, 48, 5, 12> ranlux48_base;
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 . |
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]
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 .
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]
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]
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]
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]
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]
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. |
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. |
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:
IntType
short
wskazuje , ,int
,unsigned short
long long
unsigned int
long
unsigned long
lub .unsigned long long
UIntType
wskazujeunsigned short
,unsigned int
, ,unsigned long
lubunsigned long long
.RealType
wskazuje ,float
double
lublong double
.
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:
typedef
numeric-type
result_type
jest typem zwracanym przez generator .operator()
Parametrnumeric-type
jest przekazywany jako parametr szablonu podczas tworzenia wystąpienia.result_type operator()
zwraca wartości równomiernie rozłożone międzymin()
imax()
.result_type min()
Zwraca wartość minimalną zwracaną przez generator .operator()
Adaptery silnika używają wyniku silnikamin()
podstawowego.result_type max()
Zwraca wartość maksymalną zwracaną przez generator .operator()
Jeśliresult_type
jest typem całkowitolicztnym (całkowitowartym), jest wartość maksymalna,max()
którą można faktycznie zwrócić (włącznie); gdyresult_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 silnikamax()
podstawowego.void seed(result_type s)
wysieje generator z wartościąs
nasion . W przypadku aparatów podpis jestvoid 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_seq
Seq
Jawny konstruktor z argumentem
result_type x
, który tworzy generator rozstawiony tak, jakby przez wywołanie metodyseed(x)
.Jawny konstruktor z argumentem
seed_seq& seq
, który tworzy generator rozstawiony tak, jakby przez wywołanie metodyseed(seq)
.void discard(unsigned long long count)
skutecznie wywołujeoperator()
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>>
.
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:
typedef
numeric-type
result_type
jest typem zwracanym przez rozkład .operator()
Parametrnumeric-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życiugen
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ącgen
jako źródła jednolicie rozproszonych wartości losowych i strukturyp
parametrów .typedef
unspecified-type
param_type
to pakiet parametrów opcjonalnie przekazywanych dooperator()
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śliresult_type
jest typem całkowitolicztnym (całkowitowartym), jest wartość maksymalna,max()
którą można faktycznie zwrócić (włącznie); gdyresult_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łaniaoperator()
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:
typedef
distribution-type
distribution_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.
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.