Trier un fichier

**clems_t** · 28/08/2013, 23h39

Bonjour à tous.

Je travail actuellement sur un dictionnaire de mot. L'écriture et la lecture de mon fichier ne me pose pas de problème.

J'essaie en vain de trier mon fichier mais celui n'ai pas trié ou alors partiellement ..

Pour ce qui est l'environnement et la compilation je travail sous linux et je compil avec gcc -Wall ect ...

Voici les fonctions que j'utilise pour le tri :

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
/**
*  Renvoie le nombre de ligne du fichier
**/
int nombre_lignes()
{
	FILE* monFichier = NULL;
	char motLu[LENGTH_MOT_MAX];
	int nbLignes = 0;
 
	monFichier = fopen("dictionnaires.txt", "r");
	if(monFichier == NULL)
	{
		return 0;
	}
 
	while(fgets(motLu, LENGTH_MOT_MAX, monFichier) != NULL)
	{
		nbLignes++;
	}
 
	fclose(monFichier);
 
	return nbLignes;
}
 
/**
*  Compare 2 chaînes de caractère
**/
int compareString(const void* str1, const void* str2)
{
	// renvoie 0 si chaîne identique
	// renvoie un nombre positif si les caractères de la chaîne 1 sont supérieur à ceux de la chaîne 2
	// renvoie un nombre négatif sinonn
 
 	return strcmp((char*)(str1), (char*)(str2) );
}
 
/**
* Tri du fichier par ordre croissant
**/
void tri_dico()
{
	FILE *monFichier = NULL;
	monFichier = fopen("dictionnaires.txt", "r");
	char motLu[LENGTH_MOT_MAX];
	char **tableauDeMot; // Tableau de tableau de char
	int nb_lignes = 0;
	int i, j = 0;
 
	if(monFichier == NULL)
		printf("Problème lors de la lecture du fichier");
	else
	{
		nb_lignes = nombre_lignes();
 
		// Allocation mémoire pour l'ensemble des nb_lignes du fichiers
		if(nb_lignes > 0)
			tableauDeMot = malloc(nb_lignes * sizeof(char *));
		if(tableauDeMot == NULL)
			printf("Erreur");
		else
		{
			// Allocation mémoire des i lignes du fichiers
			for(i=0;i<nb_lignes;i++)
			{
				tableauDeMot[i] = malloc(LENGTH_MOT_MAX * sizeof(char));
				if(tableauDeMot[i] == NULL)
					printf("Erreur");
			}
 
			// Copie des mots dans le tableau
			while(fgets(motLu, LENGTH_MOT_MAX, monFichier) != NULL)
			{
				strcpy(tableauDeMot[j], motLu);
				j++;
			}
 
			fclose(monFichier);
 
			qsort(tableauDeMot, nb_lignes, sizeof(*tableauDeMot), compareString);
 
			for(i=0;i<nb_lignes;i++)
				printf("%s", tableauDeMot[i]);	
		}
	}
	// On libère la mémoire
	for(i=0;i<nb_lignes;i++)
	{
		free(tableauDeMot[i]);
	}
 
	free(tableauDeMot);
}

En vous remerciant de votre aide.

**Bktero** · 29/08/2013, 07h11

Bonjour,

J'ai testé avec un fichier à 3 mots, le résultat est correct. As-tu un fichier de dictionnaire plus complet pour le test ? Tu peux mettre des pièces jointes ton message.

Ta façon de gérer le fichier n'est pas correct. Le nom est en dur à 2 endroits, tu l'ouvres et tu le fermes. Il devrait y avoir une fonction d'ouverture et ensuite tu promènes le descripteur de fichier de fonctions en fonctions (en le passant en paramètre). Pour le refermer, il y aurait une fonction de fermeture. Idéalement, tu devrais aussi simplifier ta fonction de tri. Il pourrait y avoir une fonction de chargement en mémoire, une fonction de tri, une fonction d'affichage, une fonction de réécriture du "nouveau" fichier, etc. Ici, le code reste assez court donc ça peut encore aller mais une fonction devrait avoir un seul rôle et garder une complexité faible.

**leMédaillon** · 29/08/2013, 07h15

Bonjour,

Voici quelques remarques qui n'ont rien à voir avec le contenu de ton code mais qui restent tout de même intéressantes. Tout d'abord, ton code est très bien indenté ; les félicitations du jury te sont donc accordées. Par contre, tu ne nous indiques pas quels headers tu utilise dans ta bibliothèque de fonctions. Comme quoi il faut qu'on aille chercher nous-même : c'est pas gentil han ça.

