IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

Réseau C Discussion :

Lire un mot dans un fichier [Débutant(e)]


Sujet :

Réseau C

  1. #1
    Futur Membre du Club
    Profil pro
    Étudiant
    Inscrit en
    Janvier 2007
    Messages
    17
    Détails du profil
    Informations personnelles :
    Localisation : France, Nord (Nord Pas de Calais)

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : Janvier 2007
    Messages : 17
    Points : 6
    Points
    6
    Par défaut Lire un mot dans un fichier
    Bonjour à tous

    Voila j'aurais besoin d'un coup de main pour un petit programme surrement enfantin pour vous:

    Dans mon programme principal :
    - j'ouvre un fichier en lecture
    - je fait appel à une procédure qui doit lire le premier mot du fichier et le mettre dans une chaine de caractère

    Voilà ce que j'ai fait :
    ------------------------------------------------------------
    Dans mon programme principal :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
     
    int main(int argc, char **argv){
     
    FILE * fichier;
    char * p;
    p = (char*) calloc(50,sizeof(char));
     
    fichier = fopen(argv[1], "r");                                         //ouverture du fichier
    liremot(&fichier,&p);                                                   //lecture du premier mot
    printf("Le premier mot du fichier est : %s\n",p);            //affichage du premier mot
    ----------------------------------------------------------------------------------------------
    Ma procédure (dans un autre fichier .c)

    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
     
    void liremot(FILE **f, char **p){
     
    char c;
    char * q = (*p);
     
    while ((c = fgetc(*f)) == ' ') {}               //permet d'ignorer les espaces avant le mot
     
    *q = c;
     
    while ((c = fgetc(*f)) != ' ') {                        //on lit les caractères suivant jusqu'à ce
                                                                   //qu'on trouve un autre espace
    q++;
    *q=c;
    }
    -------------------------------------------------------

    Ca compile sans erreur, aucune erreur non plus avec valgrind.

    Dans mon fichier test.sl j'ai écrit : "PRINT LET "

    J'ai quelques questions à propos de ce truc, car en fait j'ai réussi à le faire fonctionner un peu en y allant au pif.....

    1 / Est ce que je peut faire des simplifications ? (par exemple ne pas utiliser le pointeur q ou la variable c dans la procédure)

    2/ Comment initialiser ma chaine de caratères p au début de la procédure : car si je lit le premier mot puis le second, pour le second au lieu d'obtenir LET j'obtient LETNT (la fin de PRINT est toujours la). En effet elle est seulement initialisée au début du programme avec la fonction calloc (et je doute que faire un free et un autre calloc a chaque fois soit une solution....)

    3/ Comment je doit modifier cette ligne pour qu'il s'arrête également à un retour à la ligne, à une tabulation ou à la fin du fichier...?
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
     
    while ((c = fgetc(*f)) != ' ')
    (ne suffit pas car si par exempe c'est le dernier mot du fichier il ne trouve pas d espace et j 'ai un segmentation fault...)

    J'ai essayé :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    while ((c = fgetc(*f)) != (' ' || '\n' || '\t' || EOF))
    mais ca ne fonctionne pas


    Voilà c'est tout pour le moment mais c'est le début d'un projet qui consiste à créer un interpreteur de "simple langage" donc je pense que j'aurais encore besoin de votre aide lol...

  2. #2
    Membre éclairé Avatar de crocodilex
    Profil pro
    Inscrit en
    Mars 2006
    Messages
    697
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Mars 2006
    Messages : 697
    Points : 858
    Points
    858
    Par défaut

    Penser aussi à l'indentation du code...
    Software Failure. Press left mouse button to continue.
    Guru Meditation #0100000C.000FE800

  3. #3
    Futur Membre du Club
    Profil pro
    Étudiant
    Inscrit en
    Janvier 2007
    Messages
    17
    Détails du profil
    Informations personnelles :
    Localisation : France, Nord (Nord Pas de Calais)

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : Janvier 2007
    Messages : 17
    Points : 6
    Points
    6
    Par défaut
    Ok pour la balise c'est vrai que c'est plus lisible.

  4. #4
    Expert confirmé
    Avatar de Thierry Chappuis
    Homme Profil pro
    Enseignant Chercheur
    Inscrit en
    Mai 2005
    Messages
    3 499
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 46
    Localisation : Suisse

    Informations professionnelles :
    Activité : Enseignant Chercheur
    Secteur : Industrie Pharmaceutique

    Informations forums :
    Inscription : Mai 2005
    Messages : 3 499
    Points : 5 508
    Points
    5 508
    Par défaut
    Salut,

    Dans main(), tu fait deux erreurs graves: tu ne testes pas la valeur de retour de calloc, ni celle de fopen. Comme pour malloc, il n'est pas conseillé de caster la valeur de retour de calloc. Ainsi, on peut écrire:
    p = calloc(50, sizeof *p);

    En ce qui concerne, liremot, je ne comprend pas pourquoi tu utilises l'interface suivante:
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    void liremot(FILE **f, char **p)
    Je te conseille d'utiliser le prototype suivant pour définir ta fonction. Le commentaire Doxygen correspond à la spécification de la fonction que je
    d'écrire en améliorant ton code. Dis-moi si elle t'intéresse (?):
    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
     
    /**
     * Lit un mot dans le fichier.
     *
     * @param file Pointeur sur le fichier ouvert par fopen()
     * @param p_buff Pointeur sur le 1er élément d'un tableau de caractères
     *               servant de tampon
     * @param buff_size Taille du tampon
     *
     * @return Code d'erreur: 0 si OK, >0 si une erreur de lecture est intervenue
     *                        (mot coupé car buff_size insuffisant), et EOF si
     *                        si EOF est rencontré, ou si file ou p_buff vaut NULL.
     */
    int lire_mot(FILE *file, char *p_buff, size_t buff_size)
    {
        /* ... */
     
    }
    En attendant, n'oublie pas que fgetc() retourne un int et non un char. Asnis, on doit avoir:
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
     
    int c;
    c = fgetc(fp); /* où fp est de type pointeur sur FILE et ouvert avec fopen()*/
    Si tu définis c comme un char, il ne pourra pas recevoir la valeur de fin de fichier EOF.

    Thierry
    "The most important thing in the kitchen is the waste paper basket and it needs to be centrally located.", Donald Knuth
    "If the only tool you have is a hammer, every problem looks like a nail.", probably Abraham Maslow

    FAQ-Python FAQ-C FAQ-C++

    +

  5. #5
    Futur Membre du Club
    Profil pro
    Étudiant
    Inscrit en
    Janvier 2007
    Messages
    17
    Détails du profil
    Informations personnelles :
    Localisation : France, Nord (Nord Pas de Calais)

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : Janvier 2007
    Messages : 17
    Points : 6
    Points
    6
    Par défaut
    Merci pour tes explications.

    Pour tester le retour le fopen je fait un "if fichier != NULL etc..." c'est ca ?
    Par contre pour tester le calloc je vois pas ...?

    Concernant la fonction liremot je lui envoi en paramètre le fichier que j'ai ouvert (sauf que le double pointeur doit etre de trop) ainsi que l'adresse du pointeur de chaine de caractère (comme le pointeur va etre modifié je lui envoi l'adresse...enfin c'est ce qu'on m'a apris)

    Sinon pour la fonction je veux bien oui, sauf que je comprend pas trop le "size_t buff-size...."

    En fait mon programme (un interpreteur), doit lire un fichier dans lequel se trouve des instructions écrites en "simple langage"
    (instructions élémentaires : BEGIN, END, PRINT, LET, GET, FOR...ROF, IF...FI)
    Donc la première étape est de lire un mot dans le fichier pour détecter ces mots clé.
    Je déclare donc un pointeur de chaine dans le programme principale et j'utilise ma fonction liremot pour lire un mot dans le fichier...ensuite je compare le contenu de la chaine pointée par p avec les différents mot clé pour lancer une procedure correspondante. Enfin je sais pas si je me fait bien comprendre lol.

    Le fait est que je declare un pointeur p de taille 50*sizeof(char) pour etre sur de pouvoir stocker tous les mots car je vois pas du tout comment redimensionner mon pointeur en fonction du mot à lire...d'autant plus que je le declare dans mon programme principale et qu'il faut le modifier dans une procedure...

    Bref je debute je m'embrouille un peu avec tout ca ^_^ Mais je veux bien voir ta fonction ca me donnera une idée de ce qu'on peut faire de bien

  6. #6
    Membre à l'essai
    Profil pro
    Inscrit en
    Février 2003
    Messages
    15
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Février 2003
    Messages : 15
    Points : 11
    Points
    11
    Par défaut
    La fonction calloc te retourne un pointeur sur la zone mémoire allouée. Si le calloc n'a pas fonctionné alors le pointeur retourné est le pointeur NULL.

    Il faut donc que tu testes si le pointeur p est NULL ou non. Du manière générale quand un malloc (calloc ...) retourne un pointeur NULL alors tu termines purement et simplement l'application. Pour ma part pour tester le code de retour de ces fonctions j'utilise la fonction assert qui termine le programme si l'assertion est fausse.

    Dans ton cas :

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
     
    assert((p = calloc(50,sizeof(char)) != NULL)
    Si le pointeur p est NULL alors l'application se termine avec un joli message d'erreur

    J'ai une question moi aussi : pourquoi il est déconseillé de caster la valeur de retour d'un calloc ou malloc ? Dans le cadre du c++ ca ne marche pas si on ne fait pas le cast.

  7. #7
    Expert éminent sénior
    Avatar de Emmanuel Delahaye
    Profil pro
    Retraité
    Inscrit en
    Décembre 2003
    Messages
    14 512
    Détails du profil
    Informations personnelles :
    Âge : 67
    Localisation : France, Paris (Île de France)

    Informations professionnelles :
    Activité : Retraité

    Informations forums :
    Inscription : Décembre 2003
    Messages : 14 512
    Points : 20 985
    Points
    20 985
    Par défaut
    Citation Envoyé par PsyKroPack
    Pour ma part pour tester le code de retour de ces fonctions j'utilise la fonction assert
    Et bien, c'est un tord. C'est pas fait pour ça.

    http://emmanuel-delahaye.developpez....tes.htm#assert

    Le P.O. serait bien avisé de ne pas suivre ce conseil (assert) et de se contenter d'un classique :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
     
       T *p = malloc(...);
     
       if (p != NULL)
       {
          /* on continue... */
    J'ai une question moi aussi : pourquoi il est déconseillé de caster la valeur de retour d'un calloc ou malloc ? Dans le cadre du c++ ca ne marche pas si on ne fait pas le cast.
    http://emmanuel-delahaye.developpez....tes.htm#malloc
    Pas de Wi-Fi à la maison : CPL

  8. #8
    Expert confirmé
    Avatar de Thierry Chappuis
    Homme Profil pro
    Enseignant Chercheur
    Inscrit en
    Mai 2005
    Messages
    3 499
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 46
    Localisation : Suisse

    Informations professionnelles :
    Activité : Enseignant Chercheur
    Secteur : Industrie Pharmaceutique

    Informations forums :
    Inscription : Mai 2005
    Messages : 3 499
    Points : 5 508
    Points
    5 508
    Par défaut
    Citation Envoyé par Emmanuel Delahaye
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
     
       T *p = malloc(...);
     
       if (p != NULL)
       {
          /* on continue... */
    Personnellement, j'ai une préférence pour:
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    T *p = malloc(...);
    if (p == NULL)
    {
        /* On arrête */
    }
     
    /* On continue... */
    Ca évite d'avoir des niveaux d'imbrication trop profonds.


    Thierry
    "The most important thing in the kitchen is the waste paper basket and it needs to be centrally located.", Donald Knuth
    "If the only tool you have is a hammer, every problem looks like a nail.", probably Abraham Maslow

    FAQ-Python FAQ-C FAQ-C++

    +

  9. #9
    Expert éminent sénior
    Avatar de Emmanuel Delahaye
    Profil pro
    Retraité
    Inscrit en
    Décembre 2003
    Messages
    14 512
    Détails du profil
    Informations personnelles :
    Âge : 67
    Localisation : France, Paris (Île de France)

    Informations professionnelles :
    Activité : Retraité

    Informations forums :
    Inscription : Décembre 2003
    Messages : 14 512
    Points : 20 985
    Points
    20 985
    Par défaut
    Citation Envoyé par mujigka
    Personnellement, j'ai une préférence pour:
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    T *p = malloc(...);
    if (p == NULL)
    {
        /* On arrête */
    }
     
    /* On continue... */
    Ca évite d'avoir des niveaux d'imbrication trop profonds.
    Mais on se retrouve avec des fuites mémoires, des fichiers ouverts, des zombies, des sockets encore actives...

    Mon style de codage ne doit rien au hasard. Il est le fruit d'années de pratique...
    Pas de Wi-Fi à la maison : CPL

  10. #10
    Membre à l'essai
    Profil pro
    Inscrit en
    Février 2003
    Messages
    15
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Février 2003
    Messages : 15
    Points : 11
    Points
    11
    Par défaut
    Merci pour cette précision ! A l'avenir je n'utiliserai plus la fonction assert pour ça.

  11. #11
    Expert confirmé
    Avatar de Thierry Chappuis
    Homme Profil pro
    Enseignant Chercheur
    Inscrit en
    Mai 2005
    Messages
    3 499
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 46
    Localisation : Suisse

    Informations professionnelles :
    Activité : Enseignant Chercheur
    Secteur : Industrie Pharmaceutique

    Informations forums :
    Inscription : Mai 2005
    Messages : 3 499
    Points : 5 508
    Points
    5 508
    Par défaut
    Citation Envoyé par Duf59
    Sinon pour la fonction je veux bien oui, sauf que je comprend pas trop le "size_t buff-size...."
    buff_size te permet de spécifier la taille du tampon, un peu à la manière de la fonction fgets() pour la saisie d'une ligne. C'est à dire que si ton mot est plus long que la mémoire allouée à ton tampon, tu peux avoir des problèmes.

    Dans la fonction que je te propose ici, il y a acquisition dans le tampon p_buff de haut plus buff_size-1 caractères et le caractère nul terminal est ajouté automatiquement à la fin de la chaine, et cela, même si ton fichier contient un mot très long. La fonction lire_mot() renvoie les codes d'erreur suivant:
    • 0 si tout c'est bien passé
    • EOF si la fin de fichier à été rencontrée sans qu'aucun caractère différent d'un espace ait été lu
    • EOF si NULL est passé en paramètre pour file ou p_buff. Auncune lecture n'est effectuée et le contenu du tampon n'est pas modifié.
    • le nombre de caractères placés dans p_buff (>0) si le mot est plus long buff_size-1 (le caractère nul est toujours placé à la fin de la chaine).

    Je l'ai fait assez rapidement, c'est pas forcément le code le plus élégant, mais ça compile sans avertissement, et les tests donnent une exécution correcte:
    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
    #include <stdio.h>
    #include <stdlib.h>
    #include <ctype.h>
     
    /**
     * Lit un mot dans le fichier.
     *
     * @param file Pointeur sur le fichier ouvert par fopen()
     * @param p_buff Pointeur sur le 1er élément d'un tableau de caractères
     *               servant de tampon
     * @param buff_size Taille du tampon
     *
     * @return Code d'erreur: 0 si OK, >0 si une erreur de lecture est intervenue
     *                        (mot coupé car buff_size insuffisant), et EOF si
     *                        si EOF est rencontré sans qu'aucun caractère n'ait été
     *                        lu, ou si file ou p_buff vaut NULL.
     */
     
    int lire_mot(FILE *file, char *p_buff, size_t buff_size)
    {
        /*-TC- Attention, fgetc() retourne un int, car EOF ne peut être
           représenté par un char */
        int c;
        int i;        /* indice de boucle */
        int err = 0;  /* code d'erreur*/
     
        if (file != NULL && p_buff != NULL)
        {
            /* -TC- inclure le fichier d'en-tête standar ctype.h pour isspace() */
            while (isspace(c = fgetc(file)) && (c != EOF))
            {
                continue; /*Cette boucle ne fait rien */
            }
            if (c != EOF)
            { /* Le fichier contient au moins un caractère différent d'un espace
                 ou de EOF*/
     
                /* Acquisition du mot: au plus buff_size-1 caractère. Fin du mot
                   marquée par un espace ou par EOF */
                for (p_buff[0] = c, i = 1;
                        (i < (int) buff_size - 1) &&
                        (c = fgetc(file)) != EOF &&
                        !isspace(c);
                        ++i)
                {
                    p_buff[i] = c;
                }
                /* On place un caractère nul à la fin de la chaîne */
                p_buff[i] = '\0';
     
                /* Si la fin du mot n'a pas été atteinte: le mot est plus long que
                   buff_size-1 caractères --> La fonction retourne le nombre de
                   caractères placés dans p_buff */
                if (!isspace(c) && c != EOF)
                {
                    err = i;
                }
            }
            else
            {
                /* Lorsque le status d'erreur est EOF, p_buff ne reçoit aucun caractère*/
                p_buff[0] = '\0';
                err = EOF;
            }
        }
        else
        {
            err = EOF;
        }
     
        return err;
     
    }
     
    /* Fonction main() de test de lire_mot */
    int main(void)
    {
        int i; /* indice de boucle */
        int rc; /* return code */
        char s_buffer[15] = {'\0'};
        FILE *fp;
     
        /* Création d'un fichier test.txt*/
        fp = fopen("test.txt", "w");
        if (fp == NULL)
        {
            fprintf(stderr, "Impossible d'ouvrir test.txt en écriture!\n");
            exit(EXIT_FAILURE);
        }
        fprintf(fp, "  mot1 un_autre_mot2 ceci_est_un_mot_long");
        fclose(fp);
     
        /* Lecture du fichier test.txt */
        fp = fopen("test.txt", "r");
        if (fp == NULL)
        {
            fprintf(stderr, "Impossible d'ouvrir test.txt en lecture!\n");
            exit(EXIT_FAILURE);
        }
     
        for (i = 1; i <= 6; ++i)
        {
            rc = lire_mot(fp, s_buffer, sizeof s_buffer);
            switch (rc)
            {
            case 0:
                printf("%d: Mot-> \"%s\" err_status-> %s!\n",
                       i, s_buffer, "OK");
                break;
            case -1:
                printf("%d: Mot-> \"%s\" err_status-> %s!\n",
                       i, s_buffer, "EOF");
                break;
            default:
                printf("%d: Mot-> \"%s\" err_status-> %s!\n",
                       i, s_buffer, "Mot trop long");
                break;
            }
        }
        close(fp);
        return EXIT_SUCCESS;
    }
    Thierry
    "The most important thing in the kitchen is the waste paper basket and it needs to be centrally located.", Donald Knuth
    "If the only tool you have is a hammer, every problem looks like a nail.", probably Abraham Maslow

    FAQ-Python FAQ-C FAQ-C++

    +

  12. #12
    Expert confirmé
    Avatar de Thierry Chappuis
    Homme Profil pro
    Enseignant Chercheur
    Inscrit en
    Mai 2005
    Messages
    3 499
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 46
    Localisation : Suisse

    Informations professionnelles :
    Activité : Enseignant Chercheur
    Secteur : Industrie Pharmaceutique

    Informations forums :
    Inscription : Mai 2005
    Messages : 3 499
    Points : 5 508
    Points
    5 508
    Par défaut
    Citation Envoyé par Emmanuel Delahaye
    Mais on se retrouve avec des fuites mémoires, des fichiers ouverts, des zombies, des sockets encore actives...

    Mon style de codage ne doit rien au hasard. Il est le fruit d'années de pratique...
    Merci pour tes remarques, Emmanuel! Je vais changer ma façon de faire. As-tu un exemple concret où le style que tu préconises permet d'éviter les problèmes que tu mentionnes. J'ai du mal à voir quelles sont les avantages et inconvénients des deux style proposés du point de vue gestion de la mémoire, fermeture des fichiers et des connections.

    P.S. Je n'ai jamais dit que ton style de codage relevait du hasard... Je m'en excuse si tu as compris cela.

    Thierry
    "The most important thing in the kitchen is the waste paper basket and it needs to be centrally located.", Donald Knuth
    "If the only tool you have is a hammer, every problem looks like a nail.", probably Abraham Maslow

    FAQ-Python FAQ-C FAQ-C++

    +

  13. #13
    Futur Membre du Club
    Profil pro
    Étudiant
    Inscrit en
    Janvier 2007
    Messages
    17
    Détails du profil
    Informations personnelles :
    Localisation : France, Nord (Nord Pas de Calais)

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : Janvier 2007
    Messages : 17
    Points : 6
    Points
    6
    Par défaut
    Merci beaucoup Mujigka, je vais réfléchir un peu la dessus car c'est quand même un poil au dessus de mon niveau actuel...^_^ lol
    je repasserai surement pour d'autre question car cette fonction n'est qu'une infime partie de ce que je dois faire.... courage :p

    encore merci

  14. #14
    Membre éprouvé

    Profil pro
    Inscrit en
    Août 2003
    Messages
    878
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Août 2003
    Messages : 878
    Points : 1 067
    Points
    1 067
    Par défaut
    Citation Envoyé par Emmanuel Delahaye
    Le P.O. serait bien avisé de ne pas suivre ce conseil (assert) et de se contenter d'un classique :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
     
       T *p = malloc(...);
     
       if (p != NULL)
       {
          /* on continue... */
    Citation Envoyé par mujigka
    Personnellement, j'ai une préférence pour:
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    T *p = malloc(...);
    if (p == NULL)
    {
        /* On arrête */
    }
     
    /* On continue... */
    Ca évite d'avoir des niveaux d'imbrication trop profonds.
    Moi, je suis plutôt du genre :
    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
    BOOL fonctionX(void) {
        BOOL returnValue = FALSE; /* until proven TRUE */
        T *p1 = NULL;
        T *p2 = NULL;
     
        p1 = malloc(...);
        if ( NULL == p1 ) {
            goto exit_fx;
        }
     
        p2 = malloc(...);
        if ( NULL == p2 ) {
            goto exit_fp1_fx;
        }
     
        /* blabla */
     
        if ( un_truc_pas_bon ) {
            goto exit_fp2_fx;
        }
     
        /* blabla */
     
        returnValue = TRUE;
     
    exit_fp2_fx:
        free(p2);
    exit_fp1_fx:
        free(p1);
    exit_fx:
        return returnValue;
    }
    Un problème bien exposé
    est, pour moitié, solutionné. / La connaissance s'accroît quand on la partage, pas quand on l'impose. / La violence est le langage des faibles.

  15. #15
    Membre confirmé
    Profil pro
    Inscrit en
    Janvier 2007
    Messages
    466
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Janvier 2007
    Messages : 466
    Points : 632
    Points
    632
    Par défaut
    Bonsoir

    Si je ne me trompe pas C ne gere pas les Bool non ? ^^

  16. #16
    Expert confirmé
    Avatar de Thierry Chappuis
    Homme Profil pro
    Enseignant Chercheur
    Inscrit en
    Mai 2005
    Messages
    3 499
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 46
    Localisation : Suisse

    Informations professionnelles :
    Activité : Enseignant Chercheur
    Secteur : Industrie Pharmaceutique

    Informations forums :
    Inscription : Mai 2005
    Messages : 3 499
    Points : 5 508
    Points
    5 508
    Par défaut
    Citation Envoyé par David.Schris
    Moi, je suis plutôt du genre :
    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
    BOOL fonctionX(void) {
        BOOL returnValue = FALSE; /* until proven TRUE */
        T *p1 = NULL;
        T *p2 = NULL;
     
        p1 = malloc(...);
        if ( NULL == p1 ) {
            goto exit_fx;
        }
     
        p2 = malloc(...);
        if ( NULL == p2 ) {
            goto exit_fp1_fx;
        }
     
        /* blabla */
     
        if ( un_truc_pas_bon ) {
            goto exit_fp2_fx;
        }
     
        /* blabla */
     
        returnValue = TRUE;
     
    exit_fp2_fx:
        free(p2);
    exit_fp1_fx:
        free(p1);
    exit_fx:
        return returnValue;
    }
    Merci, je crois que je comprend maintenant la remarque d'Emmanuel:
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    T *p = malloc(sizeof *p);
    if (p != NULL)
    {
        /* On continue...*/
    }
    else
    {
        /* On affiche un message */
    }
    free(p);
    return returnValue;
    Peut-on également pratiquer de la sorte pour fopen() et fclose(). Lorsque free() reçoit NULL, cette fonction ne fait rien, mais si je ne me trompe pas, lorsque fclose() reçoit NULL ou un pointeur sur un flux qui a déjà été fermé, le comportement est indéterminé. Faut-il alors faire:
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    FILE *fp = fopen("test.txt", "r");
    if (fp != NULL)
    {
        /* On continue...*/
    }
    else
    {
        /* On affiche un message */
    }
    if (fp != NULL)
    {
        fclose(fp);
    }
    return returnValue;
    ou, selon la méthode de David.Schris (je n'utilise pas volontier goto, même pour faciliter la gestion des erreurs).

    C'est un peu HS par rapport au post original, mais cela m'intéresse...

    Meilleures salutations

    Thierry
    "The most important thing in the kitchen is the waste paper basket and it needs to be centrally located.", Donald Knuth
    "If the only tool you have is a hammer, every problem looks like a nail.", probably Abraham Maslow

    FAQ-Python FAQ-C FAQ-C++

    +

  17. #17
    Membre éprouvé

    Profil pro
    Inscrit en
    Août 2003
    Messages
    878
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Août 2003
    Messages : 878
    Points : 1 067
    Points
    1 067
    Par défaut
    Citation Envoyé par spawntux
    Bonsoir

    Si je ne me trompe pas C ne gere pas les Bool non ? ^^
    (<- lien)
    Un problème bien exposé
    est, pour moitié, solutionné. / La connaissance s'accroît quand on la partage, pas quand on l'impose. / La violence est le langage des faibles.

  18. #18
    Futur Membre du Club
    Profil pro
    Étudiant
    Inscrit en
    Janvier 2007
    Messages
    17
    Détails du profil
    Informations personnelles :
    Localisation : France, Nord (Nord Pas de Calais)

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : Janvier 2007
    Messages : 17
    Points : 6
    Points
    6
    Par défaut
    J'aurais une autre question:

    Est ce qu'il existe des fonctions qui permettent de savoir où on se situe dans un fichier ?

    par exemple j'ouvre le fichier, je lis plusieurs mots dedans et ensuite je veux remonter à une ligne que j'aurais memorisée auparavant.....

  19. #19
    Expert éminent sénior

    Avatar de fearyourself
    Homme Profil pro
    Ingénieur Informaticien Senior
    Inscrit en
    Décembre 2005
    Messages
    5 121
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 43
    Localisation : Etats-Unis

    Informations professionnelles :
    Activité : Ingénieur Informaticien Senior
    Secteur : Industrie

    Informations forums :
    Inscription : Décembre 2005
    Messages : 5 121
    Points : 11 877
    Points
    11 877
    Par défaut
    Citation Envoyé par Duf59
    J'aurais une autre question:

    Est ce qu'il existe des fonctions qui permettent de savoir où on se situe dans un fichier ?

    par exemple j'ouvre le fichier, je lis plusieurs mots dedans et ensuite je veux remonter à une ligne que j'aurais memorisée auparavant.....
    man ftell

    et

    man fseek
    Jc

  20. #20
    Expert éminent sénior
    Avatar de Emmanuel Delahaye
    Profil pro
    Retraité
    Inscrit en
    Décembre 2003
    Messages
    14 512
    Détails du profil
    Informations personnelles :
    Âge : 67
    Localisation : France, Paris (Île de France)

    Informations professionnelles :
    Activité : Retraité

    Informations forums :
    Inscription : Décembre 2003
    Messages : 14 512
    Points : 20 985
    Points
    20 985
    Par défaut
    Citation Envoyé par Duf59
    Est ce qu'il existe des fonctions qui permettent de savoir où on se situe dans un fichier ?

    par exemple j'ouvre le fichier, je lis plusieurs mots dedans et ensuite je veux remonter à une ligne que j'aurais memorisée auparavant.....
    ftell(), et fseek(), mais je ne suis pas sûr que ça ait un sens avec les fichiers textes...

    A mon avis, il vaut mieux revoir ton algorithme et pour ça, il faut expliquer ce que tu veux faire exactement.
    Pas de Wi-Fi à la maison : CPL

Discussions similaires

  1. Lire un mot dans un fichier texte
    Par Sophie_Géo dans le forum Développement de jobs
    Réponses: 9
    Dernier message: 12/03/2015, 15h06
  2. Ecrire & Lire des énumérés dans un fichier Texte
    Par WebPac dans le forum Langage
    Réponses: 8
    Dernier message: 18/06/2008, 11h04
  3. lire un mot dans un fichier
    Par ibtisss dans le forum Langage
    Réponses: 3
    Dernier message: 08/11/2005, 13h14
  4. Comment changer des mots dans un fichier?
    Par ptitbonum dans le forum Linux
    Réponses: 5
    Dernier message: 08/04/2004, 00h42
  5. Lire un attribut dans un fichier XML en C++
    Par ti.k-nar dans le forum XML
    Réponses: 2
    Dernier message: 14/10/2002, 16h22

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo