la déclaration de variables en c

Version imprimable

31/12/2011, 15h05
daystar

la déclaration de variables en c

Bonsoir

S'il vous plait ,quelqu'un peux me dire c'est la déclaration de nouveaux variables en C au moment d'exécution est possible ou non :roll:
je doit appliquer cette idée dans mon application et je sais pas comment faire :cry:

merci d'avance.
31/12/2011, 15h18
Kirilenko

Bonjour,

Il faudrait nous donner un exemple précis, afin que nous puissions voir si ce que tu comptes faire est possible ou pas.
En l'état, la description de ton problème est un peu trop vague.

Bonne journée.
31/12/2011, 15h26
diogene

Je suppose que tu évoques l'allocation dynamique de variables (malloc()) mais évidemment, ceci doit être prévu au moment de la compilation du programme.
01/01/2012, 13h19
daystar

hi
est-ce qu'on peut donner la possibilité à l'utilisateur de choisir le type de variable au moment d'exécution ( je veux appliquer ça sur les files et les piles).....:calim2:
01/01/2012, 15h15
Kirilenko
Je ne sais pas si ce que tu dis est à proprement parler possible, mais tu peux toujours utiliser le pointeur générique void* afin de stocker une donnée de n'importe quel type.
Exemple de structure représentant une pile :
Code:

1 2 3 4 5 6 7 /* -- Stack -- */ typedef struct stack_s { /* stored data */ void *data; /* pointer which refer the previous element */ struct stack_s *prev; } stack_s;
Après, à toi de te débrouiller pour voir quel type de donnée l'utilisateur a choisi et entrer sa valeur dans le champ de la structure. :D
Tu trouveras quelques notes sur le pointeur générique ici.

Tu peux même imaginer une structure de stockage des données de ce type.

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
/* --- stack data structure --- */
 
/* data type */
typedef enum type_e { DATA_CHAR, DATA_INT, DATA_DOUBLE,
                      DATA_FLOAT, DATA_ERROR } type_e;
 
/* data structure */
typedef struct data_s {
  /* stored data */
  void *data;
  /* data type */
  type_e type;
} data_s;
 
/* stack data structure */
typedef struct stack_s {
  /* data */
  data_s *data;
  /* pointer which refers the previous element */
  struct stack_s *prev;
} stack_s;

salut

d'aprés votre suggestions voici les modifications que j'ai fait

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
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
#ifndef _file_h_
#define _file_h_
 
#include <stdlib.h>
 
//typedef int variant; /* remplacer int par le type de donnees a enfiler */
 
/*---------------- STRUCTURE DE FILE.C ---------------------------------------------*/
 
/*
  Structure :
  Nom	:	section
  Fct	:	structure definisssant une section d'elements de type "variant"
  */
/* data type */
typedef enum type_e { DATA_CHAR, DATA_INT, DATA_DOUBLE,
                      DATA_FLOAT, DATA_ERROR } type_e;
 
/* data structure */
typedef struct data_s {
  /* stored data */
  void *data;
  /* data type */
  type_e type;
} data_s;
 
 
typedef struct section
{
 /* data */
  data_s *data;
  struct section * suiv;  /* pointeur sur la section suivante */
  struct section * prec;  /* pointeur sur la section precedente */
} section_t;
 
/*
  Structure :
  Nom	:	file
  Fct	:	structure definissant une file d'elements de type "variant"
*/
 
typedef struct file
{
  int a;            /* indice de debut de la file : premier element a sortir */
  int b;            /* indice de fin de la file : dernier element a sortir */
  int pas;          /* nombre d'elements dans une section de file */
  section_t * tete; /* pointeur de tete de la file */
  section_t * sect;  /* pointeur sur la dernière section de la file */
} file_t;
 
 
/*---------------- FONCTIONS DE FILE.C ---------------------------------------------*/
 
/*
  Nom	:	vide
  Fct	:	retourne un booleen indiquant si la file est vide
  Entree	:	(f) adresse de la file
  Sortie	:	booleen indiquant que la file est vide
*/
 
unsigned short int vide(file_t * f);
 
/*
  Nom	:	init
  Fct	:	cree une nouvelle file et retourne son adresse
  Entree	:	(maxi) nombre maximal d'elements de la file
  Sortie	:	adresse de la nouvelle file
*/
 
file_t * init(int maxi);
 
/*
  Nom	:	enfile
  Fct	:	enfile un nouvel element sur la file
  Entree	:	(f) adresse de la file
			(x) element a rajouter
  Sortie	:	booleen indiquant que tout s'est bien passe
*/
 
void enfile(file_t * f, typedef x);
 
/*
  Nom	:	defile
  Fct	:	defile un element de la file et renvoie un booleen indiquant que tout s'est bien passe
  Entree	:	(f) adresse de la file
			(x) adresse de stockage de l'element defile
  Sortie	:	booleen indiquant que tout s'est bien passe
*/
 
