Bonjour, je suis le cours de C++ disponible ici et je suis donc au chapitre sur la génération aléatoire. Mais dans la partie sur les générateurs déterministes, pour changer automatiquement la graine toutes les secondes, il est montré l'utilisation de la fonction std::time, sauf que j'ai une erreur en rentrant la même chose, disant que l'expression time n'est pas définie dans l'espace de nom std... Sur la page de cppreference dédiée à cette fonction, j'ai aussi remarqué qu'il faut inclure cmath au début du code, mais même en faisant ça, ça ne marche pas... Merci d'avance pour votre aide

Regarde mon post ici: 
https://openclassrooms.com/forum/sujet/std-make-pair-recalcitrant
Tu y trouveras ce que tu cherches.

-
Edité par Deedolith 30 août 2018 à 19:52:27

C'est <ctime> et pas <cmath> qu'il faut inclure. Le code fonctionne normalement, parce que <chrono> inclue <ctime> (mais c'est mieux d'utiliser <ctime>, je vais corriger.

Quelle version de C++ utilises tu ?

( @Deedolith un service locator, c'est un peu bourrin Et le cout d'une fonction virtuelle pour juste un nombre random, c'est violent)

Autant pour moi,  je suis pas malin, j'ai mis cmath au lieu de ctime, je ne sais pas pourquoi

En tout cas, dans mon code j'ai bien mis ctime, mais ca ne marche pas 

J'utilise Visual Studio Pro 2017 mais je ne sais pas quelle est ma version de C++ 

Pour montrer exactement le code que j'ai mis, le voici :

#include <iostream>
#include <random>
#include <ctime>

int main()
{
	auto const seed = std::time(nullptr);
	std::default_random_engine random_engine{ seed };
	std::uniform_int_distribution<> uniform_int(0, 5);
	auto const value = uniform_int(random_engine);
	std::cout << value << std::endl;

	system("pause");
}

Mais j'ai ces erreurs :
(même si on dirait que le premier avertissement n'a rien à voir avec le reste, j'aurai pas dû renommer le projet, peut être... J'ai cet avertissement de conflits, à cause de ça, même si tout marche bien quand même mis à part le problème actuel pour ctime )

-
Edité par CypElf 31 août 2018 à 21:23:30

Il te faut caster le seed dans la construction du random_engine, un random_engine ne s'initialise pas avec un time_t.

std::default_random_engine random_engine{ static_cast<std::uint64_t>(std::time(nullptr)) };
std::uniform_int_distribution<> uniform_int{0, 5};
auto const value = uniform_int(random_engine);

Et puis tant qu'a faire, uniformise tes initialisations, utilise toujours {}, plutôt que () (quand c'est possible bien sûr) passer de l'un à l'autre en fonction de la vitesse du vent et de l'age du capitaine nuit grandement à la lisibilité du code. 

-
Edité par int21h 1 septembre 2018 à 20:09:27

Hello,

Ça n'a malheureusement toujours pas l'air de marcher, voici donc le nouveau code :

#include <iostream>
#include <random>
#include <ctime>

int main()
{
	std::default_random_engine random_engine{ static_cast<std::uint64_t>(std::time(nullptr)) };
	std::uniform_int_distribution<> uniform_int{ 0, 5 };
	auto const value = uniform_int(random_engine);
	std::cout << value << std::endl;

	system("pause");
}

Mais j'ai ces erreurs (quasiment les mêmes qu'avant, en somme, une conversion de type est faite alors que ça ne devrait pas être le cas si tout allait bien, enfin je suppose, en lisant les erreurs) :

-
Edité par CypElf 2 septembre 2018 à 20:03:26

Hello,

Ton programme est en 32-bit, d'où l'erreur si je ne m'abuse, donc ça devrait fonctionner avec uint32_t.

Par contre de mon côté, le random n'a jamais fonctionné avec l'engine par défaut et time, il me sort à chaque fois le même nombre. Si jamais tu as le même souci, il faut y aller à coup de chrono :

#include <iostream>
#include <random>
#include <chrono>

int main()
{
    unsigned seed = std::chrono::system_clock::now().time_since_epoch().count();
    
    std::default_random_engine random_engine{seed};
    std::uniform_int_distribution<> uniform_int{0, 5};

    const auto value = uniform_int(random_engine);

    std::cout << value;

    return 0;
}

Après personnellement, j'utilise le mersenne twister engine, il ne m'a jamais causé de souci à contrario de l'engine par défaut :

#include <iostream>
#include <random>
#include <ctime>

int main()
{
    std::mt19937 random_engine{static_cast<uint32_t>(time(nullptr))};
    std::uniform_int_distribution<> uniform_int{0, 5};

    const auto value = uniform_int(random_engine);

    std::cout << value;

    return 0;
}

Merci, avec un uint_32t ca marche impec', par contre quand je met chrono au lieu de ctime, time n'est pas détecté comme membre de la bibliothèque standard d'après les erreurs, ctime est vraiment inclut dans chrono ?
Je ne comprends pas vraiment tout ce que j'ai du écrire pour que ça marche finalement, mais bon, maintenant ça marche

Hors sujet. Ecrire un chapitre sur les nombres aléatoire n'est pas simple en fait. Utiliser ran() est simple mais masque les problématiques des nombres aléatoires, ce qui n'est pas une bonne chose. <random> permet d'aborder réellement les nombres aléatoires, mais au prix d'une complexité plus importante. Il est probable que la solution soit d'aborder les nombres aléatoires beaucoup plus tardivement dans le cours.

Ça pourrait être un choix

En fait, l'aléatoire relève plus souvent de la contingence que du choix propre. Il est donc assez difficile de proposer une stratégie de génération de nombre aléatoires (pseudo aléatoires) en dehors des contingences dans lesquelles elle sera utilisé. Un exemple, tu ne vas pas définir les mêmes contraintes sur la génération de nombre aléatoires si tu travailles sur le TP du dictionnaire de ce site ou sur un algorithme de cryptographie de qualité militaire. Si quelqu'un casse ton algo de sélection d'un mot aléatoire dans le dictionnaire, c'est pas trop grave, s'il casse les codes d'une valise nucléaire, c'est un peu plus problématique, s'il casse le code de génération des tirages du loto, ça peut aussi poser pas mal de problèmes, s'il casse le challenge de ta carte bleue, tu risques fort de voir ton compte descendre très vite en dessous du découvert maximum autorisé....

Il se trouve que la génération de nombre aléatoire est un point sensible dans de très nombreux programmes, parfois pour des question de fun (le mot magique), parfois pour des raisons de sécurité critiques (la valise nucléaire), parfois aussi pour des raisons pratiques, imagine un serveur qui contrôle des centaines de clients, si tous les clients se connectent en même temps, le serveur ne peut les servir et va probablement s'effondrer sous la charge, par contre, si chaque client retarde sa connexion d'un petit aléa, le serveur pourra servir et ne s'effondrera pas sous la charge, parce qu'ils ne se connecteront pas tous exactement en même temps, la différence entre le serveur qui s'effondre et celui qui tient la marée va se jouer à quelques millisecondes d'aléa, celui qui se prend tout dans la gueule tombe, celui qui se prend tout dans la gueule avec un décalage de quelques ms entre chaque connexion survit. Une petite analyse sur les contraintes de génération du nombre aléatoire fait clairement apparaître qu'elles sont très différentes, c'est pourquoi il est très difficile de faire un cours sur l'aléatoire.