E/S binaires: Lire et sauvegarder une structure contenant une matrice

**nebbule** · 09/12/2011, 01h30

Salut à vous,

Je suis un peu dans le brouillard avec mon code en C, et j’espère trouver quelqu'un sur le forum de developpez.com pour éclaircir un peu tout çà...

Voici mon code:

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
123
124
125
126
 
#include<stdio.h>
#include<stdlib.h>
 
 
typedef struct{
 
    int lig;
    int col;
    double* data;
}Matrice;
 
 
Matrice* creerMatrice(int,int);
void saisirMatrice(Matrice*);
void detruireMatrice(Matrice*);
void afficherMatrice(Matrice*);
int sauverMatrice(char*,Matrice*);
Matrice* lireMatrice(char*);
 
int main(void){
 
 
Matrice dim;
Matrice* pointeur;
Matrice* pmat;
char* nom="matrice";
int retour=0;
 
 
    printf("\n\nVeuillez saisir la dimension de votre matrice(EX: X,Y): ");
    scanf("%d,%d",&dim.lig,&dim.col);
    pointeur= creerMatrice(dim.lig,dim.col);
    saisirMatrice(pointeur);
    afficherMatrice(pointeur);
    retour= sauverMatrice(nom,pointeur);
    if(retour!=1) printf("\n\nErreur en ecriture !");
    detruireMatrice(pointeur);
    pmat= lireMatrice(nom);
    afficherMatrice(pmat);
    printf("\n\n");
    return 0;
 
}
 
 
Matrice* creerMatrice(int X,int Y){
 
Matrice* pointeur;
 
 
    pointeur= (Matrice*)malloc(sizeof(Matrice));
    pointeur->lig= X;
    pointeur->col= Y;
    pointeur->data= (double*)calloc(X*Y,sizeof(double));
    return pointeur;
}
 
 
void saisirMatrice(Matrice* pointeur){
 
int i=0;
 
 
    for(i=0;i<(pointeur->lig*pointeur->col);i++){
        printf("\n\nVeuillez saisir l'element[%d]: ",i+1);
        scanf("%lf",&pointeur->data[i]);
    }
}
 
 
void afficherMatrice(Matrice* pointeur){
 
int i=0;
 
    printf("\n\nVoici un recapitulatif de votre matrice...\n\n");
    while(i<pointeur->lig*pointeur->col){
        if(i%pointeur->lig!=0){
            printf("| %lf |",pointeur->data[i]);
            printf("\n");
            i++;
        }
        else {
            printf("| %lf |",pointeur->data[i]);
            i++;
        }
    }
}
 
void detruireMatrice(Matrice* pointeur){
 
    free(pointeur->data);
    free(pointeur);
}
 
 
int sauverMatrice(char* nom,Matrice* pointeur){
 
FILE* downStream;
 
    if(!(downStream= fopen(nom,"w+"))){
        printf("\nMemoire insuffisante!");
        return 0 ;
    }
    if(fwrite(&pointeur->lig,sizeof(int),1,downStream) !=1) return 0;
    if(fwrite(&pointeur->col,sizeof(int),1,downStream) !=1) return 0;
    if(fwrite(pointeur->data,sizeof(double),(pointeur->lig*pointeur->col),downStream) !=(pointeur->lig*pointeur->col)) return 0;
    fclose(downStream);
    return 1;
}
 
Matrice* lireMatrice(char* nom){
 
Matrice* pointeur;
FILE* downStream;
 
    if(!(downStream= fopen(nom,"r"))){
        printf("\nErreur d'ouverture!");
        return 0 ;
    }
    if(fread(&pointeur->lig,sizeof(int),1,downStream) !=1) printf("\n\nErreur de lecture");
    if(fread(&pointeur->col,sizeof(int),1,downStream) !=1) printf("\n\nErreur de lecture");
    if(fread(pointeur->data,sizeof(double),(pointeur->lig*pointeur->col),downStream) !=(pointeur->lig*pointeur->col)) printf("\n\nErreur de lecture");
    fclose(downStream);
    return pointeur;
}

Comme vous pouvez le remarquer le but de cet exo est de créer une matrice, la sauvegarder sur notre disque et enfin pouvoir la relire quand on veut...
Comme c'est la première fois que j'ai à faire à la gestion des flux binaires, je ne suis pas vraiment à l'aise. On ajoute cela à une soirée infructueuse(parmi tant d'autres il est vrai, mais là j'aimerai bien finir cet exo histoire d'être tranquille pour les vacances qui approchent

)

Les hic's dans ce programme sont:

-Le prog compile mais plante au niveau de

Code :

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

1
2
lireMatrice(char*)
 if(fread(&pointeur->col,sizeof(int),1,downStream) !=1) printf("\n\nErreur de lecture");

Je vérifie déjà ce que je récupère au niveau de

Code :

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

if(fread(&pointeur->lig,sizeof(int),1,downStream) !=1) printf("\n\nErreur de lecture");

Et là, à ma grande surprise, qui je dois bien l'avouer se transforme de plus en plus en désarroi vu l'heure avancé de la soirée, au lieu de me retourner la bonne dimension(entrée au clavier), il m'en renvoie une autre.
Il y a très certainement quelque chose que je n'ai pas comprise avec fwrite et fread.
Je crois qu'il va me falloir l'aide de plus expert que moi.(En fait, j'en suis sûr

)

Merci à vous pour le temps que vous m'accorderez.