De plus ta fonction compareString, à ton avis, que fait-elle ? Évidemment elle compare des chaînes de caractères. Tu peux donc comprendre que l'entête de ta fonction n'est pas très correcte ; utilises directement des const char* : cela t'évitera de devoir faire des casts. De même, à mon humble avis, les entêtes de tes fonctions nombre_lignes et tri_dico ne sont pas très correctes. Figures-toi qu'une bibliothèque de fonctions est sensée être réutilisable alors penses à passer le nom du fichier (ici dictionnaire.txt) en paramètre à tes fonctions. Et d'ailleurs, imagines un peu que ton dictionnaire contienne plus de 700000 mots (oui le dernier dico. que m'a soumis un prof en contenait environ 800000, soit 800000 lignes). Dans ce cas, ton code sera-t-il toujours fonctionnel ? Ne buggera-t-il pas ? Je pense que oui et une meilleure solution consisterait à mapper d'abord le contenu du fichier en mémoire avant de le traiter. Mais c'est surtout une question d'esthétique ça ; et n'étant pas très sûr de ce que j'avance, je préfère laisser les autres vaillants internautes en débattre. Enfin, tu ne nous renseignes pas sur le rôle de ta variable LENGHT_MOT_MAX mais on a qu'en même pu deviner.

Voici donc un début de remarques. L'essentiel (concernant le contenu du code) viendra plus tard.

**Bktero** · 29/08/2013, 10h26

De plus ta fonction compareString, à ton avis, que fait-elle ? Évidemment elle compare des chaînes de caractères. Tu peux donc comprendre que l'entête de ta fonction n'est pas très correcte ; utilises directement des const char* : cela t'évitera de devoir faire des casts

Je me suis dit la même chose. Et j'ai vu qsort().

**clems_t** · 29/08/2013, 11h16

Merci de vos réponses.

Ce code étant pour m’entraîner je n'ai pas un grand dictionnaire, j'y ai mis juste quelques mots pour tester

Exemple :

ESSAIE
TESTS
ORDINATEUR
PROTOCOLE
FICHIERS

Qui après appel de ma fonction de tri s'affiche :

PROTOCOLE
FICHIERS
ESSAIE
TESTS
ORDINATEUR

Ensuite pour ce qui est de mes fonctions c'est vrai que j'avais pensé à passer mon fichier en paramètre et faire différents fonctions, dont une pour l'affichage, une pour le chargement mémoires, une pour le tri ect...

Mais étant en test je voulais le faire une fois que ma fonction de tri s'exécutais correctement.

Pour ce qui est de mes headers :

Code :

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

1
2
3
4
5
6
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<ctype.h>
 
#include "dico.h"

LENGHT_MOT_MAX étant défini dans "dico.h" et étant la longueur max d'un mot.

Je prends note des remarques et je vais commencer par créer une fonction d'ouverture et fermeture de fichiers.

Pour ce qui est de ma fonction d'ouverture il faut qu'en paramètre je lui envoie le fichier et le mode ?

**clems_t** · 29/08/2013, 11h41

Je me suis essayé à une fonction pour ouvrir et fermer un fichier, je suis sur la bonne route ou alors ce n'ai pas correct ce que j'ai codé ?

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
FILE *ouverture_fichier(const char* fic, char* mode)
{
	FILE *monFichier = NULL;
	monFichier = fopen(fic, mode);
 
	return monFichier;
}
 
void fermeture_fichier(FILE *fic)
{
	fclose(fic);
}

**Bysbobo** · 29/08/2013, 11h50

Vérifie que l'ouverture s'est bien déroulé et ça semble bien

Code :

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

1
2
3
4
5
6
7
8
if(monFichier == NULL)
{
   // ... à toi de rajouter ce que tu veux, par exemple
   printf("Raté, essaye encore! \n");
   // sans oublier le return
}
else
   return monFichier;

**leMédaillon** · 29/08/2013, 12h41

Envoyé par Bktero

Je me suis dit la même chose. Et j'ai vu qsort().

Il y a en effet qsort mais je parle ici de la fonction de compparaison qui, à mon humble avis, devrait ressembler à ce qui suit.

Code :

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

1
2
3
4
int
compareString(const char* str1, const char* str2) { // à mon avis, pas besoin de void*
    return strcmp(str1, str2) ;
}

Par ailleurs, ton code de tri ne fonctionne pas (désolé de te le balancer juste comme ça). J'ai essayé avec ceci :