unsigned short int defile(file_t * f, variant * x);
 
/*
Nom	:	supprime
Fct	:	libere toute la mémoire occupee par une file
Entree	:	(f) adresse de la file
*/
 
void supprime(file_t * f);
 
#endif

et puisque je connais pas bcp en c j'ai eu plusieurs erreur....povez vous m'orientez svp

06/01/2012, 09h19
hariman

Bonjour,

:tagcode:

Et poste un peu plus de détails sur les erreurs
06/01/2012, 11h30
daystar

par exemple

error : tow or more data types in declaartion of "t_file"
error : syntax error befor '*' token

and there are more:roll:
06/01/2012, 13h37
pythéas

Citation:

Envoyé par daystar

error : tow or more data types in declaartion of "t_file"
error : syntax error befor '*' token

Justement il n'y a pas du tout de "t_file" déclaré dans le code que tu présentes, pour localiser les problèmes tu pourrais essayer de faire une version expurgée qui passe à la compilation puis ajouter petit à petit les éléments dont tu as besoin.

Sinon cette erreur ressemble beaucoup à un point virgule oublié après l'accolade fermante d'une définition de struct.
06/01/2012, 16h09
Kirilenko

Il nous faudrait les lignes où se situent les erreurs pour pouvoir t'aider...
06/01/2012, 16h42
daystar

ils se sutuent a la ligne 40 pr l'erreur n°=1
la ligne 70 pr l'erreur n)=2
06/01/2012, 17h12
Kirilenko

Ligne 40, tu es sûr que c'est de ce fichier qu'il s'agit ?
06/01/2012, 17h15
daystar

oui j'en suis sur :roll:
06/01/2012, 19h11
Kirilenko

La ligne 40 est un commentaire, je me trompe.
06/01/2012, 22h11
daystar

hi again

le mem message s'affiche pr la ligne 50 (two or more data types in declaration of "file_t")............
07/01/2012, 10h31
Kirilenko

Comme l'a dit pythéas plus haut, cela ressemble à un oubli de point-virgule après une déclaration de structure ou d'énumération. Seulement, ici, je n'en vois pas.
De plus, chez moi, cela compile sans Warnings ni errreur...

je compile un projet qui contient le fichier.c suivant avec le fichichier .h
:oops: oui c'était ma faute j'ai pas bien éclairé les choses

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
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
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
#include "file.h"
 
#include <stdio.h>
#include <stdlib.h>
 
 
/*
  Nom	:	vide
  Fct	:	retourne un booleen indiquant si la file est vide
  Entree	:	(f) adresse de la file
  Sortie	:	booleen indiquant que la file est vide
*/
 
unsigned short int  vide(file_t * f)
{
  return ((f->a) == -1); /* la pile est vide si a=-1 */
}
 
/*
  Nom	:	init
  Fct	:	cree une nouvelle file et retourne son adresse
  Entree	:	(maxi) nombre maximal d'elements de la file
  Sortie	:	adresse de la nouvelle file
*/
 
file_t * init(int pas)
{
  file_t * adr_file=NULL; /* l'adresse de la file est NULL si l'allocation echoue */
 
  adr_file = (file_t *)malloc(sizeof(file_t)); /* adresse de la pile cree */
  if ( adr_file )
  {
    adr_file->a = -1;      /* aucun element dans la file */
    adr_file->b = -1;
    adr_file->pas = pas;  /* nombre maximal d'elements */
    adr_file->tete = NULL; /* la file est vide */
    adr_file->sect = NULL; /* la file est vide */
  }
 
  return adr_file;
}
 
/*
  Nom	:	enfile
  Fct	:	enfile un nouvel element sur la file
  Entree	:	(f) adresse de la file
			(x) element a rajouter
  Sortie	:	booleen indiquant que tout s'est bien passe
*/
 
void enfile(file_t * f, variant x)
{
//  unsigned short int succes = 0;
 
  if ( vide(f) ) /* si la file est vide */
  {
    f->tete = (section_t *)malloc(sizeof(section_t));             /* creation d'une premiere section */
    f->sect = f->tete;
    f->sect->tab = (variant *)malloc((f->pas) * sizeof(variant)); /* allocation de la premiere section */
    f->sect->suiv = NULL;                                         /* pas de section suivante */
    f->sect->prec = NULL;                                         /* pas de section precedente */
    f->a = 0;  /* le premier element est mis au debut du tableau */
    f->b = 0;  /* le dernier element est aussi le premier */
  }
  else
  {
    if( f->b == f->pas - 1 ) /* si la section est pleine */
    {
      f->sect->suiv = (section_t *)malloc(sizeof(section_t));       /* creation d'une nouvelle section */
      f->sect->suiv->prec = f->sect;                                /* maj section precedente */
      f->sect = f->sect->suiv;                                      /* maj derniere section */
      f->sect->tab = (variant *)malloc((f->pas) * sizeof(variant)); /* allocation de la derniere section */
      printf(" bibliothèque dynamique pour les files\n");
      f->sect->suiv = NULL;                                         /* pas de section suivante */
      f->b = 0;                                                     /* indice de fin a zero */
    }
    else
    {
      f->b = f->b + 1; /* incrementation de l'indice de fin */
    }
  }
  *(f->sect->tab + f->b) = x; /* rajout du nouvel element sur la file */
}
 
