Discussion :

[01Please]

Bonjour, pour mon stage je dois utiliser un document .txt où il y a des informations sur des produits (couleur, nom, prix, ...).

Il m'est demandé de charger les données (fichier .txt) vers le programme que je dois créer.

Il m'est conseillé d'utiliser une hashmap! Qu'est ce que cela signifie ?

De plus on m'a parlé d'une étape appelé parsing de chaque entrée ... Pouvez-vous m'expliquer quel est le rôle de cette étape?


Je dois créer également un histogramme des couleurs pour pouvoir les visualiser comme la discussion suivante :
http://www.developpez.net/forums/d11...rdre-couleurs/

Mais je ne vois pas du tout comme réussir à faire un histogramme en C++ ... Comment crée cet outil ?


Bonne journée.

[ternel]

une hashmap, c'est une std::unordered_map. Il s'agit d'une collection reliant des clés à des valeurs.

"parsing" c'est le nom anglais et général de l'opération consistant à convertir du texte en variables/objets.

un histogramme, c'est jamais qu'une map<valeur, quantité>. Ensuite, tu peux vouloir le dessiner, mais je ne pense pas.

[01Please]

Merci pour ta réponse rapide

Je ne pense pas vouloir le dessiner, sauf si visualiser l'histogramme veut dire le dessiner ...

[Bousk]

Salut,

comment tu visualises un histogramme sans l'afficher ?

[ternel]

Par un affichage console, peut-être?
En deux colonnes: valeurs | quantité

[01Please]

L'affichage s'effectuera par console grâce au logiciel Qt Creator.

[koala01]

Salut,

L'affichage s'effectuera par console grâce au logiciel Qt Creator.

Attention, il ne faut pas tout confondre...

QtCreator, c'est un EDI (Environnement de Développement Intégré), c'est à dire un outil qui regroupe, entre autres (et sans soucis d'être exhaustif), un éditeur de texte capable de pratiquer une coloration syntaxique de ton code et de te proposer le choix de certains termes en fonctions d'un groupe de lettres/ caractères déjà écrits (on appelle cela l'intellisens), un compilateur, un éditeur de liens, un débuggeur et quelques outils intéressant, le tout, configuré pour que tout fonctionne correctement "de concert".

A l'extrême limite, le fait que tu décide d'utiliser QtCreator n'aura aucun impact sur ton projet, autre que l'utilisation d'un fichier particulier à l'extension .pro qui permettra à QtCreator de générer ton exécutable.

Bien sur, ce n'est pas tout à fait vrai, parce que QtCreator est un EDI spécialement développé pour être utilisé avec le framework Qt, mais la question est alors surtout : souhaites tu créer une interface graphique pour l'utilisateur ou simplement provoquer l'affichage en mode console

Si tu veux utiliser une interface graphique, le choix "idéal" est sans doute, étant donné que tu as décidé d'utiliser QtCreator, de te tourner vers, justement, le framework Qt pour la création de cette interface.

Mais si tu souhaite simplement avoir un affichage console, tu pourrais très bien te contenter d'utiliser un éditeur de texte "plats" (donc, capable d'enregistrer des fichiers au format txt et de te laisser le choix de l'extension), proposant éventuellement une coloration syntaxique tel que NotePad++ (le simple notepad sous windows pourrait faire l'affaire, mais il est définitivement un peu trop "limité" en possiblités ) ou gedit et d'automatiser la compilation à l'aide de Makefile (voir, de tout autre système à ton gout comme Cmake ou les autotools sous linux) .

Commence donc par t'inquiéter des différents problèmes dans l'ordre de leur importance :

1. La première chose est d'arriver à lire les données du fichier
2. La deuxième est d'arriver à récupérer des données utilisables réellement utilisables par l'ordinateur (et de les placer dans la hashmap)
3. La troisième est de prouver que ces données sont utilisable, par exemple, en affichant en mode console les informations réellement pertinentes dont tu as besoin
4. La dernière étape sera de trouver le moyen de créer un historigramme correct et de décider si tu veux l'afficher directement ou si tu veux "simplement" l'enregistrer pour permettre à d'autres application (acrobat reader ? application d'affichage / de modification d'images ? autre chose ?) d'utiliser ce résultat

Le fait que tu travailleras avec QtCreator semble te prédestiner à la création d'une intrerface graphique pour ton application. Interface graphique qui présentera, tôt ou tard, les données sous différentes formes (dont la principale qui t'est demandée : un historigramme). Mais tu ne devrait avoir à t'inquiéter de ce "détail" que bien plus tard dans ton développement

