Creer une liste c++

**aminebakr** · 24/05/2017, 15h25

Bonjour,

Actuellement en stage, j'ai une partie de codage à faire en c++ et je m'y connais pas trop. La je dois extraire des caractères d'un tableau Excel et les stocker dans une liste.

Colonne 1 Colonne 2 Colonne 3 Colonne 4 Colonne 5 Colonne 6

Aluminium plate 2 8 "15808 REF 0" "78108 REF 0"
. . . . . .
. . . . . .
Je dois extraire la 2,3 et 4 eme colonne et pour la 5 eme et 6 eme juste la "REF 0" . J'ai converti mon fichier Excel en format csv et j'ai écrit un code qui me permet d extraire les caractères. Maintenant je dois stocker chaque caractères dans une liste. J'ai vu que je dois utiliser la fonction push.back mais je ne vois pas trop comment faire .

j'apprécierai grandement votre aide car le codage n'est pas ma spécialisation mais c'est une partie nécessaire pour pouvoir continuer mon stage, et pour l'instant je suis bloqué. Je vous remercie d'avance pour votre aide.

**ternel** · 24/05/2017, 15h44

Bonjour,

Regarde dans notre faq, à la question Comment lire ligne à ligne.
Pour traiter ta ligne, tu peux la mettre dans un istringstream et utiliser getline(stream, string, ';').

push_back (ou emplace_back), permettent d'ajouter un élément au bout du vector.

Si tu veux qu'on t'aide efficacement, fais-nous voir ton code (ou au moins sa partie significative).

**aminebakr** · 24/05/2017, 15h56

Salut ternel,
Merci pour ta réponse rapide, voila ce que j'ai codé.
J'ai déjà lu le tableau ligne par ligne et extrait les chaines dont j'ai besoin. La je dois les stocker dans une liste.

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
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
#include <iostream>
#include <fstream>
#include <string>
#include <sstream>
#include <vector>
#include <stdlib.h>
#include <math.h>
using namespace std;
int findNumCell(string line, string nameCell){   // cell0;cell1;...;nameCell;...;...
	int numCell=0, posCell = line.find(nameCell);
	if(posCell == -1){
		return -1;
	}
	line = line.substr(0,posCell + nameCell.size());  // cell0;cell1;...;nameCell
	for (size_t i=0; i<line.size(); i++){
		if(line[i]==';') {
			numCell += 1;
		}
	}
	return numCell;
}
 
string piquer(string line, int numColonne){
	int curs1=0, curs2=0, lp=line.size();
	string sep(";"); // Select the separator in fastener name
 
	for(int i=0; i< numColonne;i++){
        curs2=line.find(sep, curs1);
        curs1 = curs2 + sep.size();
		curs2 = curs1;
	}
 
 
    curs2=line.find(sep, curs1);
    string chaine="";
    if(curs2 != -1){
        chaine= line.substr(curs1,(curs2)-curs1);
    }
    else {
        chaine = line.substr(curs1);
    }
 
    return chaine;
}
 //retourne le numero de ligne de la chaine de caractere
int getNumLine(string word, string nomFichier){
	int numeroLigne = 1;
	int mot_trouvee = 0;
 
 
	ifstream fichier(nomFichier.c_str(), ios::in);  // on ouvre en lecture
 
        if(fichier)  // si l'ouverture a fonctionné
        {
        	string ligne;
	        while(getline(fichier, ligne))  // tant que l'on peut mettre la ligne dans "contenu"
	        {
	             mot_trouvee = findNumCell(ligne, word);
	   			if(mot_trouvee != -1){
	   				return numeroLigne;
	   			}
 
	   			numeroLigne++;
	        }
 
	        if(mot_trouvee == -1){
	        	return -1;
	        }
 
 
                fichier.close();
        }
        else{
        	 cerr << "Impossible d'ouvrir le fichier !" << endl;
        }
 
 
 
	return numeroLigne;
}
 