/*
  Nom	:	defile
  Fct	:	defile un element de la file et renvoie un booleen indiquant que tout s'est bien passe
  Entree	:	(f) adresse de la file
			(x) adresse de stockage de l'element defile
  Sortie	:	booleen indiquant que tout s'est bien passe
*/
 
unsigned short int defile(file_t * f, variant * x)
{
  unsigned short int succes = 0;
 
  if ( !vide(f) ) /* si la file n'est pas vide */
    {
      *x = *(f->tete->tab + f->a); /* sortie du premier element rajoute */
      if ( f->sect->prec != NULL ) /* s'il y a au moins deux sections */
      {
        if ( f->a != f->pas - 1 ) /* si la section ne doit pas disparaitre */
        {
          f->a = f->a + 1; /*incrementation de l'indice de debut*/
        }
        else
        {
          f->tete = f->tete->suiv; /* changement de la section de tete */
          free(f->tete->prec);     /* suppression de la section */
          f->tete->prec = NULL;    /* pas de section precedente */
          f->a = 0;                /* mise a zero de l'indice de debut */
        }
      }
      else
      {
        if ( f->a != f->b ) /* si la file comporte au moins deux elements */
        {
          f->a = f->a + 1; /* incrementation de l'indice de debut */
        }
        else
        {
          free(f->tete);  /* liberation de la section */
          f->sect = NULL; /* raz du pointeur de derniere section */
          f->a = -1;      /* maintenant la file est vide */
          f->b = -1;
        }
      }
      succes = 1; /* marquage de la reussite */
    }
 
  return succes;
}
 
/*
Nom	:	supprime
Fct	:	libere toute la memoire occupee par une file
Entree	:	(f) adresse de la file
*/
 
void supprime(file_t * f)
{
  section_t * cour = f->tete, * suiv;
  if ( cour != NULL )  /* s'il existe au moins une section */
  {
    suiv = f->tete->suiv;
    while ( cour != NULL )  /* tant qu'il reste des sections non supprimees */
    {
       suiv = cour->suiv;  /* progression du pointeur suivant */
       free(cour->tab);    /* liberation du contenu de la section courante */
       free(cour);         /* liberation de la section courante */
       cour = suiv;        /* progression du pointeur courant */
    }
  }
  free(f);  /* liberation de la structure pile */
}
 
void affiche(file_t * f){
section_t *courant;
int i;
courant=f->tete;
for (i=0;i<f->pas;++i){
    printf("%d",*courant->tab);
   // printf (" II ");
    courant = courant->suiv;
};
}
int SampleAddInt(int i1, int i2)
{
    return i1 + i2;
}
 
// A function doing nothing ;)
void SampleFunction1()
{
    // insert code here
}
 
// A function always returning zero
int SampleFunction2()
{
    // insert code here
 
    return 0;
}

07/01/2012, 11h29
Kirilenko

Je ne vois pas de déclaration de tab dans ta structure section...
07/01/2012, 15h44
diogene

Code:

void enfile(file_t * f, typedef x);

Que vient faire ce typedef au lieu du type de x ?

Erreur également pour les paramètres déclarés de type variant alors que variant n'est pas défini (la ligne de définition est en commentaires)
07/01/2012, 17h32
daystar

vous dites que c'est un problème du passage de paramètres , j'ai remplacé le type ''variant" par "data_s" mais ça marche pas aussi....je pense que c'est a cause de nbre de paramètres de la structure data_s...........
07/01/2012, 19h05
diogene

Si tu donnais le véritable code complet que tu essayes de compiler (par un copier/coller), on pourrait constater nous-mêmes les erreurs en cause et on gagnerait du temps !
08/01/2012, 12h31
daystar

Citation:

Envoyé par diogene

Si tu donnais le véritable code complet que tu essayes de compiler (par un copier/coller), on pourrait constater nous-mêmes les erreurs en cause et on gagnerait du temps !

je suis entraine de créer une bibliothèque dynamique des files en donnant la possibilité au utilisateur de choisir le type qu'il veut, j'ai donné le fichier .c et .h du projet sur le forum...

je remercie de votre intérêt
08/01/2012, 16h36
diogene

Les messages d'erreur que tu signales ne correspondent pas au code que tu as présenté

je récris le code
le fichier .h

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
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
#ifndef _file_h_
#define _file_h_
 
#include <stdlib.h>
 
