Traitement sur les fichiers.txt en C++

**nizoux** · 30/01/2017, 12h39

Bonjour ,
Je souhaite avoir votre opinion sur une m�thode pratique afin d'extraire les dates respectives des fichiers.txt se trouvant dans un r�pertoire et stocker les dates dans un vector <string> sans qu'il y ait r�p�tition.
Exemple des noms de fichiers:
MSD.NONE.2016-01-02.1994.txt
MSD.NONE.2016-01-02.1993.txt
MSD.NONE.2016-01-02.1996.txt
MSD.NONE.2016-01-05.1994.txt
MSD.NONE.2016-01-04.1994.txt
MSD.NONE.2017-01-02.1994.txt
MSD.NONE.2017-01-25.1994.txt
MSD.NONE.2017-01-25.1994.txt
MSD.NONE.2017-01-05.1994.txt

Pour cet exemple le vector doit contenir comme string les dates :
2016-01-02 ; 2016-01-05 ; 2016-01-04 ; 2017-01-02 ; 2017-01-25 ; 2017-01-05

Comme vous avez pu le constater il n y a pas de r�p�tition.
Y-a t-il une m�thode pour faire simple concernant l�extraction des cha�nes
Merci pour votre aide , toute id�e serait la bienvenue

**ternel** · 30/01/2017, 12h45

Proc�de par ordre.

Comment ferais-tu pour extraire toutes les dates?

Une fois que tu sais le faire, il y a deux choix:
ne pas introduire de doublon pendant l'extraction, ou supprimer les doublons apr�s l'extraction compl�te.

Les deux peuvent avoir leurs int�r�ts, mais je pr�f�re la premi�re, quand j'ai le choix.

Ta premi�re question est bien d'obtenir la liste des fichiers du r�pertoire.
Pour cela, la meilleure solution est probablement de passer par Boost.Filesystem.

**nizoux** · 30/01/2017, 13h04

Merci pour ton intervention.
Tout d'abord je vais catch tous les noms du r�pertoire via une m�thode utilisant la bilbio Boost comme vous avez dit avant de les mettre dans le vector<string> on mettra une condition permettant de v�rifier si il y a un doublon , ensuite pour extraire uniquement la date a vrai dire je n'ai aucune id�e pour l'instant peut-�tre penser � d�composer la cha�ne ??

**Bysbobo** · 30/01/2017, 14h54

Vu que tous les noms que tu nous as donn� sont syntaxiquement identiques, tu peux simplement les r�cup�rer via un substr() du nom total

**ternel** · 30/01/2017, 15h42

Ta solution est assez bonne.

A toi de voir ce qui change ou non dans le nom de fichier, et ce qui doit �tre pris en compte pour le doublonnage.

Si seule la date change, et le chiffre suivant change, et seule la date t'int�resse, un substring bien vis� suffit.

Si tu es sous linux, une commande telle que ls | cut -d. -f3 | sort -u affiche la liste demand�e, et en rajoutant > liste_date.csv au bout, cette liste est �crite dans un fichier.
Tu n'as plus qu'a lire ligne � ligne ce fichier pour avoir ta r�ponse.

Pour Windows, la m�me chose doit pouvoir �tre faite en batch ou PowerShell, mais je ne connais pas assez ces langages.

**nizoux** · 30/01/2017, 16h55

Merci � tous pour votre contribution et � @ternel pour ses explications d�taill�es.

**koala01** · 01/02/2017, 09h25

Salut,

Juste une petite question idiote, mais... es tu oblig� de placer tes chaines de caract�res dans un �l�ment de type std::vector

Car, si tu veux �viter les doublons (et, accessoirement, avoir une recherche dichotomique), la meilleure collection � utiliser est sans doute std::set; quitte � tout remettre dans un std::vector une fois que tu as dress� la liste compl�te

Le tout, c'est qu'il faut voir quels sont tes imp�ratifs : vas tu passer ton temps � ajouter ou supprimer des dates (de prime abord, je dirais que non), � effectuer des recherches, ou � parcourir toutes ces dates "de la premi�re � la derni�re"

Si tu effectues essentiellement des recherches, la recherche en O(log(n)) de std::set pourra sans doute contrebalancer les cache-misses du � la non contigu�t� des donn�es.