[01Please]

Merci pour ce message, très clair
Effectivement, j'utilise Qt creator pour créer des interfaces graphiques (mais pour l'instant j'utilise emacs pour coder ,il m'est demandé d'utiliser cet éditeur). Donc maintenant, j'ai compris qu'il est possible d'afficher avec une console les données par console.

Je dois utiliser ifstream c'est ça ? Il y a t-il une meilleur solution ?
Pour arriver à lire les données, je dois passer par des trucs du genre getline() ou get()... est-ce exact ?

[koala01]

Je dois utiliser ifstream c'est ça ? Il y a t-il une meilleur solution ?

Ah, dés qu'il s'agit de lire un fichier, ifstream est effectivement ce qu'il faut utiliser vu que, comme le nom l'indique, il s'agit d'un Input File STREAM

Pour arriver à lire les données, je dois passer par des trucs du genre getline() ou get()... est-ce exact ?

std::getline, stream.get() ou encore l'opérateur >>... Tout dépend du niveau de confiance ou de résistance aux erreurs que tu peux accorder au fichier à lire

Tu trouveras d'ailleurs une foule d'informations sur la gestion des flux (dont une section dédiée à l'utilisation de la console et une autre dédiée expressément à l'utilisation des flux) dans la FAQ du site... n'hésite pas à t'en inspirer

Mais tu peux aussi te tourner vers des frameworks spécifiques pour certains besoins plus complexes comme :

• boost::tokenizer qui permet de séparer les différents termes significatifs ("tokens")
• boost::filesystem, si tu dois pouvoir gérer les chemins d'accès aux fichiers de manière portable
• boost::spirit pour le cas où tu dois générer des parsers ou des lexers plus complexes

Maintenant, les trois dernières bibliothèques proposées permettent d'éviter de tomber dans le NIHS (Not Implemented Here Syndrome ou syndrome du "pas implémenté ici")... Très utiles pour arriver facilement à un résultat robustes, mais souvent peu appréciées par les profs qui souhaitent souvent profiter de certains exercices pour vous faire apprendre quelque chose (ou prendre conscience de certains aspects du problème). Il t'appartient de voir où se situent les demandes principales de ton prof et ce qu'il "pourra" accepter avant de te tourner vers ces bibliothèques

[01Please]

Bonjour,

Merci encore pour ta réponse précédente

Mon fichier texte comporte des lignes du style :

produit1 : caractéristiques : vert, jaune et rouge.
produit2 : caractéristiques : bleu, argenté et noir.

Donc comme tu me la conseillais, la première étape est de réussir à lire les données.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
 
Produit::Produit(string s){
	//vérification que le fichier est valide
	ifstream input(s.c_str());
	if(input.good())    
		parseProduit(input);
	else
		throw runtime_error("file not good");
}
 
void Produit::parseProduit(ifstream& in){
  string s ="ListeProduit.txt";    // = nom du fichier 
		while(in.good()){   // tant que le fichier n'est pas vide
			s = '\0';
			getline(in,s,'\n');   //récupère la ligne jusqu'à \n
			parseProd(s);
		}
}

Puis seconde étape, réussir à récupérer les données :
Je voudrais tout simplement récupère produit1 puis enlever les caractères suivant :

: , caractéristiques et .

puis récupérer les différents caractéristiques dans un vector<string>, pour cela j'ai fait un parser :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
 
void Produit::parseProd(string s){
	 size_t z = s.find(':');
	 size_t t = 0;
	 string nam = s.substr(0, z-1); 
	 vector<string> caracteristiques;  
	 int i = z+2; 
	 while(i < s.length()){ 
		t = s.find(',', i);
		if( t >= s.length()){ 
 
 
			caracteristiques.push_back(s.substr(i,s.length()-1-i));
			break;
		}
		else{ 
			caracteristiques.push_back(s.substr(i, t-i));
			i = t+2;	
		}
	 }
 
	prod.insert(pair<string, vector<string> >(nam, caracteristiques)); 
}

Je n'ai pas encore réussi à gérer le

et

à supprimer.

Pour la troisième étape : prouver que les données sont utilisable : je ne sais pas comment tester ??

[bacelar]

Tout ça pour ne pas utiliser une simple expression régulière de type :

(.+) \: (.+) \: (.+)(?:,(.+))*(?: et (.+))?

Ça donne si ça respecte le pattern ET les différentes valeurs.

[01Please]

C'est vrai que les expressions régulières sont plus appropriés dans ce cas, mais il m'a été demandé de reprendre le code au dessus :/