/*typedef int variant;  remplacer int par le type de donnees a enfiler */
 
/*---------------- STRUCTURE DE FILE.C ---------------------------------------------*/
 
/*
  Structure :
  Nom	:	section
  Fct	:	structure definisssant une section d'elements de type "variant"
  */
/* data type */
typedef enum type_e { DATA_CHAR, DATA_INT, DATA_DOUBLE,
                      DATA_FLOAT, DATA_ERROR } type_e;
 
/* data structure */
 
typedef struct data_s {
  /* stored data */
  void *data;
  /* data type */
  type_e type;
} data_s;
 
 
typedef struct section
{
  data_s * tab;           /* tableau representant la section proprement dite */
  struct section * suiv;  /* pointeur sur la section suivante */
  struct section * prec;  /* pointeur sur la section precedente */
} section_t;
 
 
/*
  Structure :
  Nom	:	file
  Fct	:	structure definissant une file d'elements de type "variant"
*/
 
void  struct file
{
  int a;            /* indice de debut de la file : premier element a sortir*/
  int b;            /* indice de fin de la file : dernier element a sortir*/
  int pas;          /* nombre d'elements dans une section de file*/
  section_t * tete; /* pointeur de tete de la file*/
  section_t * sect;  /* pointeur sur la dernière section de la file*/
} file_t;
}
/*---------------- FONCTIONS DE FILE.C ---------------------------------------------*/
 
/*
  Nom	:	vide
  Fct	:	retourne un booleen indiquant si la file est vide
  Entree	:	(f) adresse de la file
  Sortie	:	booleen indiquant que la file est vide
*/
 
unsigned short int vide(file_t * f);
 
/*
  Nom	:	init
  Fct	:	cree une nouvelle file et retourne son adresse
  Entree	:	(maxi) nombre maximal d'elements de la file
  Sortie	:	adresse de la nouvelle file
*/
 
void * init(int maxi);
 
/*
  Nom	:	enfile
  Fct	:	enfile un nouvel element sur la file
  Entree	:	(f) adresse de la file
			(x) element a rajouter
  Sortie	:	booleen indiquant que tout s'est bien passe
*/
 
void enfile(file_t * f, typedef x);
 
/*
  Nom	:	defile
  Fct	:	defile un element de la file et renvoie un booleen indiquant que tout s'est bien passe
  Entree	:	(f) adresse de la file
			(x) adresse de stockage de l'element defile
  Sortie	:	booleen indiquant que tout s'est bien passe
*/
 
unsigned short int defile(file_t * f, variant * x);
 
/*
Nom	:	supprime
Fct	:	libere toute la mémoire occupee par une file
Entree	:	(f) adresse de la file
*/
 
void supprime(file_t * f);
 
#endif

et voici le fichier.c

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
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
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
#include "file.h"
 
#include <stdio.h>
#include <stdlib.h>
 
 
/*
  Nom	:	vide
  Fct	:	retourne un booleen indiquant si la file est vide
  Entree	:	(f) adresse de la file
  Sortie	:	booleen indiquant que la file est vide
*/
 
void  vide(file_t * f)
{
  return ((f->a) == -1); /* la pile est vide si a=-1 */
}
 
/*
  Nom	:	init
  Fct	:	cree une nouvelle file et retourne son adresse
  Entree	:	(maxi) nombre maximal d'elements de la file
  Sortie	:	adresse de la nouvelle file
*/
 
file_t * init(int pas)
{
  file_t * adr_file=NULL; /* l'adresse de la file est NULL si l'allocation echoue */
 
  adr_file = (file_t *)malloc(sizeof(file_t)); /* adresse de la pile cree */
  if ( adr_file )
  {
    adr_file->a = -1;      /* aucun element dans la file */
    adr_file->b = -1;
    adr_file->pas = pas;  /* nombre maximal d'elements */
    adr_file->tete = NULL; /* la file est vide */
    adr_file->sect = NULL; /* la file est vide */
  }
 
  return adr_file;
}
 
/*
  Nom	:	enfile
  Fct	:	enfile un nouvel element sur la file
  Entree	:	(f) adresse de la file
			(x) element a rajouter
  Sortie	:	booleen indiquant que tout s'est bien passe
*/
 
 
void enfile(file_t * f, data_s * x)
{
  unsigned short int succes = 0;
 
  if ( vide(f) ) /* si la file est vide */
  {
    f->tete = (section_t *)malloc(sizeof(section_t));             /* creation d'une premiere section */
    f->sect = f->tete;
    f->sect->tab = (data_s *)malloc((f->pas) * sizeof(data_s)); /* allocation de la premiere section */
    f->sect->suiv = NULL;                                         /* pas de section suivante */
    f->sect->prec = NULL;                                         /* pas de section precedente */
    f->a = 0;  /* le premier element est mis au debut du tableau */
    f->b = 0;  /* le dernier element est aussi le premier */
  }
  else
  {
    if( f->b == f->pas - 1 ) /* si la section est pleine */
    {
      f->sect->suiv = (section_t *)malloc(sizeof(section_t));       /* creation d'une nouvelle section */
      f->sect->suiv->prec = f->sect;                                /* maj section precedente */
      f->sect = f->sect->suiv;                                      /* maj derniere section */
      f->sect->tab = (data_s *)malloc((f->pas) * sizeof(data_s)); /* allocation de la derniere section */
      f->sect->suiv = NULL;                                         /* pas de section suivante */
      f->b = 0;                                                     /* indice de fin a zero */
    }
    else
    {
      f->b = f->b + 1; /* incrementation de l'indice de fin */
    }
  }
  *(f->sect->tab + f->b) = x; /* rajout du nouvel element sur la file */
}
 
