Envoyer une structure dans un fichier .txt

Version imprimable

23/04/2013, 09h06
floflo87

Envoyer une structure dans un fichier .txt
Bonjour,

J'ai une petite question, j'ai une structure de type :
Code:

1 2 3 4 5 typedef struct{ int a; char B; float c; } Structure_a
mais ma structure est bien plus longue et a des structures intégrées.

Je voudrais savoir s'il y a un moyen simple (car pour l'instant j'ai trouvé que des moyens compliqués) pour faire une sauvegarde de ma structure dans un fichier .txt .

Merci par avance
23/04/2013, 09h42
Metalman

Il y a eu un grand débat là dessus il y a quelques semaines...
De ce que j'ai retenu : tu "peux" faire un fwrite et un fread pour la stocker et la lire sans vraiment savoir ce qu'il se passe...
Et tu risques d'avoir des problèmes si tu changes entre une machine 32 bits et 64 bits pour la lecture/écriture avec le même fichier.

Ou alors tu dois faire une fonction qui écrit chaque champ entre des séparateurs, et une fonction qui lit entre chaque séparateur.
23/04/2013, 12h27
Neckara

Bonjour,

Citation:

Envoyé par Metalman

Il y a eu un grand débat là dessus il y a quelques semaines...
De ce que j'ai retenu : tu "peux" faire un fwrite et un fread pour la stocker et la lire sans vraiment savoir ce qu'il se passe...
Et tu risques d'avoir des problèmes si tu changes entre une machine 32 bits et 64 bits pour la lecture/écriture avec le même fichier.

Ou alors tu dois faire une fonction qui écrit chaque champ entre des séparateurs, et une fonction qui lit entre chaque séparateur.

Pas besoins de séparateurs si on écrit tout en binaire avec pour les nombres 1 octet écrit = 1 octet du nombre, il suffit juste de passer par des hton et des types dont les tailles ne changent pas comme int8_t ou uint64_t.

Après, si on écrit les nombres avec 1 caractère écrit = 1 chiffre en base 10 du nombre, on peut avoir deux choix :
- Soit on utilise en effet des séparateurs ;
- Soit on donne une "taille" fixe aux nombres en rajoutant des caractères (ex : printf("%5.5d, monEntier)).

Si le but est juste de stocker des informations, je te conseille de tout écrire en binaire.
Si le but est de pouvoir comprendre et éditer le fichier, peut-être que les XML pourraient t'intéresser.

Le posteur originel a dit explicitement ".txt" dans son message et le titre, toute mention écriture binaire est donc hors-sujet.

Je dirais que le plus intuitif est de faire une fonction pour chaque structure, qui écrira son contenu. Si tu as des tableaux (dynamiques ou non, listes chaînées ou non), ne pas oublier d'écrire leur longueur en premier.

Edit: Exemple:

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
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
typedef struct{
	int a;
	char B;
	float c;
} Structure_a;
 
typedef struct {
	char * d;
	Structure_a *e;
	float f;
	int nba;
	short g;
} Structure_b;
 
void write_Structure_a(Structure_a const *p, FILE* f)
{
	fprintf(f, "%d\n", p->a);
	fprintf(f, "%d\n", p->B);
	fprintf(f, "%f\n", p->c);
}
void read_Structure_a(Structure_a *p, FILE* f)
{
	char s[100];
	int i;
 
	fgets(s, 100, f);
	sscanf(s, "%d", &p->a);
 
	fgets(s, 100, f);
	sscanf(s, "%d", &i); /*Because C90 has no decimal format for chars*/
	p->B = i;
 
	fgets(s, 100, f);
	sscanf(s, "%f", &p->c);
}
 
void write_Structure_b(Structure_b const *p, FILE* f)
{
	int ix;
	fprintf(f, "%d\n", p->d);
	fprintf(f, "%d\n", p->nba);
	for(ix=0 ; ix<p->nba ; ix++)
		write_Structure_a(&p->e[ix], f);
	fprintf(f, "%f\n", p->f);
	fprintf(f, "%d\n", p->g);
}
void read_Structure_b(Structure_b *p, FILE* f)
{
	char s[100];
	int ix;
 
	fgets(s, 100, f);
	sscanf(s, "%d", &p->d);
 
	fgets(s, 100, f);
	sscanf(s, "%d", &p->nba);
 
	p->e = malloc(sizeof(Structure_a) * p->nba); /*pour la gestion d'erreur on verra plus tard*/
	for(ix=0 ; ix<p->nba ; ix++)
		read_Structure_a(&p->e[ix], f);
 
	fgets(s, 100, f);
	sscanf(s, "%f", &p->f);
 
	fgets(s, 100, f);
	sscanf(s, "%hd", &p->g);
}

Salut,

Je te conseille de décrire ta structure dans un format XML.
Et pour chaque structure faire 2 fonctions de codage/decodage XML:
Code:

1 2 3 char * mystruct_to_xml_string(char *xml_str, size_t n, const mystruct * this); mystruct * xml_string_to_mystruct (my_strcut * this, const char *xml_str);

23/04/2013, 17h36
ternel

Ce n'est pas forcément une bonne idée. L'XML est assez lourd à produire et surtout à analyser.
Enfin, tant qu'on veut obtenir un xml bien-formé (je ne parle même pas d'une validation xsd ou DTD)
Souvent, les formats ini ou json sont de bons choix (ini si pas de profondeur)
23/04/2013, 17h40
Neckara

Après, pour faciliter le chargement de ta structure, je te conseille de mettre un "numéro de version" dans ton fichier.

Ainsi si tu modifie ta structure, tu incrémentes ton numéro de version et tu seras alors capable de lire d'anciennes sauvegarde.

Le XML sera très pratique et le numéro de version ne sera pas toujours utile car généralement, il faudra juste mettre des valeurs par défaut avant le chargement du fichier XML et/ou d'ignorer des champs.

Mais dans le cas de fichiers textes "bruts" ou de fichiers binaires, selon la version, on risque de ne pas du tout lire de la même façon. Dans ce cas là, le numéro de version déterminera la manière de lire le fichier de sauvegarde.

C'est pour cela que pour des sauvegarde de structures pouvant évoluer, on préfère souvent les fichiers XML ( il existe aussi d'autres types de fichiers du genre -edit : grillé par leternel-).