Si tu passes ton temps � parcourir toutes ces dates de la premi�re � la derni�re, la contigu�t� des donn�es en m�moire semble pour le moins importante, et un std::vector sera sans doute essentiel pour �viter les cache-misses

Quoi qu'il en soit, il est aussi possible d'obtenir une recherche dichotomique sur un std::vector � condition qu'il est tri�, ce qui permet d'avoir le "meilleur des deux mondes"; � ceci pr�s que, selon le compilateur que tu vas utiliser, il se peut que le contenu de la chaine de caract�res (le char * sous-jacent) soit cr�� en ayant recours � l'allocation dynamique de la m�moire, si bien que les donn�es ne seront de toutes fa�ons pas r�ellement contigu�s en m�moire.

En plus, la comparaison de chaines de caract�res est -- classiquement -- tr�s mauvaise en termes de performances: vu le format de tes dates, tu es syst�matiquement parti pour avoir quinze comparaisons par date!!!

Or, il serait sans doute possible de n'avoir besoin que de quatre comparaisons avec la structure ad�quate, sans oublier qu'elle pourrait aussi garantir la contigu�t� des donn�es en m�moire.

Cette structure pourrait prendre la forme de

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
3
4
5
6
struct MaStructure{
int annee;
int mois;
int jour;
int id; // les quatre derniers chiffres
};

et il suffirait alors de coder l'op�rateur < sous la forme de

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
3
4
5
6
bool operator < (MaStructure const & a, MaStructure const & b){
    return a.annee < b.annee ||
              (a.annee == b.annee && a.mois <b.mois) ||
              (a.annee == b.annee && a.mois == b.mois && a.jour < b.jour) ||
              (a.annee == b.annee && a.mois == b.mois && a.jour == b.jour && a.id < b.id);
}

pour disposer de "tout ce qu'il faut" pour en garantir l'unicit�

**ternel** · 01/02/2017, 09h50

Notons qu'avec C++11, il y a plus simple pour l'op�rateur de comparaison:

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
3
bool operator < (MaStructure const & a, MaStructure const & b){
    return std::tie(a.annee, a.mois, a.jour, a.id) < std::tie(b.annee, b.mois, b.jour, b.id);
}

En effet, tie cr�e un tuple de r�f�rences, et les tuples sont comparables (si tous leurs �l�ments le sont), dans l'ordre des �l�ments.

**koala01** · 01/02/2017, 11h15

En effet... je ne pense pas assez souvent � tie

Ceci dit, au final, cela reviendra au m�me, car la logique de comparaison du tuple est la m�me que celle que j'ai d�crite

**ternel** · 01/02/2017, 11h21

C'est justement parce que ca revient au m�me que c'est int�ressant.

Par contre, question performance, ca m�riterait peut-�tre une petite investigation.

**Pyramidev** · 02/02/2017, 01h21

Je viens de faire une comparaison de codes assembleurs.

MaStructure.cpp :

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
 
struct MaStructure
{
	int annee;
	int mois;
	int jour;
	int id; // les quatre derniers chiffres
};
 
#ifdef EXPRESSION_BOOLEENNE_DEVELOPPEE
bool operator<(MaStructure const& a, MaStructure const& b)
{
	return a.annee < b.annee ||
		(a.annee == b.annee && a.mois < b.mois) ||
		(a.annee == b.annee && a.mois == b.mois && a.jour < b.jour) ||
		(a.annee == b.annee && a.mois == b.mois && a.jour == b.jour && a.id < b.id);
}
#endif
 
#ifdef EXPRESSION_BOOLEENNE_FACTORISEE
bool operator<(MaStructure const& a, MaStructure const& b)
{
	return
		a.annee < b.annee || (a.annee == b.annee && (
		a.mois  < b.mois  || (a.mois  == b.mois  && (
		a.jour  < b.jour  || (a.jour  == b.jour  && (
		a.id    < b.id
		))))));
}
#endif
 
#ifdef AVEC_TIE
#include <tuple>
bool operator<(MaStructure const& a, MaStructure const& b){
	return std::tie(a.annee, a.mois, a.jour, a.id) < std::tie(b.annee, b.mois, b.jour, b.id);
}
#endif
 