/*
  Nom	:	defile
  Fct	:	defile un element de la file et renvoie un booleen indiquant que tout s'est bien passe
  Entree	:	(f) adresse de la file
			(x) adresse de stockage de l'element defile
  Sortie	:	booleen indiquant que tout s'est bien passe
*/
 
unsigned short int defile(file_t * f, data_s * x)
{
  unsigned short int succes = 0;
 
  if ( !vide(f) ) /* si la file n'est pas vide */
    {
      *x = *(f->tete->tab + f->a); /* sortie du premier element rajoute */
      if ( f->sect->prec != NULL ) /* s'il y a au moins deux sections */
      {
        if ( f->a != f->pas - 1 ) /* si la section ne doit pas disparaitre */
        {
          f->a = f->a + 1; /*incrementation de l'indice de debut*/
        }
        else
        {
          f->tete = f->tete->suiv; /* changement de la section de tete */
          free(f->tete->prec);     /* suppression de la section */
          f->tete->prec = NULL;    /* pas de section precedente */
          f->a = 0;                /* mise a zero de l'indice de debut */
        }
      }
      else
      {
        if ( f->a != f->b ) /* si la file comporte au moins deux elements */
        {
          f->a = f->a + 1; /* incrementation de l'indice de debut */
        }
        else
        {
          free(f->tete);  /* liberation de la section */
          f->sect = NULL; /* raz du pointeur de derniere section */
          f->a = -1;      /* maintenant la file est vide */
          f->b = -1;
        }
      }
      succes = 1; /* marquage de la reussite */
    }
 
  return succes;
}
 
/*
Nom	:	supprime
Fct	:	libere toute la memoire occupee par une file
Entree	:	(f) adresse de la file
*/
 
void supprime(file_t * f)
{
  section_t * cour = f->tete, * suiv;
  if ( cour != NULL )  /* s'il existe au moins une section */
  {
    suiv = f->tete->suiv;
    while ( cour != NULL )  /* tant qu'il reste des sections non supprimees */
    {
       suiv = cour->suiv;  /* progression du pointeur suivant */
       free(cour->tab);    /* liberation du contenu de la section courante */
       free(cour);         /* liberation de la section courante */
       cour = suiv;        /* progression du pointeur courant */
    }
  }
  free(f);  /* liberation de la structure pile */
}
// The functions contained in this file are pretty dummy
// and are included only as a placeholder. Nevertheless,
// they *will* get included in the shared library if you
// don't remove them :)
//
// Obviously, you 'll have to write yourself the super-duper
// functions to include in the resulting library...
// Also, it's not necessary to write every function in this file.
// Feel free to add more files in this project. They will be
// included in the resulting library.
 
// A function adding two integers and returning the result
int SampleAddInt(int i1, int i2)
{
    return i1 + i2;
}
 
// A function doing nothing ;)
void SampleFunction1()
{
    // insert code here
}
 
// A function always returning zero
int SampleFunction2()
{
    // insert code here
 
    return 0;
}

et je rassure q je reçoit les ereures que j'ai cité avant

09/01/2012, 01h29
pythéas
Citation:

Envoyé par daystar

je récris le code

Ben pas tout à fait, il y a des choses nouvelles par exemple :
Citation:
Envoyé par daystar

Code:

1 2 void struct file
Ça ça me dit rien qui vaille pourquoi un bon vieux typedef?
09/01/2012, 01h48
edgarjacobs

Hello,

Si je vois bien, ligne 51 de fichier.h, il y a une accolade fermante en trop.
Simple erreur en déposant le code, peut-être?
10/01/2012, 15h34
daystar

Quelqu'un peut-il envisager sérieusement et aide-moi 8O
11/01/2012, 11h46
Bousk
Peut-être qu'envisager une formation initiale du langage serait un début :idea:
ou en tous cas pousser la formation.

A part du code pas très joli, des messages d'erreur non concordant et qui semblent basiques, le sujet est un peu vide..

Pour avoir des "types dynamiques" au choix de l'utilisateur, la solution en première page me semble pas farfelue
Code:

