Discussion :

[A_B]

Salut :
Je suis en train de travailler sur des structures comportant des champs de caracteres comme ça :

Code :

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

1
2
3
4
5
typedef struct perso {
                gchar *nom;
                gchar *prenom ;
                gchar *telephone ;
                                      }bloc ;

Et je désire les ecrire dans un fichier binaire, normalement avec (fwrite), et puis les reccuperer avec (fread) , et mettre le resultat dans un fichier (texte.txt) pour l'afficher dans un (text view)et la c'est le probleme , car fputs utilise une chaine de char et moi j'en ai une chaine gchar, alors comment je fais ?
Voila une partie du 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
void cb_consulter (GtkWidget *widget, gpointer data)
{
    FILE *texte = NULL ;
    FILE *fichier = NULL;
 
    bloc *temp  = NULL ;
    gchar nombre ;
    const gchar *nom , *prenom , *tel ;
    int x=0;
 
    temp = (struct perso*) malloc (sizeof (struct perso));
 
    fichier = fopen ("repp","r");
 
 
 
                          while (fread(temp,sizeof(bloc),1,fichier),!feof(fichier))
 
                          {
                           nom    =   temp->nom ;
                           prenom =   temp->nom ;
                           tel    =   temp->nom ;
                           fputs(nom,texte);
                           fputs(prenom,texte);
                           fputs(tel,texte);
 
                            x++ ;
                           }
                           nombre = x ;
 
                           free(temp);
 
                           fclose(fichier);
 
                           open(widget,texte);
 
 
 
};

[Franck.H]

Hé bin ? un gchar c'est quoi d'après toi ?

Code :

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

typedef char   gchar;

voilà, c'est rien d'autre que ca, que ce soit l'un ou l'autre cela ne change strictement rien du tout donc aucun problème et si ton compilateur t'embêtes, alors tu fait un cas c'est tout, exemple:

Code :

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

fputs((char *)nom,texte);

[A_B]