ESSAIE
TESTS
ORDINATEUR
PROTOCOLE
FICHIERS

Le résultat est cela :

PROTOCOLE
TESTS
FICHIERS
ORDINATEUR
ESSAIE

Le bon tri devrait être ce qui suit non ?

TESTS
PROTOCOLE
ORDINATEUR
FICHIERS
ESSAIE

Et lorsqu'on ajoute des lettres minuscules ou autres caractères au fichier, alors là c'est la catastrophe.

Quant à mes remarques dans mon post précédent, voici ce à quoi je faisais allusion :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
int
nombre_lignes(const char *fname)
{
    FILE* monFichier = NULL ;
    char motLu[LENGTH_MOT_MAX] ;
    int nbLignes = 0 ;
 
    monFichier = fopen(fname, "r") ;
 
    [...]
}

Code :

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

1
2
3
4
5
6
7
8
9
void
tri_dico(const char *fname)
{
    FILE *monFichier = NULL;
    monFichier = fopen(fname, "r");
    char motLu[LENGTH_MOT_MAX];
 
    [...]
}

Je verrais ce que je peux ajouter d'autres plus tard.

**clems_t** · 29/08/2013, 13h02

Oui mon tri ne marche pas, je suis entrain d'apporter des modifications.

Pour ce qui est des minuscules j'ai déjà traité le problème je converti tout en majuscule avant de l'écrire dans le fichier.

Mes fonctions d'ouverture et fermeture sont elles d'une utilités ?

**Bktero** · 29/08/2013, 13h24

Il y a en effet qsort mais je parle ici de la fonction de compparaison qui, à mon humble avis, devrait ressembler à ce qui suit.

Connais-tu le prototype de qsort() ?

Si je rajoute un printf() dans la fonction de comparaison, ça m'affiche n'importe quoi. Ce que tu donnes à qsort() n'est pas ce qu'il faut ou à l'inverse, ce que te donne qsort() n'est pas ce à quoi tu t'attends.

Si tu veux une piste, Google puis premier résultat sur Stackoverflow.

EDIT : et même en lisant la page de manuel sur Developpez.com !

**leMédaillon** · 29/08/2013, 13h32

La fonction fermeture_fichier n'est pas en réalité très intéressante, vu qu'elle ne contient qu'une seule instruction. Cependant, par analogie à la fonction ouverture_fichier, on peut effectivement songer à mettre en place le code source d'une telle fonction. Revenons maintenant à la fonction fermeture_fichier. Un nom comme open_file aurait été moins long à mon avis ; mais ce n'est que mon point de vue après tout.

Venons-en maintenant à ton code.

