Mettre un fichier texte dans un tableau en C

cs_snake57 Messages postés 204 Date d'inscription vendredi 19 novembre 2004 Statut Membre Dernière intervention 1 novembre 2011 - 1 nov. 2011 à 03:29
cs_patatalo Messages postés 1466 Date d'inscription vendredi 2 janvier 2004 Statut Modérateur Dernière intervention 14 février 2014 - 1 nov. 2011 à 19:55
Bonjour à tous, je me suis fais 3 petite fonction.

La première me permet de récupérer le nombre de ligne dans un fichier texte.
La seconde me renvoie un tableau qui contient dans sa dimension 0 le nombre de ligne du fichier texte et dans les dimensions suivantes le nombre de caractère de chaque ligne. Par ex si la dimension 3 vaut 18, cela signifie que la ligne 3 du fichier a 18 caractères.

Ces deux fonctions marchent parfaitement.

Je me suis alors fais une troisième fonction qui range dans un tableau le fichier texte.
C'est la que j'ai un soucis. J'ai ma compilation qui passe sans problème mais à l'exécution j'ai une erreur "segmentation fault". Je pense donc que je tape dans une zone mémoire non autorisée ou un truc du genre. Mais ça fait 3 jours que je cherche et j'arrive pas a mettre la main sur l'erreur que j'ai pu faire.

Je vous laisse ci-dessous mes 3 fonctions, J'ai mis plein de commentaires donc vous devriez vite comprendre le principe du truc.

Si quelqu'un à le temps d'essayer ma 3è fonction se serait cool. Parce que la je bloque vraiment la dessus.

merci

#include <stdio.h>
#include <stdlib.h>

#include "fichier.h"

//***********************************************************************************************************************************//
//Fonction permettant de calculer le nombre de ligne d'un fichier                                                                    //
//Elle prend comme paramètre le chemin d'acces vers ce fichier sous la forme d'une chaine de caractères                              //
//Elle renvoie un entier qui contient le nombre de ligne qu'il y'a dans le fichier                                                   //
//***********************************************************************************************************************************//
long nbrLigneFichier(char *chemin)
{
    FILE *fichier = NULL;               //fichier est un pointeur vers une structure de type FILE
    char caractereActuel = 'a';         //contient le caractère actuellement lu par la fonction
    long nbrLigne = 0;                  //contient le nombre de ligne du fichier
    
    fichier = fopen(chemin, "r");       //on ouvre le fichier
    if (fichier == NULL)                //si l'ouverture échoue
    {
        printf("Impossible d'ouvrir le fichier %s",chemin); //on affiche un message d'erreur
        exit(0);                        //on quitte le programme
    }
    while (caractereActuel != EOF)      //on continue tant que fgetc n'a pas retourné EOF (fin de fichier)
    {
        caractereActuel=fgetc(fichier); //lecture du fichier caractère par caractère
        if(caractereActuel=='\n')       //on compte le nombre de ligne (les caractères retour à la ligne)
        {
            nbrLigne++;                 //incrémentation du compteur de ligne
        }
    }
    fclose(fichier);                    //on referme le fichier
    return(nbrLigne);                   //la fonction renvoie le nombre de ligne qu'elle a comptée
}

//***********************************************************************************************************************************//
//Fonction permettant de calculer le nombre de caractère de chaque ligne d'un fichier                                                //
//Elle prend comme paramètre le chemin d'acces vers ce fichier sous la forme d'une chaine de caractères                              //
//Elle range le résultat dans un tableau d'int et renvoie le pointeur vers ce tableau                                                //
//La dimension 0 du tableau contient le nombre de ligne total du fichier                                                             //
//La dimension 1 à n contient le nombre de caractère contenu dans la ligne 1 à n
//***********************************************************************************************************************************//
//ATTENTION UN MALLOC EST FAIT DANS CETTE FONCTION, NE PAS OUBLIER DE FAIRE UN FREE APRRES UTILISATION                               //
//***********************************************************************************************************************************//
long* nbrCharParLigne(char *chemin)
{
    FILE *fichier = NULL;               //fichier est un pointeur vers une structure de type FILE
    char caractereActuel = 'a';         //contient le caractère actuellement lu par la fonction
    long nbrCharLigneActuelle = 0;      //contient le nombre de caractère de la ligne en cour de lecture
    long LigneActuelle = 1;             //contient la ligne actuellement en cour de traitement

    long *nbrChar = malloc(sizeof(*nbrChar) * (nbrLigneFichier(chemin) + 1)); //On alloue un tableau qui contient autant de ligne qu'il y'a de ligne dans le fichier
    if (nbrChar == NULL)                //si l'ouverture échoue
    {
        printf("Impossible d'allouer la mémoire"); //on affiche un message d'erreur
        exit(0);                        //on quitte le programme
    }

    fichier = fopen(chemin, "r");       //on ouvre le fichier
    if (fichier == NULL)                //si l'ouverture échoue
    {
        printf("Impossible d'ouvrir le fichier %s",chemin); //on affiche un message d'erreur
        free(nbrChar);                  //on libère la mémoire
        exit(0);                        //on quitte le programme
    }
    
    while (caractereActuel != EOF)      //on continue tant que fgetc n'a pas retourné EOF (fin de fichier)
    {
        caractereActuel=fgetc(fichier); //lecture du fichier caractère par caractère
        nbrCharLigneActuelle++;         //on compte le nombre de caratère dans la ligne
        if(caractereActuel == '\n')     //si on est à la fin d'une ligne (caractères retour à la ligne)
        {
            nbrChar[LigneActuelle]=nbrCharLigneActuelle; //range le nombre de caractère de la ligne dans le tableau
            nbrCharLigneActuelle = 0;   //remise à zéro du compteur, pour pouvoir compter la ligne suivante
            LigneActuelle++;            //incrémentation du compteur de ligne pour la fois d'après
        }
    }
    
    fclose(fichier);                    //on referme le fichier
    nbrChar[0] = LigneActuelle - 1;     //on écrit le nombre de ligne totale dans la dimension 0 du tableau
    return(nbrChar);                    //la fonction renvoie le pointeur du tableau
}