1 2 3 4 5 typedef enum type_e { TYPE_CHAR, TYPE_INT, /*...*/ } typedef struct _datas_s { void* datas; type_e type; } datas_s;
type servant à identifier le type réel contenu dans la structure, un simple cast suffira par la suite à récupérer la valeur au bon format, pourquoi pas sur un switch

Bon après je ne vais pas réécrire toutes les fonctions de manipulation qui peuvent être utile ou envisageables, mais si l'une bloque tu peux revenir vers nous.
13/01/2012, 21h53
daystar

t'as raison il me reste bcp de choses à apprendre :oops:

Je me soucie plus de ce sujet que l'utilisateur peut choisir le type qu'il veut

d'aprés ce que j'ai lu que le cast " fonctionne aussi bien pour les types natifs (int, double, etc ...) que pour les classes et les structures."

j'ai pas compris ce que tu veut dire par
"type servant a identifié le type réel " !!
"par un switch"!!

Bon, tu as dans ta structure une variable qui est pointée par un pointeur de type void*. Par conséquent, il t'est impossible de deviner le vrai type de stockage de ta variable (si c'est un caractère, donc char, si c'est un entier, donc int, un nombre à virgule, donc double/float, etc.). La syntaxe que je t'avais proposée, est, bien que pas optimisée (normalement cela révèle de quelques défauts de conception, mais c'est peut-être l'occasion pour toi de comprendre certaines choses), d'indiquer le type réel de ta variable par une autre variable, comprise dans une énumération :

Code:

TYPE_CHAR, TYPE_INT /* etc */

Après, à toi de voir quel est le type de la variable stockée et donc de récupérer le type de la variable, de le « convertir » en une de ces constantes d'énumération, et de le stocker aux côtés de ton pointeur dans ta pile (j'ai cru comprendre que tu essayais plutôt de faire une file, mais ça revient au même pour nous).

Le switch, ici, pourrait nous permettre, si tu cherchais à afficher ta file, de séparer en plusieurs cas, selon le type réel de ta variable (indiquée par la variable de type type_e), de « caster » (effectuer un changement type volontaire et temporel) ton pointeur générique en un des types natifs, selon le cas du switch dans lequel tu te trouves. Exemple de squelette :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 void print_data(data_s *data) { switch(data->type) { case TYPE_INT: /* afficher ta donnée comme un INT */ break; case TYPE_CHAR: /* afficher ta donnée comme un CHAR */ /* etc, etc */ default: break; } }

d'aprés vous que la variable data doit avoir un type
je l'affecte le type variant ''int"

mais je peux rien faire d'autre ou appliquer ce cast avant q je régle les erreurs surtous celle qui se cache derière ce message
" ligne 50 :error :two or more data types in declaration of t_file "
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 typedef int variant; /*remplacer int par le type de donnees a enfiler */ /*---------------- STRUCTURE DE FILE.C ---------------------------------------------*/ /* Structure : Nom : section Fct : structure definisssant une section d'elements de type "variant" */ /* data type */ typedef enum type_e { DATA_CHAR, DATA_INT, DATA_DOUBLE, DATA_FLOAT, DATA_ERROR } type_e; /* data structure */ typedef struct data_s { /* stored data */ variant * data; /* data type */ type_e type; } data_s;

14/01/2012, 11h33
Kirilenko

Bon.

- poste tout ton code ;
- indique dans quel fichier se situe cette erreur qui pointe la ligne 50.

Ensuite, si tu fonctionnes comme ça, tu peux virer l'énumération, parce que tu sais à l'avance que ta variable sera de type int.

voici le code de fichier.h

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
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
#ifndef _file_h_
#define _file_h_

#include <stdlib.h>

typedef int variant;  /*remplacer int par le type de donnees a enfiler */

/*---------------- STRUCTURE DE FILE.C ---------------------------------------------*/

/*
  Structure :
  Nom	:	section
  Fct	:	structure definisssant une section d'elements de type "variant"
  */
/* data type */
typedef enum type_e { DATA_CHAR, DATA_INT, DATA_DOUBLE,
                      DATA_FLOAT, DATA_ERROR } type_e;

/* data structure */

typedef struct data_s {
  /* stored data */
  variant * data;
  /* data type */
  type_e type;
} data_s;


typedef struct section
{
  data_s * tab;           /* tableau representant la section proprement dite */
  struct section * suiv;  /* pointeur sur la section suivante */
  struct section * prec;  /* pointeur sur la section precedente */
} section_t;


/*
  Structure :
  Nom	:	file
  Fct	:	structure definissant une file d'elements de type "variant"
*/

void  struct file
{
  int a;            /* indice de debut de la file : premier element a sortir*/
  int b;            /* indice de fin de la file : dernier element a sortir*/
  int pas;          /* nombre d'elements dans une section de file*/
  section_t * tete; /* pointeur de tete de la file*/
  section_t * sect;  /* pointeur sur la dernière section de la file*/
} file_t; /*ligne 50*/