#ifdef TOUT_EN_UN_INT
#include <climits>
static_assert(sizeof(int)*CHAR_BIT >= 32);
bool operator<(MaStructure const& a, MaStructure const& b)
{
	// Inspiré de : https://www.developpez.net/forums/d1609952/c-cpp/cpp/declaration-operateurs-l-objet-courant/#post8789609
	return
		((((a.annee * 16 + a.mois) * 32) + a.jour) * 16 * 1024) + a.id
			<
		((((b.annee * 16 + b.mois) * 32) + b.jour) * 16 * 1024) + b.id;
}
#endif

Commandes ex�cut�es avec GCC 6.3.0 :

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
3
4
g++ -O3 -S MaStructure.cpp -DEXPRESSION_BOOLEENNE_DEVELOPPEE -o EXPRESSION_BOOLEENNE_DEVELOPPEE.s
g++ -O3 -S MaStructure.cpp -DEXPRESSION_BOOLEENNE_FACTORISEE -o EXPRESSION_BOOLEENNE_FACTORISEE.s
g++ -O3 -S MaStructure.cpp -DAVEC_TIE                        -o AVEC_TIE.s
g++ -O3 -S MaStructure.cpp -DTOUT_EN_UN_INT                  -o TOUT_EN_UN_INT.s

Les trois premiers fichiers g�n�r�s sont assez similaires.
Ils ont chacun 6 branchements conditionnels.
Au niveau de la taille, le 1er est un peu plus grand que le 2e qui est un peu plus grand que le 3e.

TOUT_EN_UN_INT.s, sans surprise, n'a aucun branchement conditionnel.
En taille, il est plus petit que les trois premiers fichiers.

Voici le contenu des fichiers :

EXPRESSION_BOOLEENNE_DEVELOPPEE.s :

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
	.file	"MaStructure.cpp"
	.text
	.p2align 4,,15
	.globl	_ZltRK11MaStructureS1_
	.def	_ZltRK11MaStructureS1_;	.scl	2;	.type	32;	.endef
	.seh_proc	_ZltRK11MaStructureS1_
_ZltRK11MaStructureS1_:
.LFB0:
	.seh_endprologue
	movl	$1, %eax
	movl	(%rdx), %r8d
	cmpl	%r8d, (%rcx)
	jl	.L1
	movl	$0, %eax
	je	.L12
.L1:
	ret
	.p2align 4,,10
.L12:
	movl	$1, %eax
	movl	4(%rdx), %r9d
	cmpl	%r9d, 4(%rcx)
	jl	.L1
	movl	$0, %eax
	jne	.L1
	movl	$1, %eax
	movl	8(%rdx), %r10d
	cmpl	%r10d, 8(%rcx)
	jl	.L13
	je	.L4
	xorl	%eax, %eax
	ret
	.p2align 4,,10
.L13:
	ret
	.p2align 4,,10
.L4:
	movl	12(%rdx), %eax
	cmpl	%eax, 12(%rcx)
	setl	%al
	ret
	.seh_endproc
	.ident	"GCC: (GNU) 6.3.0"

EXPRESSION_BOOLEENNE_FACTORISEE.s :

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
	.file	"MaStructure.cpp"
	.text
	.p2align 4,,15
	.globl	_ZltRK11MaStructureS1_
	.def	_ZltRK11MaStructureS1_;	.scl	2;	.type	32;	.endef
	.seh_proc	_ZltRK11MaStructureS1_
_ZltRK11MaStructureS1_:
.LFB0:
	.seh_endprologue
	movl	$1, %eax
	movl	(%rdx), %r8d
	cmpl	%r8d, (%rcx)
	jl	.L1
	movl	$0, %eax
	je	.L10
.L1:
	ret
	.p2align 4,,10
.L10:
	movl	$1, %eax
	movl	4(%rdx), %r9d
	cmpl	%r9d, 4(%rcx)
	jl	.L1
	movl	$0, %eax
	jne	.L1
	movl	$1, %eax
	movl	8(%rdx), %r10d
	cmpl	%r10d, 8(%rcx)
	jl	.L1
	movl	$0, %eax
	jne	.L1
	movl	12(%rdx), %eax
	cmpl	%eax, 12(%rcx)
	setl	%al
	ret
	.seh_endproc
	.ident	"GCC: (GNU) 6.3.0"

