Discussion :

[Meyn]

je me rappelle plus comment on fait quand dans un fichier j'ai une structure du genre

octet 0-100 nom
octet 100-200 addresse
octet 200-205 code postal
...

je me rappelle qu'une facon simple est de faire une structure

struct s_header
{
char nom[100];
char addresse[100];
char codepostal[5];
}


et ensuite de faire une union

union u_header
{
struct s_header;
char // la le bas blesse
}

mais sachant que je pense utiliser fgets pour faire des entree bufferise.

je me rappelle plus quoi mettre dans l'union pour pourvoir confomdre ma structure avec les octets lu du fichier.

en esperant avoir ete clair avec mon probleme.

Cordialement.

[Gruik]

Je sais pas si c'est autorisé, mais ceci pourrait être sympa

Code :

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

1
2
3
4
5
union u_header
{
  struct s_header;
  char data_header[sizeof (struct s_header)];
};

[Meyn]

oui mais ce que j'arrive pas a faire c'est que j'ai un char* (s) que j'obtiens avec fgets et la je le confondre avec ma struct
si je fais

union u_headers u;

u.data_header = s;
la ca marche pas.

donc si vous avais une idee.

[Gruik]

C'est parceque les langages plus évolués t'ont fait prendre l'habitude de manipuler des types chaine alors qu'en C il n'y a pas vraiment de type "chaine"
Juste des pointeurs qui pointent vers des zones contenant une serie de caractere terminée par \0

Pour copier une chaine dans une zone c'est strcpy()

[NewbiZ]

J'ai pas de compilateur sous la main, alors je promets rien.

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
 
#include <stdio.h>
#include <stdlib.h>
 
typedef
struct
{
      char nom[100];
      char addresse[100];
      char codepostal[5];
} header_t;
 
void LoadFromFile( const char* filename, header_t* buffer)
{
     FILE* file = NULL;
 
     if ((file = fopen(filename, "rb")) == NULL)
     {
                printf("LoadFromFile: Erreur de chargement du fichier.\n");
                return;
     }
 
     fread(file, sizeof(header_t), 1, buffer);
 
     fclose(file);
}
 
void SaveToFile( const char* filename, header_t* buffer)
{
     FILE* file = NULL;
 
     if ((file = fopen(filename, "wb")) == NULL)
     {
                printf("SaveToFile: Erreur d'ecriture du fichier.\n");
                return;
     }
 
     fwrite(buffer, sizeof(header_t), 1, file);
 
     fclose(file);
}
 
void LoadFromString (const char* data, header_t* buffer)
{
     buffer = (header_t*)data;
}
 
int main(int argc, char *argv[])
{
  header_t header;
 
  LoadFromFile("fichier.txt", &header);
  LoadFromString("ceci est une chaine", &header);
  SaveToFile("fichier2.txt", &header);
 
  system("PAUSE");	
  return 0;
}

[Meyn]

Merci les gars je vais tester ca ;-)

[fearyourself]

Quelques remarques :

Code :

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

1
2
 
     if ((file = fopen(filename, "rb")) == NULL)

Le fichier est ouvert en binaire, plus embêtant à regarder son bon fonctionnement que si on commence en mode texte...

Code :

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

1
2
3
4
5
 
     {
                printf("LoadFromFile: Erreur de chargement du fichier.\n");
                return;
     }

Erreur de conception, le return; ne devrait pas être utilisé. Ceci est une fonction qui peut planter, ce serait bien de retourner un entier pour le signaler.

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 SaveToFile( const char* filename, header_t* buffer)
{
     FILE* file = NULL;
 
     if ((file = fopen(filename, "wb")) == NULL)
     {
                printf("SaveToFile: Erreur d'ecriture du fichier.\n");
                return;
     }
 
     fwrite(buffer, sizeof(header_t), 1, file);
 
     fclose(file);
}

Mêmes remarques...

Code :

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

1
2
3
4
5
 
void LoadFromString (const char* data, header_t* buffer)
{
     buffer = (header_t*)data;
}

Pas de cast en C. On peut s'en passer et c'est source d'erreurs... Cette fonction est fausse.

En C, on ne modifie pas les paramètres que les zones pointées...

Ceci fonctionnerait :

Code :

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

1
2
3
4
5
 
void LoadFromString (const char* data, header_t* buffer)
{
     memcpy( buffer, data , sizeof(header_t));
}

Jc

[Meyn]

Merci les gars ca marche.

[NewbiZ]

Le fichier est ouvert en binaire, plus embêtant à regarder son bon fonctionnement que si on commence en mode texte...

C'est à dire ? "son bon fonctionnement".

Erreur de conception, le return; ne devrait pas être utilisé. Ceci est une fonction qui peut planter, ce serait bien de retourner un entier pour le signaler.

Désolé, instinct C++iens, d'habitude je préfère conserver la valeur de retour de la fonction pour autre chose, et envoyer une exception en cas de problème, ca permet d'éviter un gros switch et de gérer les erreurs indépendamment de la ou on apelle la fonction.

[fearyourself]

C'est à dire ? "son bon fonctionnement".

C'est plus facile, après l'écriture d'un fichier de le lire avec un bloc note s'il est écrit en mode texte