Remplissez le tableau avec des nombres aléatoires en C ++

Le remplissage d'un tableau avec des nombres aléatoires est simple s'il est supposé que le tableau est de 10 éléments. Pour ce faire, générez un nombre aléatoire et mettez dans le tableau comme premier élément. Générer un autre nombre aléatoire et mettre en tant que deuxième élément. Ensuite, générez à nouveau un troisième nombre aléatoire et mettez en tant que troisième élément. Continuez de cette façon jusqu'à ce que le dixième élément soit atteint.

Cependant, voici d'autres choses à apprécier avant de coder. Les nombres aléatoires générés par C ++ 20 suivent une séquence. Il existe de nombreuses séquences de ce type, donc les nombres aléatoires ne sont pas vraiment aléatoires. L'utilisateur du programme ne sera guère en mesure de savoir quelle séquence le programmeur a choisi et comment déterminer le numéro suivant, lorsque la fonction aléatoire est appelée, dans le même code.

Chaque séquence a un numéro de départ. La graine est liée au nombre de départ d'une séquence. Chaque séquence dépend de la graine et de la distribution de séquence. La distribution de séquence est le profil de la séquence.

Cet article explique comment remplir un tableau avec des nombres aléatoires commençant par les classes: random_device, default_random_ngine et uniforme_int_distribution. Ces classes sont toutes dans la bibliothèque aléatoire qui doit être incluse. Le squelette d'un programme pour remplir un tableau de 10 éléments, avec des nombres aléatoires, est le suivant:

#inclure
#inclure
Utilisation de Namespace Std;
int arr [10];
int main()

// déclarations
retour 0;

Notez que tout type arithmétique peut être utilisé comme type d'élément pour le tableau. La taille du tableau est de 10. Cependant, un nombre de nombres aléatoires peut être obtenu.

Moteur et distribution

Dans ce sujet, un moteur est un générateur de nombres aléatoires.

random_device

Ceci est une classe à partir de laquelle les objets sont instanciés. Un objet de cette classe est un appareil et non un moteur. Cela a besoin d'un générateur pour être utile. Un générateur peut prendre un random_device comme argument.

Default_random_Engine

Un moteur dans ce sujet génère des nombres aléatoires. Il existe différents moteurs à partir desquels le programmeur peut choisir. Cela doit être choisi lorsque le programmeur n'est pas sûr du moteur à choisir. Ceci est une classe à partir de laquelle les objets sont instanciés. Il faut un objet Random_Device comme argument.

uniforme_int_distribution

Il existe de nombreux profils de distribution de séquences que le programmeur peut choisir. Celui choisi pour cet article est: Uniform_int_distribution. Ceci est une classe à partir de laquelle les objets peuvent être créés. Sa construction prend un moteur comme argument, ainsi que les nombres de limite inférieure et supérieure pour les nombres aléatoires. C'est en fait un modèle de classe. L'une de ses syntaxes de construction est:

Explicit Uniform_int_distribution (Inttype A, Inttype B = Numeric_limits:: max ());

Les trois déclarations suivantes fonctionnent ensemble:

random_device rd;
Default_random_Engine Eng (rd ());
uniforme_int_distribution dist (4, 13);

De 4 à 13 sont dix entiers, y compris les limites inférieures et supérieures. La spécialisation du modèle pour l'objet de distribution, dist, est int. Ainsi, dix nombres aléatoires différents peuvent être choisis dans cette plage, (4 - 13). Notez que l'argument pour eng () est rd () et non rd. Notez également que tout type arithmétique pourrait être la spécialisation du modèle pour cette construction de distribution.

À partir de ce code, pour obtenir le numéro aléatoire suivant, utilisez «Dist (Eng);» .

Produire dix entiers aléatoires

Le programme suivant, produit dix entiers aléatoires, de 4 à 13 inclus.

#inclure
#inclure
Utilisation de Namespace Std;
int main()

random_devicerd;
Default_random_EngineEng (rd ());
Uniform_int_distributionDist (4, 13);
couter<couter<retour 0;

La sortie de l'ordinateur de l'auteur est:

7 10 4 10 6
8 12 6 12 8

Certains nombres se sont produits plus d'une fois. Le programme commence par l'inclusion de la bibliothèque ioStream pour l'entrée et la sortie. Après cela, la bibliothèque aléatoire est incluse pour les nombres aléatoires. La ligne suivante est une déclaration et non une directive. Ça se termine par un point-virgule. Il insiste sur le fait que tout nom, non précédé de «std ::», est de l'espace de noms standard.

Ensuite, il y a la fonction principale C ++. Les trois premières déclarations de la fonction principale ont été expliquées, précédemment. Dans le segment de code suivant, DIST (ENG) sortit le numéro aléatoire suivant; Bien sûr, dans la gamme (inclusive), présenté comme arguments au constructeur de distribution.

Remplir un tableau avec des nombres aléatoires

Dans le code ci-dessus, dix nombres aléatoires ont été produits avec l'expression, dist (Eng). Il a été tapé dix fois. Il peut être dactylographié une fois et être appelé dix fois, s'il est fait dans une boucle pour. La boucle pour deviendra dix fois. Dans cette situation, le numéro aléatoire de retour ne sera pas envoyé au terminal (écran); il sera envoyé à l'emplacement d'élément suivant, du tableau. Le programme suivant illustre ceci:

#inclure
#inclure
Utilisation de Namespace Std;
int arr [10];
int main()

random_devicerd;
Default_random_EngineEng (rd ());
Uniform_int_distributionDist (4, 13);
pour (int i = 0; i<10; i++)
arr [i] = dist (Eng);
pour (int i = 0; i<10; i++)
couter<couter<retour 0;

La sortie de l'ordinateur de l'auteur, cette fois, est:

9 8 12 10 8 10 8 5 4 11

Notez comment la première boucle pour la boucle a été codée. Bien sûr, n'importe quelle gamme peut être choisie, le programme suivant utilise une plage de 0 à 100:

#inclure
#inclure
Utilisation de Namespace Std;
int arr [10];
int main()

random_devicerd;
Default_random_EngineEng (rd ());
Uniform_int_distributionDist (0, 100);
pour (int i = 0; i<10; i++)
arr [i] = dist (Eng);
pour (int i = 0; i<10; i++)
couter<couter<retour 0;

La sortie de l'ordinateur de l'auteur, cette fois, est:

43 52 52 24 90 81 21 72 33 42

Bien que la gamme compte plus de dix entiers, seuls dix nombres aléatoires ont été produits, comme décidé par la première boucle pour.

Conclusion

Effectuez la procédure suivante pour remplir un tableau avec des nombres aléatoires: générez un nombre aléatoire et placez le tableau, comme premier élément. Générer un autre nombre aléatoire et mettre en place, comme deuxième élément. Générer un troisième nombre aléatoire et mettre en place, comme troisième élément. Continuez de cette façon jusqu'à ce que le nombre de nombres aléatoires requis soit atteint. Le segment de code suivant est important:

int arr [10];
random_device rd;
Default_random_Engine Eng (rd ());
uniforme_int_distribution dist (0, 100);
pour (int i = 0; i<10; i++)
arr [i] = dist (Eng);