string getLineByNumLine(string chemin_acces_fichier,int num_line){
 
    int i = 0;
 
    ifstream fichier(chemin_acces_fichier.c_str());
 
    if( fichier )// ce test échoue si le fichier n'est pas ouvert
    {
        string ligne;
 
 
        while( i<num_line && getline( fichier, ligne ))
        {
            i++;
        }
        return ligne;
    }
    else{
        	 cerr << "Impossible d'ouvrir le fichier !" << endl;
        }
 
 
}
 
string findData(string line, int numCell){ // cell0;cell1;cell2;...;...
	int nSep=0, curs1=0, curs2=0;
	string data;
	if (numCell == 0){
		curs2 = line.find(";", curs1);
	}
	else {
		if (line[0] == ';') nSep +=1; // Content of celli+1 would be found
		while(nSep < numCell + 1){
			curs1 = curs2+1;
			curs2 = line.find(";", curs1);
			nSep +=1;
		}
	}
	data = line.substr(curs1, curs2-curs1); // Insert content of cell numCell in data
	return data;
}
string getContenuGuillemet(string line){
	int curs1=0, curs2=0 ;
	string sep("\"");
 
		curs1=line.find(sep, curs1);
		curs2=line.find(sep,curs1+1);
		//curs3=line.find(sep,curs1+2);
		//curs4=line.find(sep,curs1+3);
 
		line = line.substr(curs1+1,curs2-curs1-1);//,(curs3+1,curs4-curs3-1));
 
	return line;
}
string getContenuGuillemet2(string line){
	int curs1=0, curs2=0, curs3=0, curs4=0;
	string sep("\"");
 
		curs1=line.find(sep, curs1);
		curs2=line.find(sep,curs1+1);
		curs3=line.find(sep,curs2+1);
        curs4=line.find(sep,curs3+1);
 
 
		line = line.substr(curs1+1,curs2-curs1-1)+";"+line.substr(curs3+1,curs4-curs3-1);
 
 
	return line;
}
string getNomMaterial(string NomMaterial){
	int curs1=0, curs2=0;
	string sep(";");
 
		curs1=NomMaterial.find(sep, curs1);
		curs2=NomMaterial.find(sep,curs1+1);
		NomMaterial = NomMaterial.substr(curs1+1,curs2-curs1-1);
 
 
	return NomMaterial;
}
string getTickness(string Tickness){
	int curs1=0, curs2=0,curs3=0,curs4=0;
	string sep(";");
 
		curs1=Tickness.find(sep, curs1);
		curs2=Tickness.find(sep,curs1+1);
		curs3=Tickness.find(sep,curs2+1);
		curs4=Tickness.find(sep,curs3+1);
		Tickness =Tickness.substr(curs2+1,curs3-curs2-1)+";"+Tickness.substr(curs3+1,curs4-curs3-1);
 
	return Tickness;
}
string getRef(string Ref){
	int curs1=0, curs2=0, curs3=0, curs4=0;
	string sep(";");
 
		curs1=Ref.find(sep, curs1);
		curs2=Ref.find(sep,curs1+1);
		curs3=Ref.find(sep,curs2+1);
		curs4=Ref.find(sep,curs3+1);
		Ref = Ref.substr(curs1+1,curs2-curs1-1)+ ";"+Ref.substr(curs3+1,curs4-curs3-1);
 
 
	return Ref;
}
string virguleToPoint(string chaine){
    int trouvePoint = chaine.find(",",0);
        if( trouvePoint!= -1){
            chaine.replace(trouvePoint,1,".");
        }
    return chaine;
}
 