/*---------------- FONCTIONS DE FILE.C ---------------------------------------------*/

/*
  Nom	:	vide
  Fct	:	retourne un booleen indiquant si la file est vide
  Entree	:	(f) adresse de la file
  Sortie	:	booleen indiquant que la file est vide
*/

unsigned short int vide(file_t * f);

/*
  Nom	:	init
  Fct	:	cree une nouvelle file et retourne son adresse
  Entree	:	(maxi) nombre maximal d'elements de la file
  Sortie	:	adresse de la nouvelle file
*/

void * init(int maxi);

/*
  Nom	:	enfile
  Fct	:	enfile un nouvel element sur la file
  Entree	:	(f) adresse de la file
			(x) element a rajouter
  Sortie	:	booleen indiquant que tout s'est bien passe
*/

void enfile(file_t * f, typedef x);

/*
  Nom	:	defile
  Fct	:	defile un element de la file et renvoie un booleen indiquant que tout s'est bien passe
  Entree	:	(f) adresse de la file
			(x) adresse de stockage de l'element defile
  Sortie	:	booleen indiquant que tout s'est bien passe
*/

unsigned short int defile(file_t * f, variant * x);

/*
Nom	:	supprime
Fct	:	libere toute la mémoire occupee par une file
Entree	:	(f) adresse de la file
*/

void supprime(file_t * f);

#endif

et le fichier .c du projet

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
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
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
#include "file.h"
 
#include <stdio.h>
#include <stdlib.h>
 
 
/*
  Nom	:	vide
  Fct	:	retourne un booleen indiquant si la file est vide
  Entree	:	(f) adresse de la file
  Sortie	:	booleen indiquant que la file est vide
*/
 
void  vide(file_t * f)
{
  return ((f->a) == -1); /* la pile est vide si a=-1 */
}
 
/*
  Nom	:	init
  Fct	:	cree une nouvelle file et retourne son adresse
  Entree	:	(maxi) nombre maximal d'elements de la file
  Sortie	:	adresse de la nouvelle file
*/
 
file_t * init(int pas)
{
  file_t * adr_file=NULL; /* l'adresse de la file est NULL si l'allocation echoue */
 
  adr_file = (file_t *)malloc(sizeof(file_t)); /* adresse de la pile cree */
  if ( adr_file )
  {
    adr_file->a = -1;      /* aucun element dans la file */
    adr_file->b = -1;
    adr_file->pas = pas;  /* nombre maximal d'elements */
    adr_file->tete = NULL; /* la file est vide */
    adr_file->sect = NULL; /* la file est vide */
  }
 
  return adr_file;
}
 
/*
  Nom	:	enfile
  Fct	:	enfile un nouvel element sur la file
  Entree	:	(f) adresse de la file
			(x) element a rajouter
  Sortie	:	booleen indiquant que tout s'est bien passe
*/
 
 
void enfile(file_t * f, data_s * x)
{
  unsigned short int succes = 0;
 
  if ( vide(f) ) /* si la file est vide */
  {
    f->tete = (section_t *)malloc(sizeof(section_t));             /* creation d'une premiere section */
    f->sect = f->tete;
    f->sect->tab = (data_s *)malloc((f->pas) * sizeof(data_s)); /* allocation de la premiere section */
    f->sect->suiv = NULL;                                         /* pas de section suivante */
    f->sect->prec = NULL;                                         /* pas de section precedente */
    f->a = 0;  /* le premier element est mis au debut du tableau */
    f->b = 0;  /* le dernier element est aussi le premier */
  }
  else
  {
    if( f->b == f->pas - 1 ) /* si la section est pleine */
    {
      f->sect->suiv = (section_t *)malloc(sizeof(section_t));       /* creation d'une nouvelle section */
      f->sect->suiv->prec = f->sect;                                /* maj section precedente */
      f->sect = f->sect->suiv;                                      /* maj derniere section */
      f->sect->tab = (data_s *)malloc((f->pas) * sizeof(data_s)); /* allocation de la derniere section */
      f->sect->suiv = NULL;                                         /* pas de section suivante */
      f->b = 0;                                                     /* indice de fin a zero */
    }
    else
    {
      f->b = f->b + 1; /* incrementation de l'indice de fin */
    }
  }
  *(f->sect->tab + f->b) = x; /* rajout du nouvel element sur la file */
}
 
/*
  Nom	:	defile
  Fct	:	defile un element de la file et renvoie un booleen indiquant que tout s'est bien passe
  Entree	:	(f) adresse de la file
			(x) adresse de stockage de l'element defile
  Sortie	:	booleen indiquant que tout s'est bien passe
*/
 