Non toujours ça ne marche pas (l'ecriture des chaines de caractere sur le fichier texte ), meme si je le consulte manuellement , je ne trouve pas ce que je prevoit ! Je trouve des caractere bizarre..Donc l'ecrituire n'a pas eu lieu normalement !

[Franck.H]

Bin montre alors ta fonction qui écrit ... ou le code complet de ton programme que je puisse tester chez moi

[A_B]

Voila la fonction :

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
void cb_consulter (GtkWidget *widget, gpointer data)
{
    FILE *texte   = NULL ;
    FILE *fichier = NULL;
 
    bloc *temp    = NULL ;
 
    char *nom = NULL;
    char *prenom = NULL;
    char *tel = NULL;
 
    int x = 0;
 
    temp = (struct perso*) malloc (sizeof (struct perso));
 
 
    fichier = fopen ("repp","r");
    texte   = fopen ("texte.txt","w");
 
 
                          while (fread(temp,sizeof(bloc),1,fichier),!feof(fichier))
 
                          {
                           temp = (struct perso*) malloc (sizeof (struct perso));
                           nom    =   temp->nom ;
                           prenom =   temp->nom ;
                           tel    =   temp->nom ;
 
                           free(temp);
 
                           fputs(nom,texte);
                           fputs(prenom,texte);
                           fputs(tel,texte); 
 
                            x++ ;
                           }
 
 
 
 
                           fclose(fichier);
                           fclose (texte);
 
                           open(widget,data);
 
 
 
};

voila la fonction open :

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
void open (GtkWidget*widget, gpointer data)
{
    open_file("texte.txt",GTK_TEXT_VIEW(data));
    gtk_widget_show_all(affiche);
   (void)widget;
}
 
static void open_file (const gchar *file_name, GtkTextView *p_text_view)
{
gchar *contents              = NULL;
GtkTextBuffer *p_text_buffer = NULL;
 
if (g_file_get_contents (file_name, &contents, NULL, NULL))
{
    p_text_buffer = gtk_text_view_get_buffer (p_text_view);
    gtk_text_buffer_set_text (p_text_buffer, contents, -1);
 
}
}

[Franck.H]

Un truc auquel je n'ai pas fait attention mais utiliser fread sur un flux texte ne fonctionne pas, il faut utiliser fgets qui reste encore la meilleure solution. En effet, fread n'est fait que pour les flux binaires et non texte donc ton problème viens du fait que tu lit ton fichier avec cette fonction et donc forcément tes données sont éronées.

C'est comme si tu veux utiliser fwrite pour écrire dans un flux texte puis après tu veux lire le fichier en l'ouvrant dans un éditeur, tu risques d'avoir des surprises

Le mieux est d'enregistrer et de lire uniquement dans le même format donc écriture avec fprintf et lecture avec fgets !

[A_B]

Peut etre vous n'avez pas compris :
Je travaille sur des fichiers binaires , mais je copie les informations dans des fichiers textes pour les afficher dans textview, donc la fread que vous voyez c'est celle qui lit le fichier binaire,...

[Franck.H]

Peut etre vous n'avez pas compris :
Je travaille sur des fichiers binaires , mais je copie les informations dans des fichiers textes pour les afficher dans textview, donc la fread que vous voyez c'est celle qui lit le fichier binaire,...

Faux car ici:

Code :

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

fichier = fopen ("repp","r");

Tu ouvres un fichier en mode texte "r", si tu veux une ouverture en mode binaire il faut mettre "rb" ... ceci fait parti des bases du C !

Cependant, si tu veux simplement lire ton fichier binaire et mettre les informations dans les widgets, je ne vois pas la raison de d'abord enregistrer dans un fichier texte puis transmettre les infos aux widgets

C'est vrai quoi, tu lit ton fichier binaire dont tu rempli une structure avec tes infos comme tu le fait là (il faut pas oublier d'ouvrir en mode binaire par contre sinon ca n'ira pas mieux) puis depuis cette structure tu insères les données dans tes widgets, pourquoi se compliquer la vie !

[A_B]

Mais je croit que la meilleur façon d'afficher des info c'est le TEXTVIEW non ?
Et je sait pas comment j'insere mes infos ligne par ligne...
Sinon je suis pret a changer..!

[Franck.H]

Commence déjà par ouvrir ton fichier depuis lequel tu veux récupérer les informations, en mode binaire "rb", une fois que tu charges des infos dans ta structure avec fread comme tu l'as fait, normalement les informations dans ta structure sont en clair !

Tu peux insérer depuis un GtkTextBuffer des informations gtk_text_buffer_insert mais il faut alors que tu récupère avant chaque insertion la position finale du curseur avec gtk_text_buffer_get_end_iter. Tu peux éventuellement essayer la fonction gtk_text_buffer_insert_at_cursor

Avec tout ca, n'oublie pas d'ajouter un saut de ligne à chaque fois que tu veux écrire une nouvelle ligne

[Lunixinclar]

fichier = fopen ("repp","r");
while (fread(temp,sizeof(bloc),1,fichier),!feof(fichier))
{
nom = temp->nom ;
prenom = temp->nom ;
tel = temp->nom ;
fputs(nom,texte);

Ouvrir le fichier en mode lecture non binaire puis faire un fputs c'est du n'importe quoi. Il faudrait apprendre le C avant d'entreprendre d'utiliser GTK+.

Le rapport entre char er gchar? Mieux vaut utiliser une fonction qui prend un gchar en argument rapport à la portabilité. En ce sens GTK se dissocie du C en lui ajoutant une plus-value.

[A_B]

Je vois pas ou est le probleme , la fonction que tu voit , marche tres bien en mode console (bien sure je n'ai pas inserer le fputs ) alors ou est le probleme stp pose moi une suggestion !
Merci ..

[Franck.H]

Je n'avais tilté tout de suite désolé mais dans ta strcutre tu à déclarer des pointeur sur gchar mais tu n'alloues que la structure elle même, non ses membres. Ce que je te conseil, c'est de déclarer des tableaux statiques à la place des pointeurs.

Voici un exemple (vite faire) de création/chargement d'un fichier écrit en format binaire et affichage dans un GtkTextView:

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
#include <gtk/gtk.h>
#include <glib.h>
#include <string.h>
#include <stdio.h>
 
 
#define REPERTOIRE "rep.data"
 
 
typedef struct
{
   gchar nom [40];
   gchar prenom [40];
   gchar telephone [20];
}
bloc;
 
 
/*
 * Fonctions mises en static car privees dans ce module de compilation,
 * a omettre si les fonctions doivent etres publiques !
 */
static gboolean enregistrer_personne (void)
{
   gboolean b_ret = TRUE;
   bloc personne = { "Dupont", "Francois", "0388885065" };
   FILE * p_file = fopen (REPERTOIRE, "wb");
 
   if (p_file != NULL)
   {
      size_t nbwrite = fwrite (& personne, sizeof (bloc), 1, p_file);
 
      if (nbwrite != 1)
      {
         b_ret = FALSE;
      }
 
      fclose (p_file);
   }
 
   return b_ret;
}
 
static void charger_personne (GtkTextView * p_txt)
{
   bloc personne;
   FILE * p_file = fopen (REPERTOIRE, "rb");
 
   if (p_file != NULL)
   {
      size_t nbread = fread (& personne, sizeof (bloc), 1, p_file);
 
      if (nbread == 1)
      {
         GtkTextBuffer * p_buf = gtk_text_view_get_buffer (p_txt);
 
         gtk_text_buffer_insert_at_cursor (
            p_buf, personne.nom, strlen (personne.nom)
         );
         gtk_text_buffer_insert_at_cursor (p_buf, "\n", 1);
         gtk_text_buffer_insert_at_cursor (
            p_buf, personne.prenom, strlen (personne.prenom)
         );
         gtk_text_buffer_insert_at_cursor (p_buf, "\n", 1);
         gtk_text_buffer_insert_at_cursor (
            p_buf, personne.telephone, strlen (personne.telephone)
         );
         gtk_text_buffer_insert_at_cursor (p_buf, "\n", 1);
      }
 
      fclose (p_file);
   }
}
 
 
int main (int argc, char ** argv)
{
   GtkWidget * p_win = NULL;
   GtkWidget * p_txt = NULL;
 
 
   gtk_init (& argc, & argv);
 
 
   p_win = gtk_window_new (GTK_WINDOW_TOPLEVEL);
   gtk_window_set_default_size (GTK_WINDOW (p_win), 300, 300);
 
   p_txt = gtk_text_view_new ();
   gtk_container_add (GTK_CONTAINER (p_win), p_txt);
 
   g_signal_connect (
      G_OBJECT (p_win),
      "destroy",
      G_CALLBACK (gtk_main_quit),
      NULL
   );
 
 
   /*
    * Enregistrement d'une personne dans un fichier en mode binaire:
    */
   if (enregistrer_personne ())
   {
      /*
       * Chargement du fichier cree precedement dans un GtkTextView:
       */
      charger_personne (GTK_TEXT_VIEW (p_txt));
   }
 
 
   gtk_widget_show_all (p_win);
   gtk_main ();
 
 
   return 0;
}

[A_B]

Merci c'est trés clairmais seulement pourquoi tu utilise :

Code :

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

size_t

Peut tu me l'expliquer stp ?

[Franck.H]

Merci c'est trés clairmais seulement pourquoi tu utilise :

Code :

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

size_t

Peut tu me l'expliquer stp ?

Hé bien c'est le type demandé par la fonction tout simplement, c'est un type utilisé en standard pour les longueurs (ex: strlen), tailles (ex: sizeof), index (ex: tab[i]) ... et d'ailleurs si tu regarde le prototype de la fonction fwrite ou fread:

Code :

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

1
2
3
size_t fread (void *ptr, size_t size, size_t nmemb, FILE *stream);
size_t fwrite (const void *ptr, size_t size, size_t nmemb, FILE *stream);

Tu ne peux que constater l'évidence même Il conviens de toujours respecter le type des arguments, ils sont spécifiés mais pas pour faire joli