vector<string> getContenu(string line){
	vector<string> champs;
	int curs1=0, curs2=0, lp=line.size();
	string sep(";"); // Select the separator in fastener name
 
 
	while (curs2 != lp ){
		curs2=line.find(sep, curs1);
		string valeurActuelle;
        if(curs2 != -1){
                valeurActuelle = line.substr(curs1,(curs2)-curs1);
                valeurActuelle = virguleToPoint(valeurActuelle);
            string chaine= valeurActuelle;
            if(chaine == sep){
                return champs;
            }
 
            champs.push_back(valeurActuelle);
		curs1 = curs2 + sep.size();
		curs2 = curs1;
        }
        else {
                valeurActuelle = line.substr(curs1);
                valeurActuelle = virguleToPoint(valeurActuelle);
			champs.push_back(valeurActuelle);
			curs2=lp;
		}
 
	}
 
	return champs;
}
vector<string> getContenu2(string line){
	vector<string> champs;
	int curs1=0, curs2=0,curs3=0,crus4=0, lp=line.size();
	string sep(";"); // Select the separator in fastener name
 
 
	while (curs2 != lp ){
		curs2=line.find(sep, curs1);
		string valeurActuelle;
        if(curs2 != -1){
                valeurActuelle = line.substr(curs1,(curs2)-curs1);
                valeurActuelle = virguleToPoint(valeurActuelle);
            string chaine= valeurActuelle;
            if(chaine == sep){
                return champs;
            }
 
            champs.push_back(valeurActuelle);
		curs1 = curs2 + sep.size();
		curs2 = curs1;
        }
        else {
                valeurActuelle = line.substr(curs1);
                valeurActuelle = virguleToPoint(valeurActuelle);
			champs.push_back(valeurActuelle);
			curs2=lp;
		}
 
	}
 
	return champs;
}
 
 
 
 
vector<double> tranformStringToDouble(vector<string> vectorString){
    vector<double> vectorDouble;
 
    for(int i=0;i<vectorString.size();i++)
    {
        string valeurActuelle = vectorString[i];
 
        double terma = atof(vectorString[i].c_str());
 
        if(terma != 0.0){
            vectorDouble.push_back(terma);
        }
    }
 
    return vectorDouble;
}
//numero de colonne; inf si absent
int rechercheNumColValeurDouble(vector<double> vectorDouble, double valeurARecherche){
 
    for(int i = 0; i < vectorDouble.size(); i++){
 
        if(vectorDouble[i] == valeurARecherche){
            return i+1;
        }
    }
 
    for(int i = 0; i < vectorDouble.size(); i++){
 
        if(vectorDouble[i] >= valeurARecherche-0.1 && vectorDouble[i] <= valeurARecherche+0.1){
            return i+1;
        }
    }
       int i;
    if(vectorDouble[i] != valeurARecherche && vectorDouble[i] != valeurARecherche-0.1 && vectorDouble[i] != valeurARecherche+0.1){
        cout<<" warning : le diametre choisi n'exsiste pas"<<endl;
    }
 
 
}
 
//retourne indice qui correspong au numero de ligne
int rechercheNumLineThickness(vector<double> vectorDouble, double valeurARecherche){
    for(int i = 0; i < vectorDouble.size(); i++){
 
        if(vectorDouble[i] == valeurARecherche){
            return i;
        }
    }
 
    int i = 0;
    for(i=0; i < vectorDouble.size(); i++){
 
        if(vectorDouble[i+1] > valeurARecherche){
            return i;
        }
    }
 
    return i;
}
 
