Bonjour, j'ai réaliser ce TP et après avoir reçu les remarques de mes correcteurs, j'essaye d'optimiser mon code afin de prendre de bonnes habitudes.

J'ai rencontré 2 problèmes lors de cet exercices le premier provient de la fonction 'rand' qui ne permet pas d'obtenir un 'int' supérieur à 32727, et j'ai aussi remarqué que le résultat de ce 'rand' restait toujours dans la même fourchette lors de mes test les résultats tournaient entre 19 000 et 20 000.

La deuxième question que je me pose lors de chaque nouvelle partie je recharge le dictionnaire en faisant appel à une fonction. Hors si j'ai bien compris lorsque la fonction est lue mon 'vector' mots est effacer de la mémoire. Que vaut t'il mieux faire garder en mémoire ce 'vector' ou l'effacer lorsque j'en ai plus besoin pour le reste du programme.

J'ai utiliser aussi le 'namespace std' pour être sur la même longueur d'onde que le cours sinon j'ai lu qu'il est préférable d'utiliser 'std::' .

Voici mon code, je vous remercie d'avance pour vos conseils.

#include <iostream>
#include <string>
#include <ctime>
#include <cstdlib>
#include <fstream>
#include <vector>

using namespace std;
string melangerLettres(string mot)
{
	string melange;
	int position(0);

	//Tant qu'on a pas extrait toutes les lettres du mot
	while (mot.size() != 0)
	{
		//On choisi un numéro de lettre au hasard dans le mot
		position = rand() % mot.size();
		//On ajjoute la lettre dans le mot mélangé
		melange += mot[position];
		//On retire cette lettre du mot mystère
		//Pour ne pas la prendre une deuxième fois
		mot.erase(position, 1);
	}

	//On renvoie le mot mélangé
	return melange;
}

char rejouer(char ouiNon)
{
	
	// boucle tant que la lettre tapée n'est pas "o" ou "n".
	do
	{
		cout << "Voulez vous rejouer  O/N ?" << endl << endl;
		cin >> ouiNon;

		if (ouiNon == 'o')
		{
			cout << "Nouvelle partie !" << endl << endl;
		}
		else if (ouiNon == 'n')
		{
			cout << "Fin du jeu !" << endl << endl;
		}
		else
		{
			cout << "Erreur veuillez taper \"o\" ou \"n\" !" << endl << endl;
		}
	} while (ouiNon != 'n' && ouiNon != 'o');

	return ouiNon;
}

void pause()
{
	cout << "Apuyez sur la touche Entree pour quitter ..." << endl;
	cin.ignore();
	cin.get();
}

//ouverture du dictionnaire et choix du mot
string motAleatoire(string mot)
{
	vector<string> mots;
	int aleatoire;

	ifstream dico("dico.txt");
	if (dico)
	{
		while (dico >> mot)
		{
			mots.push_back(mot);
			aleatoire = rand() % mots.size();
			mot = mots[aleatoire];
		}
	}
	//si le dictionnaire est corrompu ou manquant fermeture du programme
	else
	{
		cout << "Erreur impossible de lire le dictionnaire" << endl;
		pause();
		exit(EXIT_FAILURE);
	}
	return mot;
}


int main()
{
	// Initialisation des nombres aléatoires
	srand(time(0));

	char ouiNon('a');

	//Message de bienvenue

	cout << "Trouvez le mot MYSTERE moins de 5 tentatives" << endl << endl;
	cout << "Bonne chance !!!" << endl << endl;

	do
	{
		string motMystere, motMelange, motUtilisateur;

		int compteur(0);

		//On cree le mot mystere
		motMystere = motAleatoire(motMystere);

		//On récupère le mot avec les lettres mélangées dans motMelange
		motMelange = melangerLettres(motMystere);

		// On commence à compter les essais .
		compteur++;

		//On demande à l'utilisateur quel est le mot mystère
		do
		{

			cout << endl << "Essai " << compteur << "/5" << endl << endl;
			cout << endl << "Quel est ce mot ? " << motMelange << endl;
			//l'utilisateur entre un mot
			std::cin >> motUtilisateur;

			if (motUtilisateur == motMystere)
			{
				cout << "Vous avez gagne en " << compteur << " coups."<< endl;
				//On appelle la fonction gagne
				
			}
			else
			{
				cout << "Ce n'est pas le mot !" << endl << endl;
				//On ajoute +1 au compteur d'essais
				compteur++;
				//si le compteur arrive à 5 c'est perdu.
				if (compteur > 5)
				{
					cout << "Vous avez Perdu le Mot mystere est " << motMystere << endl << endl;
					
					//fin du jeu
					ouiNon = rejouer(ouiNon);
				}

			}
		} while (motUtilisateur != motMystere);
		//On recommence tant qu'il n'a pas trouvé

	} while (ouiNon == 'o');
	pause();
	return 0;
	}