//***********************************************************************************************************************************//
//Fonction qui permet de ranger chaque ligne d'un fichier texte dans une ligne d'un tableau de char                                  //
//Elle prend comme paramètre le chemin d'acces vers ce fichier sous la forme d'une chaine de caractères                              //
//Elle ne renvoie un pointeur sur un tableau 2D de char                                                                              //
//***********************************************************************************************************************************//
//ATTENTION UN MALLOC EST FAIT DANS CETTE FONCTION, NE PAS OUBLIER DE FAIRE UN FREE APRRES UTILISATION   (MALLOC D'UN TABLEAU 2D)    //
//***********************************************************************************************************************************//
/*la suppression ce fait de cette facon
for(int i = 0, i < nblignes; ++i)
{
    free(tabChar[i]);
}
free(tabChar);*/
char** rangeFichierTabChar(char *chemin)
{
    FILE *fichier = NULL;                      //fichier est un pointeur vers une structure de type FILE
    long nbrLigne = 0;                         //contient le nombre de ligne du fichier
    char caractereActuel = 'a';                //contient le caractère actuellement lu par la fonction
    long ligneActuelle = 0;                    //contient la ligne actuellement en cour de traitement
    long nbrCharLigneActuelle = 0;             //contient le nombre de caractère de la ligne en cour de lecture
    char **tabChar = NULL;                     //pointeur de tableaux non initialisé
    long *nbrChar = NULL;                      //pointeur de tableaux non initialisé
    long i = 0;
    
    nbrChar = nbrCharParLigne(chemin);         //appelle de la fonction nbrCharParLigne qui va nous renvoyer un pointeur (voir ci-dessus)
    
    nbrLigne = nbrChar[0];                     //contient le nombre de ligne du fichier
    
    tabChar = malloc(sizeof(char) * nbrLigne); //allocation de la première dimensions du tableau de caractères (la colonne)
    if (tabChar == NULL)                       //si l'ouverture échoue
    {
        printf("Impossible d'allouer la mémoire"); //on affiche un message d'erreur
        exit(0);                                   //on quitte le programme
    }
    
    for(i = 0; i < nbrLigne; i++)        //allocation de la seconde dimensions (les lignes)
    {
        tabChar[i] = malloc(sizeof(char)*(nbrChar[i + 1] + 1)); //On ajoute un char supplémentaire pour pouvoir ajouter le caractère '\0' à la fin de chaque chaine
        if (tabChar[i] == NULL)                //si l'ouverture échoue
        {
            printf("Impossible d'allouer la mémoire"); //on affiche un message d'erreur
            exit(0);                           //on quitte le programme
        }
    }
    
    fichier = fopen(chemin, "r");              //on ouvre le fichier
    if (fichier == NULL)                       //si l'ouverture a  réussie
    {
        printf("Impossible d'ouvrir le fichier %s",chemin); //si l'ouverture échoue
        free(nbrChar);                         //ce pointeur à été initialisé par une fonction utilisant malloc, il faut donc libérer l'espace mémoire réservé
        exit(0);                               //on quitte le programme
    }
    
    for(i = 0; i < nbrLigne; i++)
    {
        if(fgets(tabChar[i], nbrChar[i + 1], fichier) == NULL)
        {
            printf("Erreur 1 dans la fonction rangeFichierTabChar"); //on affiche un message d'erreur
            exit(0);
        }
    }

    fclose(fichier);                           //on referme le fichier
    free(nbrChar);                             //ce pointeur à été initialisé par une fonction utilisant malloc, il faut donc libérer l'espace mémoire réservé
    return(tabChar);
}

1 réponse

cs_patatalo Messages postés 1466 Date d'inscription vendredi 2 janvier 2004 Statut Modérateur Dernière intervention 14 février 2014 1
1 nov. 2011 à 19:55
salut,


tabChar = malloc(sizeof(char) * nbrLigne);
->
tabChar = malloc(sizeof(char*) * nbrLigne);


@++
0