AVEC_TIE.s :

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
	.file	"MaStructure.cpp"
	.text
	.p2align 4,,15
	.globl	_ZltRK11MaStructureS1_
	.def	_ZltRK11MaStructureS1_;	.scl	2;	.type	32;	.endef
	.seh_proc	_ZltRK11MaStructureS1_
_ZltRK11MaStructureS1_:
.LFB1223:
	.seh_endprologue
	movl	$1, %eax
	movl	(%rdx), %r8d
	cmpl	%r8d, (%rcx)
	jl	.L1
	movl	$0, %eax
	jg	.L1
	movl	$1, %eax
	movl	4(%rdx), %r9d
	cmpl	%r9d, 4(%rcx)
	jl	.L1
	movl	$0, %eax
	jg	.L1
	movl	$1, %eax
	movl	8(%rdx), %r10d
	cmpl	%r10d, 8(%rcx)
	jl	.L1
	movl	$0, %eax
	jg	.L1
	movl	12(%rdx), %eax
	cmpl	%eax, 12(%rcx)
	setl	%al
.L1:
	ret
	.seh_endproc
	.ident	"GCC: (GNU) 6.3.0"

TOUT_EN_UN_INT.s :

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
	.file	"MaStructure.cpp"
	.text
	.p2align 4,,15
	.globl	_ZltRK11MaStructureS1_
	.def	_ZltRK11MaStructureS1_;	.scl	2;	.type	32;	.endef
	.seh_proc	_ZltRK11MaStructureS1_
_ZltRK11MaStructureS1_:
.LFB1:
	.seh_endprologue
	movl	(%rcx), %eax
	sall	$4, %eax
	addl	4(%rcx), %eax
	sall	$5, %eax
	addl	8(%rcx), %eax
	sall	$14, %eax
	addl	12(%rcx), %eax
	movl	%eax, %ecx
	movl	(%rdx), %eax
	sall	$4, %eax
	addl	4(%rdx), %eax
	sall	$5, %eax
	addl	8(%rdx), %eax
	sall	$14, %eax
	addl	12(%rdx), %eax
	cmpl	%eax, %ecx
	setl	%al
	ret
	.seh_endproc
	.ident	"GCC: (GNU) 6.3.0"

EDIT 2017-02-02-01h54 : Avec le code :

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
3
4
5
6
7
8
9
10
bool operator<(MaStructure const& a, MaStructure const& b)
{
	// Notez l'utilisation des <= à la place des ==.
	return
		a.annee < b.annee || (a.annee <= b.annee && (
		a.mois  < b.mois  || (a.mois  <= b.mois  && (
		a.jour  < b.jour  || (a.jour  <= b.jour  && (
		a.id    < b.id
		))))));
}

l'assembleur g�n�r� est identique � celui g�n�r� par la version qui utilise std::tie.

**koala01** · 02/02/2017, 03h16

Envoy� par Pyramidev

Je viens de faire une comparaison de codes assembleurs.

<snip>
l'assembleur g�n�r� est identique � celui g�n�r� par la version qui utilise std::tie.

Y a donc plus qu'� faire tourner un grand nombre de fois chacun de ces code sur un grand nombre de donn�es pour essayer d'en faire ressortir des statistiques de performances correctes

Car, l'un dans l'autre, neuf lignes d'assembleurs de plus ou de moins peuvent tr�s bien ne pas faire une �norme diff�rence, voire, meme, ne pas faire une diff�rence dans le sens que l'on croit, lorsqu'il s'agit d�tiquettes (L1, L10, L ...) et de sauts conditionnels ou non (jl, je, jne)

Et l'id�al serait -- bien sur -- de faire des tests avec des donn�es "presque tri�es", des donn�es "mod�r�ment m�lang�es" et des donn�es "tr�s m�lang�es"... Car, � mon sens, si des diff�rences visibles doivent apparaitre, c'est � ce niveau l� qu'on les verra

Traitement sur les fichiers.txt en C++

C++

Discussions similaires

Partager

Partager