vector<double> thicknessDoubleVector(string nomFichier, int numLigneACommence){
    vector<double> retour;
    string motAExtraire;
    int i=1;
	ifstream fichier(nomFichier.c_str(), ios::in);  // on ouvre en lecture
 
        if(fichier)  // si l'ouverture a fonctionné
        {
        	string ligne;
	        while(getline(fichier, ligne) )  // tant que l'on peut mettre la ligne dans "contenu"
	        {
	            if(i>= numLigneACommence){
                        motAExtraire = piquer(ligne, 0);
                        string valeurAPush = virguleToPoint(motAExtraire);
 
                        retour.push_back(atof(valeurAPush.c_str()));
 
                }
 
 
 
            i++;
	        }
 
 
 
 
                fichier.close();
        }
        else{
        	 cerr << "Impossible d'ouvrir le fichier !" << endl;
        }
 
 
    return retour;
}
 
   string delet(string nom){
	// Remove eventual spaces in fastener name
	for (size_t n = 0; n < nom.size(); n++){
		if(nom[n] == '-' || nom[n] == '_'|| nom[n] == ' '){
			nom.erase(n,1);
		}
	}
	return nom;
}
bool CheckSubstring(string firstString, string secondString){
    if(secondString.size() > firstString.size())
        return false;
 
    for (int i = 0; i < firstString.size(); i++){
        int j = 0;
        if(firstString[i] == secondString[j]){
            while (firstString[i] == secondString[j] && j < secondString.size()){
                j++;
                i++;
            }
 
            if (j == secondString.size())
                    return true;
        }
    }
    return false;
}
 
 
int main(int argc, char* argv[])
{
    /*/string nom = argv[1];
    //cout << "bonjour " << nom << endl;
   // int numLineDiametre;
    //numLineDiametre=getNumLine("Diameter (mm)","C:/Users/to122333/Desktop/airbus/Table35.csv");
        //cout<<"numelinediametre :"<<numLineDiametre<<endl;
string line = getLineByNumLine("C:/Users/to122333/Desktop/airbus/Table35.csv", 2);
//cout<<line<<endl;
line=getContenuGuillemet(line);
cout<<line<<endl;
 
vector<string> params;// Affiche valeur  de la ligne
 
params=getContenu(line);
 
for(int i=0;i<params.size();i++)
{
    cout<<params[i]<<endl;
}
//numLineDiametre=getNumLine("Diameter (mm)","C:/Users/to122333/Desktop/airbus/table35.csv");
//cout<<numLineDiametre<<endl;
 //line = getLineByNumLine("C:/Users/to122333/Desktop/airbus/table35.csv", numLineDiametre);
//cout<<line<<endl;
 
vector<string> vectorDiametre = getContenu(line);
//cout << "contenu de la ligne diametre: " << endl;
for(int i=1;i<vectorDiametre.size();i++)
{
    //cout<<vectorDiametre[i] << " "<<endl;
}
 
//int numeroColonne = findNumCell(line, "4,78");
//cout << "numeroColonne de findNummCell pour 4,78: " << numeroColonne << endl;
 
//int numLine = getNumLine("2","C:/Users/to122333/Desktop/airbus/table35.csv");
//string lineEpaisseur = getLineByNumLine("C:/Users/to122333/Desktop/airbus/table35.csv",numLine);
 
//cout << lineEpaisseur << endl;
 
//string resultat = piquer(lineEpaisseur, numeroColonne);
//cout << "resultat piqué : " << resultat << endl;
 
int ThicknessNumLine = getNumLine("Thickness", "C:/Users/to122333/Desktop/airbus/Table35.csv");
//cout << "numLigne Thickness : " << ThicknessNumLine << endl;
 
/*vector<double> doubleParam = tranformStringToDouble(getContenu(getLineByNumLine("C:/Users/to122333/Desktop/airbus/table35.csv", ThicknessNumLine+1)));
cout << "double transforme : " << endl;
 
for(int i=0;i<doubleParam.size();i++)
{
    cout<<doubleParam[i]<<endl;
}
 
int numCol = rechercheNumColValeurDouble(tranformStringToDouble(vectorDiametre), 4.78);
//cout << "numero Colonne diametre choisi : " << numCol << endl;
 
//cout << "numero ligne Thickness :  "<< ThicknessNumLine << endl;
vector<double> valeursThickness = thicknessDoubleVector("C:/Users/to122333/Desktop/airbus/Table35.csv", ThicknessNumLine+1);
//cout << "affichage valeursThickness : " << endl;
for(int i=0;i<valeursThickness.size();i++)
{
    //cout<<valeursThickness[i]<<endl;
}
 
int numeroLigneValeurThicknessRecherche = rechercheNumLineThickness(valeursThickness, 1.2) + ThicknessNumLine+1;
//cout << "numero ligne Thickness choisi : " << numeroLigneValeurThicknessRecherche<< endl;
 
 
string ligneDeTickness=getLineByNumLine("C:/Users/to122333/Desktop/airbus/Table35.csv",numeroLigneValeurThicknessRecherche );
string valeurExtraite= piquer(ligneDeTickness,numCol);
 
 
cout << "valeurExtraite : " << valeurExtraite << endl;*/
cout<<"********************************************************************************************"<<endl;
int numLineAlu=getNumLine("Aluminium 2000 Series","C:/Users/to122333/Desktop/airbus/Material.csv");
  //      cout<<"numLineAlu :"<<numLineAlu<<endl;
 
  string ligneAlu = getLineByNumLine("C:/Users/to122333/Desktop/airbus/Material.csv", 24);
cout<<"Ligne entriere:"<<endl<<ligneAlu<<endl<<endl<<endl;
 
 
 
ligneAlu=getNomMaterial(ligneAlu);
cout<<"Nom du materiau:"<<endl<<ligneAlu<<endl<<endl<<endl;
 
string newNom=delet(ligneAlu);
cout<<"nom a comparer:"<<newNom<<endl<<endl<<endl;
 cout << "Enter first string:";
string firstString;
getline(cin, firstString);
if(CheckSubstring(firstString, newNom))
        cout << "Il appartient a la chaine"<<endl;
    else
        cout << "Il n'appartient pas a la chaine"<<endl<<endl<<endl;
 
string Tickness= getTickness(getLineByNumLine("C:/Users/to122333/Desktop/airbus/Material.csv", numLineAlu));
cout<<"l'epaisseur est comprise entre :"<<Tickness<<endl<<endl<<endl;
 
string contenuEntreGuillemet=getContenuGuillemet2(getLineByNumLine("C:/Users/to122333/Desktop/airbus/Material.csv", numLineAlu));// contenu entre guillemet
cout<<" contenu entre guillemet:"<<endl<<contenuEntreGuillemet<<endl<<endl<<endl;
 
 
string Ref=getRef(contenuEntreGuillemet);
cout<<"La REF :"<<endl<<Ref<<endl;
 
 
 
vector<string> paramse;// Affiche valeur  de la ligne
 
paramse=getContenu(Ref);
 
for(int i=0;i<paramse.size();i++)
{
    cout<<paramse[i]<<endl;
}
}