**Kaamui** · 09/12/2011, 10h00

Envoyé par nebbule

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
 
Matrice* lireMatrice(char* nom){
 
//Matrice* pointeur;<---------PAS BIEN
Matrice* pointeur = NULL;//<----- BIEN
FILE* downStream;
 
    if(!(downStream= fopen(nom,"r"))){
        printf("\nErreur d'ouverture!");
        return 0 ;
    }
    if(fread(&pointeur->lig,sizeof(int),1,downStream) !=1) printf("\n\nErreur de lecture");
    if(fread(&pointeur->col,sizeof(int),1,downStream) !=1) printf("\n\nErreur de lecture");
    if(fread(pointeur->data,sizeof(double),(pointeur->lig*pointeur->col),downStream) !=(pointeur->lig*pointeur->col)) printf("\n\nErreur de lecture");
    fclose(downStream);
    return pointeur;
}

Normalement cela devrait aller mieux

**diogene** · 09/12/2011, 10h31

@Kaamui :

Normalement cela devrait aller mieux

Non.

@nebbule

Code :

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

1
2
3
4
5
6
Matrice* lireMatrice(char* nom){
 
Matrice* pointeur;
FILE* downStream;
... 
    if(fread(&pointeur->lig,sizeof(int),1,downStream) !=1) printf("\n\nErreur de lecture");....

Il n'y a pas de matrice créée dont l'adresse aurait été mise dans pointeur.

Il faut commencer par lire le nombre de lignes et de colonnes, puis appeler creerMatrice() pour obtenir l'adresse d'une matrice valide et enfin lire les données de la matrice.

**Kaamui** · 09/12/2011, 11h29

C'est vrai en effet. J'ai regardé trop vite

**nebbule** · 09/12/2011, 15h37

Salut à vous et merci beaucoup.

Effectivement, depuis que j'ai créée la matrice les paramètres sont pris en compte. Ki après mûr réflexion(et les idées un peu plus clair), devient évidente, la solution adoptée pour ma part est celle-ci:

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
 
Matrice* lireMatrice(char* nom){
 
Matrice* pointeur;
FILE* downStream;
 
    if(!(downStream= fopen(nom,"r"))){
        printf("\nErreur d'ouverture!");
        return 0 ;
    }
    pointeur= creerMatrice(pointeur->lig,pointeur->col);
    if(fread(&pointeur->lig,sizeof(int),1,downStream) !=1) printf("\n\nErreur de lecture");
    if(fread(&pointeur->col,sizeof(int),1,downStream) !=1) printf("\n\nErreur de lecture");
    if(fread(pointeur->data,sizeof(double),(pointeur->lig*pointeur->col),downStream) !=(pointeur->lig*pointeur->col)) printf("\n\nErreur de lecture");
    fclose(downStream);
    return pointeur;
}

Encore merci, à vous Kaamui et un spécial pour diogene et le site developpez.com qui m'a aidé, m'aide et m'aidera encore(j'en suis sûr) lors de mes déboires avec les langages informatiques. Neb'

**diogene** · 09/12/2011, 16h39

Ceci n'est pas correct :

Code :

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

pointeur= creerMatrice(pointeur->lig,pointeur->col);

Parce que au moment de l'évaluation des arguments, pointeur n'est pas correctement initialisé. Il faut procéder de la façon suivante :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
Matrice* lireMatrice(char* nom){
 
Matrice* pointeur;
FILE* downStream;
int lgn, col;
....
    if(fread(&lgn,sizeof(int),1,downStream) !=1) printf("\n\nErreur de lecture");
    if(fread(&col,sizeof(int),1,downStream) !=1) printf("\n\nErreur de lecture");
    pointeur= creerMatrice(lgn,col);
....
}

**nebbule** · 09/12/2011, 17h30

Effectivement diogene, l'initialisation d'un pointeur est primordiale et je suis passé au travers.
Par contre, je ne m'explique pas pourquoi, avec la méthode que j'ai établie juste au-dessus, mon programme fonctionné quand même ?

Est-ce dû au hasard ? (Je ne vous embête plus après)
Neb'.

**Kaamui** · 09/12/2011, 17h47

Ce n'est pas parce que ça compile et que tu as les bons résultats à la fin que ton code est bon :

Pour rejoindre diogene, tu n'as qu'à essayer d'afficher le contenu de tes membres lig et col présentes dans ta matrice pointeur juste après l'appel à CreerMatrice.

Cordialement,

**nebbule** · 09/12/2011, 18h48

Entièrement d'accord avec toi Kaamui.
Après test dans ma fonction lireMatrice que cela soit avec la mauvaise méthode ou que cela soit avec la bonne méthode les retours sont les mêmes, que cela soit pour les adresses ou pour les valeurs stockés (ce qui n’était pas le cas avant sans l'appel à creerMatrice()).

Ce que j'ai pu remarquer lors des tests c'est qu'a partir du moment où ma fonction creerMatrice() a été appelé une fois, les blocs mémoires alloués restent les mêmes, même après avoir détruit tous les champs de ma structure.

A croire que ma structure garde toujours les mêmes blocs lors de toute l’exécution du programme.(a savoir si la fonction free() libère réellement l'allocation mémoire directement, où seulement lorsque le prog à fini sont exécution ????)

Cordialement.Neb'

E/S binaires: Lire et sauvegarder une structure contenant une matrice

C

Discussions similaires

Partager

Partager