Lire et écrire.

Version imprimable

Lire et écrire.

Salut à tous !

Contexte : Dans le jeu que je code il y a des règles par exemple ## donne $.
Une règle est un tableau de deux dimensions qui contient d'une part les ingrédients et d'autre part le résultat.

Question : J'essaye d'entrée des règles dans un fichier texte par exemple
## $
$$ ~
Et mon but est de lire ce fichier et de renvoyer une tableau de règles.

Voici une fonction qui pourrait vous être utile :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
Regle char2Regle(char entree[], char sortie[]){
    Regle regle = {
    {0,0,0,0,0,0,0,0,0,0,0,0,0,0},
    {0,0,0,0,0,0,0,0,0,0,0,0,0,0},
    };
    int i;for(i=0;entree[i]!='\0';i+=1){
        regle.entree[char2Materiau(entree[i])]+=1;
    }
    for(i=0;sortie[i]!='\0';i+=1){
        regle.sortie[char2Materiau(sortie[i])]+=1;
    }
    return regle;
}

Voici la bête :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
Regle *lit_regles(const char *filename){
    int i,j=0,N = compte_lignes(filename);
    Regle *tampax = calloc(sizeof(Regle),N);
    FILE* fichier = fopen("filename", "r");
    char *entree, *sortie;
    if (!fichier){
            for(i=0;fgetc(fichier)!=EOF;i++){
            entree = calloc(sizeof(char),N);
            sortie = calloc(sizeof(char),N);
            fscanf(fichier,"%s %s", entree, sortie);
            tampax[i] = char2Regle(entree,sortie);
            fseek(fichier,(strlen(entree)+strlen(sortie))+1,SEEK_CUR);
            free(entree);
            free(sortie);
            }
        fclose(fichier);
        return tampax;
        }
    else
    {
            printf("\nImpossible d'ouvrir le fichier test.txt\n");
            return NULL;
    }
}

Mon but est de stocker des règles dans le tableau tampax jusqu'à ce que le curseur soit à la fin du fichier mais je passe à côté. Pouvez vous m'aider s'il vous plait ?

Ça sent mauvais, ça:
Code:

1 2 3 N = compte_lignes(filename); ... entree = calloc(sizeof(char),N);

29/03/2016, 18h52
CechD

Je n'ai pas compris pourquoi ça sent mauvais mais en y réfléchissant un peu j'ai surtout compris que ça sert à rien, du coup j'ai mis 50 parce que c'est largement suffisent àmha :mouarf:.
29/03/2016, 20h51
Matt_Houston

Citation:

Envoyé par CechD

Mon but est de stocker des règles dans le tableau tampax

:fleur2: élégant !

Pourquoi le fseek ? Les données lues par fscanf sont déjà consommées.
29/03/2016, 20h56
CechD

Mes TP de programmation sont le jeudi de 16h à 18h, ça fait des dégâts :aie:.

Je pensais devoir déplacer mon curseur tout seul, ce peut-il que fscanf va déplacer mon curseur à la fin des éléments qu'il lit ?
30/03/2016, 14h16
dinobogan

Citation:

Envoyé par CechD

Je pensais devoir déplacer mon curseur tout seul, ce peut-il que fscanf va déplacer mon curseur à la fin des éléments qu'il lit ?

Oui, le "curseur" est déplacé par cette fonction, pas besoin de fseek avec fscanf.

Selon chacun de vos commentaire j'ai fait des motifs mais je n'arrive pas à voir le fond du problème qu'en dite vous ?

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
Regle *lit_regles(const char *filename){
    int i,j=0,N = compte_lignes(filename);
    Regle *always = calloc(sizeof(Regle),N);
    FILE* fichier = fopen("filename", "r");
    char *entree, *sortie;
    if (!fichier){
            for(i=0; fgetc(fichier)!=EOF ;i++){
            entree = calloc(sizeof(char),50);
            sortie = calloc(sizeof(char),50);
            fscanf(fichier,"%s %s", entree, sortie);
            always[i] = char2Regle(entree,sortie);
            affiche_regle(always[i]); /*Teste*/
            free(entree);
            free(sortie);
            }
        fclose(fichier);
        return always;
        }
    else
    {
            printf("\nImpossible d'ouvrir le fichier test.txt\n");
            return NULL;
    }
}

J'ai ensuite réalisé un teste :
- afficheregle pour voir si le tableau de remplissait et j'ai découvert que non il y a une boucle infini avant même de remplir le tableau.

To be continued.

Bonjour

Citation:

Envoyé par CechD

Selon chacun de vos commentaire j'ai fait des motifs

Ah ? Et tu as dessiné quoi comme "motif" ???

Citation:

Envoyé par CechD

mais je n'arrive pas à voir le fond du problème qu'en dite vous ?

Ben je dis que tu as d'autres dessins à faire...

Déjà juste ça
Code:

1 2 3 4 5 6 7 8 9 char *entree, *sortie; while (...) { entree = calloc(sizeof(char),50); sortie = calloc(sizeof(char),50); ... free(entree); free(sortie); }
serait avantageusement remplacé par
Code:

1 2 3 4 5 char entree[50], sortie[50]; while (...) { ... }
Inutile en effet d'allouer/désallouer à chaque itération. Et si vraiment tu veux remplir ta chaine de zéro avant son remplissage (ce qui serait autant incompréhensible qu'inutile) alors t'as memset() qui peut te le faire...

Ensuite ça
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 fichier=fopen(...) if (!fichier) // t'es sûr ??? { .... .... (gros traitement)... .... fclose(fichier); return truc; } else { printf("erreur..."); return NULL; }
Peut s'écrire plus simplement
Code:

1 2 3 4 5 6 7 8 9 10 11 12 fichier=fopen(...) if (fichier == NULL) { printf("erreur"); return NULL; } .... .... (gros traitement)... .... fclose(fichier); return truc;
Déjà écrire explicitement fichier != NULL évite de se vautrer lamentablement avec des raccourcis qui 1) n'en sont pas vraiment et 2) sont plus source d'erreur qu'autre chose. Et ensuite faire les tests préalables en début de fonction et sortir immédiatement si pb t'offre ensuite tout l'espace de ta ligne pour coder tes gros traitements. Mais certains profs "puristes" n'aiment pas (leur crédo c'est "un seul point d'entrée et un seul point de sortie") donc sur ce détail c'est toi qui voit.

Déjà tout ça ça devrait améliorer grandement le motif...

31/03/2016, 09h43
nnovic

Accessoirement, c'est la cour des grands ici. Alors "tampax", renommé "always", pour stocker des règles, c'est déplacé. Garde ça pour les soirées entre potes.
31/03/2016, 10h09
CechD

Si je ne vous réponds plus c'est que je me fait discret comme un ninja, je referais surface quand je serais validé par la street et plein de confiance, sayonara !
31/03/2016, 18h47
Sve@r

Citation:

Envoyé par nnovic

Accessoirement, c'est la cour des grands ici. Alors "tampax", renommé "always", pour stocker des règles, c'est déplacé. Garde ça pour les soirées entre potes.

Bah moi j'ai trouvé ça amusant (c'est pas la vanne de l'année mais ça dénote un esprit inventif). C'est son programme qu'il code pour lui (enfin pour son TP) alors s'il a envie de se faire ses jeux de mots (qui ne sont ni vulgaires ni scabreux) sur ses noms de variables pourquoi vouloir jouer le censeur ?

Juste (pour CechD qui devrait revoir sa conjugaison des verbes "refaire" et "être" à l'indicatif futur) que ça me rappelle que la norme veut un "t_" devant les noms de types (t_regle par exemple)...