**koala01** · 02/06/2017, 15h33

Salut,

Houla la... y a de la place pour le progres dans ton code! Je vais donc commencer par quelques remarques d'ordre générale :

1- using namespace std; est une directive qui a été introduite au tout début (ou presque) de la normalisation du C++, dans l'unique but de permettre au code qui compilait avant l'introduction de la notion d'espace de noms (et le passage de tout ce qui était fourni par la bibliothèque standard dans l'espace de noms std) de continuer à compiler avec "un minimum de modification" suite à cette introduction, tout en reproduisant le problèmes qui ont justifié la mise en place de cette notion, vu qu'elle contourne leur but réel.

A l'heure actuelle, la bibliothèque standard est dans l'espace de noms std depuis plus de vingt ans maintenant. Du code récent ne devrait donc plus jamais contenir cette directive. Tu devrais préférer l'utilisation des noms "pleinement qualifiés" (comme std::cout, std::cin ou std::cin).

2- La classe std::string est, typiquement, une classe dont la copie nécessite beaucoup de mémoire et de temps. L'idéal (comme, pour faire simple, tout ce qui est plus complexe qu'un type primitif) est donc d'en éviter la copie à chaque fois qu'elle n'est pas indispensable; ce qui est le cas de tes fonctions prenant une (ou plusieurs) std::string comme paramètre.

Le meilleur moyen pour en éviter la copie d'un paramètre est de le transmettre sous forme de référence (éventuellement constante, s'il s'avère que la fonction appelée n'a aucune raison de modifier la valeur de l'élément en question).

3- Tout ce qui a trait à une position quelconque, à un numéro de ligne, à un nombre de "quelque chose" etc. ne sera jamais négatif (on ne peut pas avoir "moins cinq pommes" dans notre panier

).

L'idéal est donc d'utiliser spécifiquement une valeur entière non signée pour représenter ces valeurs qui ne peuvent en aucun cas être négative.

En outre, la norme définit explictement un alias de type nommé size_t comme étant sur le type entier non signé permettant de représenter "n'importe quelle taille représentable sur un système donné". Chaque fois que tu as besoin d'un taille ou un nombre de "quelque chose", tu devrais veiller à utiliser cet alias de type.

4- L'accès à des informations se trouvant sur le disque dur compte très clairement parmi les accès les plus lents que l'on puisse trouver sur un ordinateur (à l'exception peut-être des accès effectués sur un réseau).

Si bien que l'on préférera tout faire pour les éviter autant que possible. L'une des solutions les plus fréquentes (et les plus efficaces) est, très certainement de charger l'ensemble du fichier sous la forme qui "nous convient le mieux" dans un tableau de données et de manipuler ce tableau en lieu et place du fichier d'origine.

5- Contre toute attente, le premier destinataire du code que tu écris n'est pas un compilateur idiot qui ne sait que suivre les règles qu'on lui a indiqué, mais un humain "relativement intelligent" avec toutes ses habitudes. Il est donc primordial de veiller à ce que le code que tu écris puisse être compris le plus facilement possible par cet humain (qui pourrait très bien être toi-même, dans un délais "suffisamment long" pour que tu aies eu tout le temps d'oublier ce que tu voulais faire).

L'idéal est donc de veiller à respecter quelques règles simples :

une instruction == une ligne : si tu as besoin de trois variables de type identique, chaque définition de variable est à considérer comme une instruction à part entière, et il faut donc utiliser trois lignes différentes (une pour chaque variable)
on crée les variables le plus près possible de l'endroit du code où elles sont utilisées, de manière à en limiter au maximum leur durée de vie
Nommer, c'est créer disait l'autre. Le nom que tu donne à "quelque chose" indique au lecteur l'usage qu'il est sensé pouvoir en faire. Le compilateur se fout pas mal des noms et de leur longueur, mais le lecteur humain les utilisera pour se faire une idée de la logique qui est suivie. Il faut donc veiller à choisir le bon nom pour chaque fonction/type/variable que tu crées, de manière à ce que le lecteur puisse déterminer le plus facilement possible son utilité
On choisi la langue du code, et on s'y tient : Oui, je parle bien de la langue et non du langage! : on choisi la langue dans laquelle nous irons choisir les différents noms que nous utiliserons. Laquelle OSEF, du moment que l'on s'y tient : Tu veux le francais, l'anglais ou le chinoix cela me va très bien (même si mon mandarain est déplorable ). Mais par pitié, ne commence pas à les mélanger

Ceci étant dit, pour ce qui concerne ton code en lui-même:
La fonction findNumCell :
Déjà, le code de cette fonction est beaucoup trop compliqué par rapport à ce qui peut être fait. Observe le code qui vient et admire!

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
#include <string>
#include <algorithm>
#include <iostream>
#include <limits>
size_t findNumCell(std::string const & line, std::string const & nameCell){   // cell0;cell1;...;nameCell;...;...
    auto found = line.find(nameCell);
    if(found==std::string::npos)
		return -1; // typiquement 0xFFFFFFFF, soit std::numeric_limits<size_>::max();
	auto sub = line.substr(0,found);
	return std::count(sub.begin(),sub.end(),';');
}
int main(){
	std::string str{"salut;la;compagnie;3;5;3.14569"};
	std::cout<<findNumCell(str ,"3");
 
}

Avoue que c'est non seulement plus compact, mais aussi plus facile à comprendre, non ?

Mais, en plus : as tu conscience du fait que, en théorie, ce n'est pas le nom de la colonne que tu trouveras dans les différentes lignes, mais valeur associée au nom des différentes colonnes? Si tu ne peux pas garantir qu'il y ait effectivement une ligne en sachant laquelle!!!) qui contiendra le nom de chaque colonne, cette fonction ne servira à rien!

La fonction piquer : j'ai du mal à en comprendre la logique. Je ne comprend donc pas ce que tu veux faire, et je ne peux donc pas vérifier si c'est ce qu'elle fait effectivement.

La fonction getNumLine prend deux responsabilités :

lire le contenu de ton fichier et
vérifier, pour chaque ligne lue, si elle correspond à une ligne donnée.

En vertu du SRP, cela nous fait une responsabilité de trop, sans compter le problème lié aux accès disques que j'ai exposé plus tôt.

Sépare la lecture du fichier (qui provoquera l'ajout de chaque ligne du fichier dans un "tableau de lignes") de la recherche d'une ligne donné (qui pourra alors s'effectuer dans le "tableau de lignes"), et tu ne t'en portera que mieux, tant du point de vue du code (qui sera beaucoup plus simple), que du fait des performances

Creer une liste c++

C++

Discussions similaires

Partager

Partager