[bacelar]

Alors utilise la fin de l'expression régulière pour ce qui te reste à faire :
(.+)(?:,(.+))*(?: et (.+))?

[01Please]

Ok je vais essayer. Puis après avoir modifier mon code, comment faire pour prouver que ces données sont utilisable? :/

[CosmoKnacki]

Alors utilise la fin de l'expression régulière pour ce qui te reste à faire :
(.+)(?:,(.+))*(?: et (.+))?

Cette expression ne peut pas fonctionner pour deux raisons:

La première est que les quantificateurs étant gourmands par défaut, (.+) prendra tous les caractères jusqu'à la fin de la chaîne et la partie (?:,(.+))*(?: et (.+))? n'aura jamais rien car elle est entièrement optionnelle. On pourrait l'éviter en jouant avec des négations de classe de caractères en écrivant par exemple ([^, ]+)(?:(?:, ([^, ]+))* et ([^.]+))? (dans la mesure où les couleurs sont sans nuances, en un seul mot, car avec ocre jaune, vert pomme et rouge carmin., ça ne marche plus.)

L'autre raison c'est qu'on ne peut pas répéter un groupe de capture sans écraser la capture précédente, par exemple avec rouge, vert, bleu, orange et jaune., le groupe de capture 2 contiendra successivement vert puis bleu puis orange mais à chaque répétition la valeur précédente est écrasée et le groupe ne contiendra au final que orange.

Quitte à utiliser une regex pour ça, il y a plus simple:

S'il y a toujours trois couleurs: ([^,]+), ([^ ]+) et ([^.]+) ou ([^,]+), ([^ ]+(?: [^ ]+)*?) et ([^.]+) pour prendre en charge les couleurs en plusieurs mots.

Si le nombre de couleurs est variable, on utilise std::regex_iterator avec cette pattern: [^,. ]{3,} (avec trois caractères minimum on zappe le "et") ou ([^., ][^.,]+?)(?:[,.]| et ).

Maintenant pour partir du code que tu as déjà produit, tu peux très bien continuer dans la même logique et tester la présence de la sous-chaîne ' et ' avec string::find sans avoir recours aux regex.

[01Please]

J'ai réussi à afficher le fichier texte sauf que l'affichage ne fonctionne pas comme je le voudrais; je n'ai pas utilisé les expressions régulières; je dois continuer avec le code qui m'a été transmit ...


Voici mon affichage :

--------------------------- affichage ----------------------------
il y a 31 produits

PRODUIT1
---- Caractéristiques : ------
vert.
PRODUIT2
---- Caractéristiques : ------
jaune

---- Caractéristiques : ------
actéristiques :jaune, violet , bleu et rouge.

---- Caractéristiques : ------
violet

---- Caractéristiques : ------
actéristiques :jaune, violet , bleu et rouge.

---- Caractéristiques : ------
bleu et rouge.
PRODUIT3
---- Caractéristiques : ------
céphalées
---- Caractéristiques : ------

...

Ce que je devrais avoir :

PRODUIT1*: caractéristiques : vert.
PRODUIT2*: caractéristiques : jaune, violet , bleu et rouge.
PRODUIT3 : caractéristiques : or et argent.
PRODUIT4 : caractéristiques : rose, blanc, noir et gris.

dans ce fichier texte; il y a 25 produits


mon code :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
 
 
void Produit::parsePro(string s)
 
{
	 size_t z = s.find(':');
	 size_t t = 0;
	 string nam = s.substr(0, z-1);
	 // nom du produit
 
	 size_t z2 = s.find(" caractéristiques :");
         vector<string> couleurs;  
	 int i = z2+19; 
 
	 while(i < s.length())
	   { 
	     t = s.find(',', i);
 
	     if( t >= s.length())
	       { 
 
		 couleurs.push_back(s.substr(i,s.length()-1-i));
		 break;
	       }
	     else
	       { // il y a plusieurs couleurs à traiter encore
		 couleurs.push_back(s.substr(i, t-i));
		 i = t+2;	
	       }
 
 
	     size_t et = s.find("et"); // copier dernier mot après le et
	     size_t point = s.find('.'); // chercher le . Le dernier charactère des lignes du fichiers txt
	     int posEt  = et+2;
	     int posPoint = point;
	     couleurs.push_back(s.substr(posEt, posPoint-1));
 
 
	   }
 
	 prod.insert(pair<string, vector<string> >(nam, couleurs)); //insertion de la paire représentant le produit dans la map
}