Ton code est correct à la seule exception que toute personne qui utilisera ton code devra faire des tests de retour dans sa fonction principale (en l'occurence la fonction main). Ce que je dis peut être illustrer par :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
int
main(int argc, char **argv)
{
    [...]
 
    FILE* fdesc = ouverture_fichier("nomDuFichier", "r") ;
    if( fdesc == NULL ) {
        perror("fopen in ouverture_fichier") ;
        //fermeture_fichier(fdesc) ;
        return EXIT_FAILURE ;
    }
 
    [...]
}

On pourrait simplifier la tâche à l'utilisateur de ta bibliothèque, utilisateur qui pourrait ne pas être toi, en procédant comme suit :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
bool
ouverture_fichier(const char* fic, const char* mode)
{
    FILE *monFichier = fopen(fic, mode) ; // pas besoin d'initialiser d'abord à NULL
    if(monFichier == NULL) {
        perror("fopen in ouverture_fichier") ;
        fermeture_fichier(monFichier) ;
        return false ;
    }
    return true ;
}

On aura donc plus à ce casser la tête dans la fonction main. Et un simple test sur le retour de la fonction pourra nous faire prendre des décisions. De plus, pas besoin de surcharger ton programme avec le type bool : tu peux bien utiliser des int.

Enfin, ce que j'avance n'est pas universel et il y a sans doute maintes meilleures façons de faire mieux. Courage !

EDIT : @Bktero

Envoyé par Bktero

Connais-tu le prototype de qsort() ?

Je ne le connais pas par coeur mais le manuel vient de me renseigner. Cependant, je ne vois pas où se trouve le lien avec le code de la fonction compareString, sans vouloir jouer à l'idiot.

**Bktero** · 29/08/2013, 13h38

Envoyé par leMédaillon

Je ne le connais pas par coeur mais le manuel vient de me renseigner. Cependant, je ne vois pas où se trouve le lien avec le code de la fonction compareString, sans vouloir jouer à l'idiot.

Le pointeur sur fonction en dernier argument.

Envoyé par leMédaillon

On pourrait simplifier la tâche à l'utilisateur de ta bibliothèque, utilisateur qui pourrait ne pas être toi, en procédant comme suit :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
bool
ouverture_fichier(const char* fic, const char* mode)
{
    FILE *monFichier = fopen(fic, mode) ; // pas besoin d'initialiser d'abord à NULL
    if(monFichier == NULL) {
        perror("fopen in ouverture_fichier") ;
        fermeture_fichier(monFichier) ;
        return false ;
    }
    return true ;
}

Et le pointeur sur fichier pour manipuler le flux ? Pourquoi fermer un fichier qui n'a pas été ouvert ?

Envoyé par Bysbobo

Vérifie que l'ouverture s'est bien déroulé et ça semble bien

Code :

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

1
2
3
4
if(monFichier == NULL)
   printf("Raté, essaye encore! \n");
else
   return monFichier;

Et tu ne renvoies rien dans le if ?

En Java ou C++, j'aurais dit "lances une exception !", mais là, c'est pas possible...

**leMédaillon** · 29/08/2013, 13h50

Envoyé par Bktero

Le pointeur sur fonction en dernier argument.

Humm, tu aimes bien jouer aux devinettes toi han.

J'aurais toutefois mieux compris ; merci.

Code :

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

1
2
3
4
5
6
7
8
9
10
Ce que dit le manuel
 
#include <stdlib.h>
 
void qsort (
                     void *base,
                     size_t nmemb,
                     size_t size,
                     int (*compar)(const void *, const void *) /*le pointeur de fonction en question */
           ) ;

Cependant, à mon avis, cela n'affecte aucunement le prototype de la fonction compareString car de toute façon une fonction qui peut recevoir un void* peut recevoir un char* aussi non ? Sinon dites moi si je me trompe (ce n'est pas impossible).

**Bktero** · 29/08/2013, 13h52

Dire "une fonction qui accepte un paramètre void* accepte aussi un paramètre char*" est correct, c'est presque la définition du pointeur void*. Mais ce n'est absolument pas synonyme de "int (*compar)(const void *, const void *) est identique à int (*compar)(const char *, const char *)" !!!