Lu'!

Changes de cours. Il apprend un sacré paquet d'âneries à ne pas faire, en plus de montrer des exemples de code buggés et d'être obsolète (quelques recherches sur le forum t'en diront plus). Prends plutôt le tutoriel disponible sur Zeste de Savoir. Ou encore le cours de C++ de @gbdivers, même s'il est encore en écriture il ne contient pas ce genre de bavures (et si tu as des problèmes de compréhension sur une partie et que ce n'est pas à cause d'un manque d'étude du cours, tu peux poster ici). Si tu préfères un cours déjà complet, tourne toi vers le C++ Primer de Lippman dans sa dernière édition (en anglais), il sera un poil moins à jour mais c'est un bon cours.

Quelques remarques concernant ton code :

• ne met pas de commentaires s'ils sont inutiles (tous ici). Le bon commentaire, c'est celui qui n'est pas écrit parce que le code est clair et n'en nécessite pas,
• n'utilise pas "using namespace std" (raison + que faire),
• ne déclare pas tes variables en avance,
• fais plus de fonctions, découpe plus ton code,
• les fonctionnalités srand/rand sont des fonctionnalités dépréciées du langage C, utilise les fonctions du header random,
• ta fonction de choix aleatoire est très bizarre (l'entrée ne sert à rien, tu changes le mot à chaque tour sans aucune raison),
• tu relis ton fichier chaque fois que tu as besoin d'un mot, c'est très inefficace, charges tout dans un vector et conserve ce vector pour y piocher des mots,
• dans ton mélange, tu récupères la position dans un entier, mais le type des index est std::size_t (et pour mélanger, il existe std::shuffle).

Ton problème vient d'une limitation intrinsèque à rand(). Cette fonction renvoie comprise entre RAND_MIN et RAND_MAX qui s'avèrent souvent être SHORT_MIN et SHORT_MAX. Soit de petites valeurs. Utilise les fonctionnalités de C++ comme proposé plus haut.

-
Edité par Ksass`Peuk 29 octobre 2018 à 13:10:18

Merci pour tes conseils rapide.

Je n'utiliserais plus 'using namespace std'.

J'ai retardé au maximum la déclaration des variables.

je ne ferais plus 

int unInt;
//du code
unInt = 10;

mais plutôt

//du code

int unInt = 10;

Pour les fonctions j'avais peur d'en faire de trop et je n'ai pas osé je vais continuer d'expérimenter et en créer de nouvelles.

Effectivement je crée un nouveau mot mystère a chaque tour vu que j'appelais ma fonction 'motAleatoire'  dans une boucle 'do while' et ça n'avait rien à faire là. Je dois créer une fonction séparée qui stocke le dictionnaire dans un 'vector'.

Je ne suis qu'au début de mon apprentissage et je fait le maximum pour me remettre en question et prendre les bonnes habitudes grâce à tes conseils et avec tous les liens que tu m'a donné j'ai de quoi faire merci encore.

Salut,

Jean-LouisGustine a écrit:

Pour les fonctions j'avais peur d'en faire de trop et je n'ai pas osé je vais continuer d'expérimenter et en créer de nouvelles.

Il est vrai que l'on se demande parfois si on ne fait pas "trop" de fonctions...

Mais, l'un dans l'autre, si chaque fonction que l'on peut créer ne prend qu'une et une seule responsabilité, nous ne pourrons jamais qu'arriver à un point où il n'y aura que "juste assez" de fonctions

Il ne faut pas essayer de "partager" la responsabilité d'une fonction, ce qui mènerait effectivement à en avoir trop.  Mais il s'agit surtout de  veiller à ce que chaque fonction ne fasse que "ce qu'elle est sensée faire":

Si tu veux, dans l'ordre,

1. extraire les différents mots que tu trouve dans un fichier
2. choisir un (unique) mot parmi ceux que tu as extraits en (1)
3. mélanger les lettres qui composent le mot que tu as choisi
4. poser différentes questions à différents moments à l'utilisateur
5. suivre une logique particulière qui mette les réponses de l'utilisateur en rapport avec le mot choisi en (2) et mélangé en (3)
6. recommencer en (2), pour que l'utilisateur puisse faire plusieurs partie
7. mettre le tout "en musique" pour obtenir une application exécutable

tu te retrouve directement avec plus de sept responsabilités distinctes (car tu devras compter au moins deux responsabilités distinctes pour chaque question que tu veux poser à l'utilisateur : une pour l'afficher, et l'autre pour ... récupérer sa réponse).

Alors, bien sur, il est sans doute possible de réutiliser certaines des responsabilités décrites en (4), parce qu'il n'y a que quelques détails qui changent (on dit qu'on "factorise" le code ), mais le compte effectué ici est relativement juste

Pour chacune de ces responsabilité, il faudra prévoir une fonction particulière, en sachant:

• que le (7) correspondra à la fonction principale "main"
• que le (7) et le (5) vont -- de toute évidence -- faire visiblement "prendre en charge" ... "toute la logique" qui permet de faire appel à des responsabilités plus précises

Mais, au final, la création d'une application n'est jamais qu'un jeu de légo : on commence par créer des "petites briques" basiques (les fonctions les plus simples), que l'on pourra assembler entre  elles pour obtenir des "pans de murs" (des fonctions plus complexes), qui seront -- eux aussi -- assemblés entre eux pour obtenir les murs (des fonctions encore plus complexes), que nous pourons utiliser pour construire des tours, des douves, des bâtiments divers et variés et des remparts (des fonctions de plus en plus complexes) que nous pourrons regrouper pour construire ... notre zoli chateau-fort / notre zolie ville fortifiée (notre application).

-
Edité par markand 29 octobre 2018 à 17:19:41

markand a écrit:

Ta fonction melangerLettres s'écrit en 2 lignes avec C++11. Une fonction et un return.

-
Edité par markand il y a 44 minutes

Random_shuffle??? 

est-ce que je chauffe?

edit: j'ai tenté ceci et ça marche bien

std::string melangerLettres(std::string mot)
{
	auto rng = std::default_random_engine{};
	shuffle(std::begin(mot), std::end(mot), rng);

	//On renvoie le mot mélangé
	return mot;
}

-
Edité par Jean-LouisGustine 29 octobre 2018 à 18:29:37

Jean-LouisGustine a écrit:

Random_shuffle???

Ksass`Peuk a écrit:

• dans ton mélange, tu récupères la position dans un entier, mais le type des index est std::size_t (et pour mélanger, il existe std::shuffle).

Le do ->while(motUtilisateur != motMystere); il faut ajouter le compteur <= 5 dans la condition genre (motUtilisateur != motMystere) || (compteur <= 5)

wafistos a écrit:

Le do ->while(motUtilisateur != motMystere); il faut ajouter le compteur <= 5 dans la condition genre (motUtilisateur != motMystere) || (compteur <= 5)

} while (motUtilisateur != motMystere || compteur <= 5);

mais ça ne marche pas il ne prend pas en compte le deuxième argument et je reste coincé dans la boucle 

Pour palier à ce problème j'ai utilisé un bool du grenre 

bool fini(false);

		//On demande à l'utilisateur quel est le mot mystère
		do
		{
			std::cout << std::endl << "Essai " << compteur << "/5" << std::endl << std::endl;
			std::cout << std::endl << "Quel est ce mot ? " << motMelange << std::endl;

			//l'utilisateur entre un mot
			std::cin >> motUtilisateur;
			
			if (motUtilisateur == motMystere)
			{
				std::cout << "Vous avez gagne en " << compteur << " coups."<< std::endl;
				//On appelle la fonction gagne
				
				ouiNon = rejouer(ouiNon);
				fini = true;
			}
			else
			{
				std::cout << "Ce n'est pas le mot !" << std::endl << std::endl;
				//On ajoute +1 au compteur d'essais
				compteur++;
				//si le compteur arrive à 5 c'est perdu.
				if (compteur > 5)
				{
					std::cout << "Vous avez Perdu le Mot mystere est " << motMystere << std::endl << std::endl;
					
					//fin du jeu
					
					ouiNon = rejouer(ouiNon);
					fini = true;
				}

			}
		} while (fini == false);

J'ai utilisé cette méthode mais je ne comprends pas pourquoi lorsque j'utilise deux conditions je n'arrive pas à sortir de ma boucle.  

-
Edité par Jean-LouisGustine 30 octobre 2018 à 10:14:26

Découpe ton code. Tu verras mieux le pourquoi du comment.

Salut,

Les conditions dans les boucles, quelles qu'elles soient, indiquent ce qui doit être respecter pour RETOURNER dans la boucle.

Si tu veux QUITTER la boucle si mot == mot mystère OU si  compteur == 5, la condition pour RETOURNER dans la boucle devient quoi?

-
Edité par koala01 30 octobre 2018 à 10:18:04

Le do ->while(motUtilisateur != motMystere); il faut ajouter le compteur <= 5 dans la condition genre (motUtilisateur != motMystere) || (compteur <= 5) c'est mieux optimiser?? non ??

Ah oui, et arrêtez de parler d'optimisation quand il s'agit juste d'écrire un code de manière lisible. L'optimisation c'est pas ça.

Et, là, tu décides de rentrer dans la boucle si le motUtilisateur est différent de motMyster OU si compteur <= 5 ...

Or, les deux conditions doivent être remplies pour que l'on puisse rentrer dans la boucle: dés que l'une d'elle n'est plus remplie, il faut quitter la boucle!

Ksass`Peuk a écrit:

Ah oui, et arrêtez de parler d'optimisation quand il s'agit juste d'écrire un code de manière lisible. L'optimisation c'est pas ça.

Je dirais même que c'est souvent opposé x)

Faire la somme des éléments des éléments d'un tableau d'entier

comment je ferais :

#include <iostream>
#include <vector>
#include <numeric>

int main()
{
    std::vector<int> v(1,64);
    std::cout << std::accumulate(v.begin(), v.end(), 0) << std::endl;
    return 0;
}

C'est du standard, c'est lisible, c'est évolutif, c'est ce qu'on attend généralement d'un développeur

Maintenant on te dit que le tableau est paginé par 64 valeurs ( si j'ai bien compris ), et bien voici l'optimisation proposée par godbolt (le main est de moi donc sûrement pas optimisé)

#include <iostream>
#include <cstring>

// Compile with -O3 -march=native to see autovectorization
// assumes input is aligned on 64-byte boundary and that
// length is a multiple of 64.
int somme_totale(int* input, int length) {
  // Alignment hints supported on GCC 4.7+ and any compiler
  // supporting the appropriate builtin (clang 3.6+).
#ifndef __has_builtin
#define __has_builtin(x) 0
#endif
#if __GNUC__ > 4 \
    || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7) \
    || __has_builtin(__builtin_assume_aligned)
  input = static_cast<int*>(__builtin_assume_aligned(input, 64));
#endif
#if _MSC_VER
  __assume((length & 63) == 0);
#else
  if (length & 63) __builtin_unreachable();
#endif
  int sum = 0;
  for (int i = 0; i < length; ++i) {
    sum += input[i];
  }
  return sum;
}

int main()
{
    static const size_t TABSIZE = 64;
    int tab[TABSIZE];
    for(size_t i=0; i<TABSIZE; ++i)
        tab[i] = 1;
    std::cout << somme_totale(tab, TABSIZE) << std::endl;
    return 0;
}

Que c'est laid, et la syntaxe lourde xP et pourtant plus rapide, plus léger, plus optimisé, que ma version utilisant du standard

-
Edité par romantik 30 octobre 2018 à 14:57:35

romantik a écrit:

Que c'est laid, et la syntaxe lourde xP et pourtant plus rapide, plus léger, plus optimisé, que ma version utilisant du standard

C'est surtout buggé visiblement :

$ g++ -o machin machin.cpp -march=native -O3 -DNDEBUG
$ ./machin 
Erreur de segmentation (core dumped)

Mais sinon, non le code plus optimisé n'est pas nécessairement dégueux. Si on est organisé.

oh exact, je ne sais pas utiliser memset x)

Je remplace ça par une boucle for, je vais pas me casser la tête, c'est juste pour montrer le principe

Tiens juste pour te montrer qu'il y a pas de règle. Ton code optimisé par GCC, j'ai juste remplacé l'affichage par un return pour ne pas s'encombrer du code d'affichage qui est illisible.

	.file	"machin.cpp"
	.section	.text.unlikely,"ax",@progbits
.LCOLDB0:
	.text
.LHOTB0:
	.p2align 4,,15
	.globl	_Z12somme_totalePii
	.type	_Z12somme_totalePii, @function
_Z12somme_totalePii:
.LFB41:
	.cfi_startproc
	testl	%esi, %esi
	jle	.L4
	subl	$8, %esi
	xorl	%eax, %eax
	vpxor	%xmm0, %xmm0, %xmm0
	shrl	$3, %esi
	addl	$1, %esi
.L3:
	movq	%rax, %rdx
	addq	$1, %rax
	salq	$5, %rdx
	vpaddd	(%rdi,%rdx), %ymm0, %ymm0
	cmpl	%eax, %esi
	ja	.L3
	vpxor	%xmm2, %xmm2, %xmm2
	vperm2i128	$33, %ymm2, %ymm0, %ymm1
	vpaddd	%ymm0, %ymm1, %ymm1
	vperm2i128	$33, %ymm2, %ymm1, %ymm0
	vpalignr	$8, %ymm1, %ymm0, %ymm0
	vpaddd	%ymm0, %ymm1, %ymm0
	vperm2i128	$33, %ymm2, %ymm0, %ymm2
	vpalignr	$4, %ymm0, %ymm2, %ymm2
	vpaddd	%ymm2, %ymm0, %ymm0
	vmovd	%xmm0, %eax
	vzeroupper
	ret
	.p2align 4,,10
	.p2align 3
.L4:
	xorl	%eax, %eax
	ret
	.cfi_endproc
.LFE41:
	.size	_Z12somme_totalePii, .-_Z12somme_totalePii
	.section	.text.unlikely
.LCOLDE0:
	.text
.LHOTE0:
	.section	.text.unlikely
.LCOLDB5:
	.section	.text.startup,"ax",@progbits
.LHOTB5:
	.p2align 4,,15
	.globl	main
	.type	main, @function
main:
.LFB42:
	.cfi_startproc
	leaq	8(%rsp), %r10
	.cfi_def_cfa 10, 0
	andq	$-32, %rsp
	vpxor	%xmm1, %xmm1, %xmm1
	pushq	-8(%r10)
	pushq	%rbp
	.cfi_escape 0x10,0x6,0x2,0x76,0
	movq	%rsp, %rbp
	pushq	%r10
	.cfi_escape 0xf,0x3,0x76,0x78,0x6
	subq	$296, %rsp
	vmovdqa	.LC1(%rip), %ymm0
	movq	%fs:40, %rax
	movq	%rax, -24(%rbp)
	xorl	%eax, %eax
	vmovdqa	%ymm0, -304(%rbp)
	vmovdqa	%ymm0, -272(%rbp)
	vmovdqa	%ymm0, -240(%rbp)
	vmovdqa	%ymm0, -208(%rbp)
	vmovdqa	%ymm0, -176(%rbp)
	movq	-24(%rbp), %rdx
	xorq	%fs:40, %rdx
	vmovdqa	%ymm0, -144(%rbp)
	vmovdqa	%ymm0, -112(%rbp)
	vmovdqa	%ymm0, -80(%rbp)
	vpaddd	%ymm0, %ymm0, %ymm0
	vpaddd	%ymm0, %ymm0, %ymm0
	vpaddd	%ymm0, %ymm0, %ymm0
	vperm2i128	$33, %ymm1, %ymm0, %ymm2
	vpaddd	%ymm2, %ymm0, %ymm0
	vpalignr	$8, %ymm0, %ymm2, %ymm2
	vpaddd	%ymm2, %ymm0, %ymm0
	vperm2i128	$33, %ymm1, %ymm0, %ymm1
	vpalignr	$4, %ymm0, %ymm1, %ymm1
	vpaddd	%ymm1, %ymm0, %ymm0
	jne	.L11
	vmovd	%xmm0, %eax
	vzeroupper
	addq	$296, %rsp
	popq	%r10
	.cfi_remember_state
	.cfi_def_cfa 10, 0
	popq	%rbp
	leaq	-8(%r10), %rsp
	.cfi_def_cfa 7, 8
	ret
.L11:
	.cfi_restore_state
	vzeroupper
	call	__stack_chk_fail
	.cfi_endproc
.LFE42:
	.size	main, .-main
	.section	.text.unlikely
.LCOLDE5:
	.section	.text.startup
.LHOTE5:
	.section	.rodata.cst32,"aM",@progbits,32
	.align 32
.LC1:
	.long	1
	.long	1
	.long	1
	.long	1
	.long	1
	.long	1
	.long	1
	.long	1
	.ident	"GCC: (Ubuntu 5.4.0-6ubuntu1~16.04.10) 5.4.0 20160609"
	.section	.note.GNU-stack,"",@progbits

La même en utilisant std::accumulate :

	.file	"machin.cpp"
	.section	.text.unlikely,"ax",@progbits
.LCOLDB0:
	.section	.text.startup,"ax",@progbits
.LHOTB0:
	.p2align 4,,15
	.globl	main
	.type	main, @function
main:
.LFB41:
	.cfi_startproc
	movl	$64, %eax
	ret
	.cfi_endproc
.LFE41:
	.size	main, .-main
	.section	.text.unlikely
.LCOLDE0:
	.section	.text.startup
.LHOTE0:
	.ident	"GCC: (Ubuntu 5.4.0-6ubuntu1~16.04.10) 5.4.0 20160609"
	.section	.note.GNU-stack,"",@progbits

-
Edité par Ksass`Peuk 30 octobre 2018 à 15:10:16