unsigned short int defile(file_t * f, data_s * x)
{
  unsigned short int succes = 0;
 
  if ( !vide(f) ) /* si la file n'est pas vide */
    {
      *x = *(f->tete->tab + f->a); /* sortie du premier element rajoute */
      if ( f->sect->prec != NULL ) /* s'il y a au moins deux sections */
      {
        if ( f->a != f->pas - 1 ) /* si la section ne doit pas disparaitre */
        {
          f->a = f->a + 1; /*incrementation de l'indice de debut*/
        }
        else
        {
          f->tete = f->tete->suiv; /* changement de la section de tete */
          free(f->tete->prec);     /* suppression de la section */
          f->tete->prec = NULL;    /* pas de section precedente */
          f->a = 0;                /* mise a zero de l'indice de debut */
        }
      }
      else
      {
        if ( f->a != f->b ) /* si la file comporte au moins deux elements */
        {
          f->a = f->a + 1; /* incrementation de l'indice de debut */
        }
        else
        {
          free(f->tete);  /* liberation de la section */
          f->sect = NULL; /* raz du pointeur de derniere section */
          f->a = -1;      /* maintenant la file est vide */
          f->b = -1;
        }
      }
      succes = 1; /* marquage de la reussite */
    }
 
  return succes;
}
 
/*
Nom	:	supprime
Fct	:	libere toute la memoire occupee par une file
Entree	:	(f) adresse de la file
*/
 
void supprime(file_t * f)
{
  section_t * cour = f->tete, * suiv;
  if ( cour != NULL )  /* s'il existe au moins une section */
  {
    suiv = f->tete->suiv;
    while ( cour != NULL )  /* tant qu'il reste des sections non supprimees */
    {
       suiv = cour->suiv;  /* progression du pointeur suivant */
       free(cour->tab);    /* liberation du contenu de la section courante */
       free(cour);         /* liberation de la section courante */
       cour = suiv;        /* progression du pointeur courant */
    }
  }
  free(f);  /* liberation de la structure pile */
}
// The functions contained in this file are pretty dummy
// and are included only as a placeholder. Nevertheless,
// they *will* get included in the shared library if you
// don't remove them :)
//
// Obviously, you 'll have to write yourself the super-duper
// functions to include in the resulting library...
// Also, it's not necessary to write every function in this file.
// Feel free to add more files in this project. They will be
// included in the resulting library.
 
// A function adding two integers and returning the result
int SampleAddInt(int i1, int i2)
{
    return i1 + i2;
}
 
// A function doing nothing ;)
void SampleFunction1()
{
    // insert code here
}
 
// A function always returning zero
int SampleFunction2()
{
    // insert code here
 
    return 0;
}

14/01/2012, 12h01
Kirilenko

Bon, déjà, il y a un problème (d'ailleurs il me semble avoir vu cette même remarque à la page précédente... :aie:) : il n'y a aucune déclaration ni même allusion de t_file dans ce code. Alors, soit tu as fait une erreur en recopiant l'erreur, soit tu ne compiles pas le bon fichier...

Citation:
Envoyé par daystar
Code:

1 2 3 4 5 6 7 8 void struct file { int a; /* indice de debut de la file : premier element a sortir*/ int b; /* indice de fin de la file : dernier element a sortir*/ int pas; /* nombre d'elements dans une section de file*/ section_t * tete; /* pointeur de tete de la file*/ section_t * sect; /* pointeur sur la dernière section de la file*/ } file_t; /*ligne 50*/
Salut

En dehors de toutes les pertinentes remarques que les autres membres de la section C t'ont indiquées (et que manifestement tu sembles ne pas lire avec la concentration qui devrait s'y associer), la syntaxe void struct X {...} file_t ne veut absolument rien dire (de cohérent). Une structure n'est pas typée par un élément d'un type standard comme int, char, float ou void...

Citation:

Envoyé par daystar

vous dites que c'est un problème du passage de paramètres

Ouais non. Ils ont dit ça car ils pensaient que tu avais le niveau adéquat pour t'attaquer à la manipulation de structures et l'implémentation de listes chainées. Or il semblerait que tu n'en sois pas encore là dans ton apprentissage du langage. Donc peut-être qu'il y a un problème (minime) de paramètres mais le vrai problème se situe bien plus en profondeur...

14/01/2012, 16h33
daystar

Citation:

Envoyé par Kirilenko

il n'y a aucune déclaration ni même allusion de t_file dans ce code. .

Je ne sais pas pourquoi je répète cette erreur à chaque fois j'ai voulu dire "file_t";

Je pense que je doit s'arrêter là
Il me semblait un sujet facile qui ne nécessite que quelques modifications pour un code déja écrit
J'ai pas trouvé la réponce que je cherche , mais je savais les bases qui doivent être maîtrisées

Je remercie tous ceux qui ont contribué à ce sujet et intéressés à m'aider
14/01/2012, 16h36
dafpp

Dis donc, on abandonne vite.