Ce ne sont pas types compatibles. Essaye de changer le prototype de la fonction de comparaison et regarde ton compilateur dire "non !". En fait, tu confonds le fait qu'accepter un void* te permet de recevoir des char* (c'est vrai) avec void* et char* sont interchangeables (c'est faux !). qsort() ne peut pas accepter un pointeur sur une fonction qui prend des paramètres de type char* car il ne pourra pas lui passer des void* !

**leMédaillon** · 29/08/2013, 13h56

Humm I can see. En réalité, j'ignore la vraie raison pour laquelle c'est le cas. Je pourrais toujours essayer d'expliquer cela mais je ne dirais de toute façon rien d'absolument vrai. Et donc, ne voulant pas me lancer dans des dires qui pourraient être faux, aurais-tu l'amabilité de m'expliquer pourquoi la citation "int (*compar)(const void *, const void *) est identique à int (*compar)(const char *, const char *)" est fausse ?

EDIT : J'avais pas bien lu ton post. Je comprends maintenant pourquoi tu insistes. J'espère aussi que clems_t a, tout comme moi, retenu la leçon.

Merci et bonne après-midi !

**Bysbobo** · 29/08/2013, 14h54

Envoyé par Bktero

Et tu ne renvoies rien dans le if ?

En Java ou C++, j'aurais dit "lances une exception !", mais là, c'est pas possible...

Si bien sûr, il faut renvoyer quelques choses mais comme je ne sais pas ce qu'il compte faire en cas d'échec, j'aurais dû mettre des points de suspension ^^
=> J'ai edité pour éviter les soucis

**clems_t** · 29/08/2013, 16h11

Je ne sais pas quoi retourner en cas d'échec

Code :

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

1
2
3
4
5
6
7
8
9
10
FILE *open_file(const char* fic, char* mode)
{
	FILE * monFichier = NULL;
	monFichier = fopen(fic, mode);
 
	if(monFichier == NULL)
		return ? Que mettre ici ?
	else
		return monFichier;		
}

**leMédaillon** · 29/08/2013, 16h49

Dans les deux cas, on retourne le descripteur de flux. Il revient donc à l'utilisateur de ta bibliothèque (en l’occurrence toi) de faire les tests adéquats dans la fonction main. Ce n'est qu'une idée mais on peut sûrement faire mieux.

Code :

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

1
2
3
FILE *open_file(const char* fic, char* mode) {
    return fopen(fic, mode); // les tests adéquats sont faits dans la fonction main
}

EDIT : code édité pour qu'il soit plus court.

Bonne soirée !

**clems_t** · 29/08/2013, 18h06

J'ai retravaillé mon code en plusieurs fonctions, j'attends vos avis pour me dire ce qui vas ou ne vas pas

Code :

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

1
2
3
4
5
6
7
/**
*  Retourne un pointeur sur le fichier
**/
FILE *open_file(const char* fic, char* mode)
{
	return fopen(fic, mode);		
}

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
/**
*  Renvoie le nombre de ligne du fichier
**/
int nombre_lignes(FILE *fichier)
{
	int nb_lignes = 0;
	int c;
 
	do{
		c = fgetc(fichier);
		if (c == '\n')
	    		nb_lignes++;
	}while (c != EOF);
 
	rewind(fichier);
 
	return nb_lignes;
}

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
/**
*  Chargement du fichier en mémoire
**/
char** alloc_fichier_tab(FILE *fichier, int nb_lignes)
{
	char** pTableau_char; // Tableau de pointeur sur tableau de char
	int i;
 
	// Allocation mémoire du fichier
	if(nb_lignes > 0)
	{
		pTableau_char = malloc(nb_lignes * sizeof(char *));
		if(pTableau_char == NULL)
			puts("Echec");
		else
		{
			// Allocation mémoire des lignes du fichiers
			for(i=0;i<nb_lignes;i++)
			{
				pTableau_char[i] = malloc(LENGTH_MOT_MAX * sizeof(char));
				if(pTableau_char[i] == NULL)
					puts("Echec");
			}
		}
	}
 
	return pTableau_char;
}

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
/**
*  Copie du fichier en mémoire
**/
char** charger_fichier(char** pTableau, FILE* fichier)
{
 
	char buffer[LENGTH_MOT_MAX];
	int i = 0;
 
	for(i=0; fgets(buffer, LENGTH_MOT_MAX, fichier) != NULL; i++)
		strcpy(pTableau[i], buffer);
 
	// Retour au début du fichier
	rewind(fichier);
 
	return pTableau;
}

Code :

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

1
2
3
4
5
6
7
8
9
/**
*  On trie le fichier en mémoire
**/
char** fichier_trier(char** pTableau, FILE* fichier, int nb_lignes)
{
	qsort(pTableau, nb_lignes, sizeof(*pTableau), compareString);
 
	return pTableau;
}

Code :

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

1
2
3
4
5
6
7
8
9
/**
*  On affiche le fichier trié
**/
void afficher_tab(char** pTableau, int nb_lignes)
{
	int i = 0;
	for(i=0;i<nb_lignes;i++)
		printf("%s", pTableau[i]);
}

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
/**
* On libère la mémoire
**/
void free_fichier_tab(char** pTableau, int nb_lignes)
{
	int i = 0;
 
	for(i=0;i<nb_lignes;i++)
	{
		free(pTableau[i]);
	}
	free(pTableau);
}

Merci d'avoir pris le temps de me lire.

EDIT : Le tri n'a toujours pas l'air de fonctionner ...
Et en compilant avec valgrind j'ai 15 allocs pour 8 free ...

**clems_t** · 30/08/2013, 09h40

L'erreur viens de ma fonction compareString,

Code :

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

1
2
3
4
5
int compareString(const void* str1, const void* str2)
{
    char *a = *(char**)str1, *b = *(char**)str2;
    return strcmp(a,b);
}

Comme je tri un tableau de pointeur sur char et non un pointeur sur char ...

J'ai aussi édité mes fonctions en corrigeant quelques détails.

Mon problème est maintenant de bien libérer la mémoire.

Dans mon main je fais :

Code :

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

1
2
3
4
 
afficher_tab(fichier_trier(charger_fichier(alloc_fichier_tab(fichier, nb_lignes_fic),fichier), fichier, nb_lignes_fic), 					nb_lignes_fic);
// Libération de la mémoire
free_fichier_tab(alloc_fichier_tab(fichier, nb_lignes_fic), nb_lignes_fic);

Trier un fichier

C

Discussions similaires

Partager

Partager