Discussion :

[acacia]

La fonction InsererA:

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
void InsererA(struct liste_events * const liste, float val)
{
 
float t=val;
float h=6+rand()%18;
float    x = h *(b1 - a1) + a1;
float    Tarr = t + x;
Insertion(liste, EVT_A, Tarr);
int q;
++q;
int qmax;
if (q > qmax)
  {
      qmax = q;
  }
 
bool serveur_libre;
  if (serveur_libre)
  {
      Inserer(liste, EVT_S, t);
  }
 
 
}

[Médinoc]

q, qmax et serveur_libre ne servent à rien dans la fonction telle que tu l'as écrite.
En les ignorant, ça donnerait ceci:

Code C :

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

1
2
3
4
5
6
7
8
void InsererA(struct liste_events * const liste, float val)
{
	float t=val;
	float h=(float)( 6 + rand()%18 );
	float x = h *(b1 - a1) + a1;
	float Tarr = t + x;
	Insertion(liste, EVT_A, Tarr);
}

Ensuite, il faut voir exactement ce que sont supposées faire les fonctions.
Car si une fonction appelée InsererA() insère un S en plus du A, c'est qu'il y a un problème: Il faudra soit changer le code, soit renommer la fonction...

[acacia]

voici ce que donne le code maintenant:

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
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
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
 
 
//#include <stdbool.h>
typedef enum e_bool { false=0, true } bool;
 
#define a1 6
#define b1 24
#define a2 10
#define b2 16
 
typedef enum {EVT_A, EVT_S, EVT_D} type;
 
struct chainon_event
{
	type event_type;
	float event_time;
	struct chainon_event *pNext;
};
 
struct liste_events
{
	struct chainon_event *pTete;
};
 
 
struct chainon_event *ExtrairePremier(struct liste_events * const pListe)
{
	struct chainon_event *pRet = NULL;
 
	/*  test la validite du parametre */
	if (pListe->pTete != NULL)
	{
		struct chainon_event *p;
 
		p = pListe->pTete;
		if (p == NULL)
		{
			printf("liste vide\n");
		}
		else
		{
			pListe->pTete = p->pNext;
			pRet = p;
			printf("l'evennement extrait est: ");
			/* on force l'affichage */
			fflush(stdout);
		}
	}
 
	return pRet;
}
 
/*  purge le tampon du flux d'entree standard  */
void purger(void)
{
	int c;
	while ((c = fgetc(stdin)) != '\n' && c != EOF)
	{ }
}
 
void pause(char const * const message)
{
	if (message != NULL)
	{
		printf("%s", message);
		fflush(stdout);
	}
	purger();
}
 
struct chainon_event * CreerEvent(char tp, float val)
{
	struct chainon_event *pEvent = malloc(sizeof *pEvent);
	if (pEvent != NULL)
	{
		pEvent->event_type = tp;
		pEvent->event_time = val;
	}
	return pEvent;
}
 
void Inserer(struct liste_events * const pListe, char tp, float val)
{
	/*  programmation defensive: on s'assure de la validite des parametres */
	if (pListe != NULL)
	{
		struct chainon_event * const pEvent = CreerEvent(tp, val);
		/*  tester si l'allocation a reussi */
		if (pEvent != NULL)
		{
			/*  on se place au debut de la liste */
			struct chainon_event *pt1 = NULL;
			struct chainon_event *pt2 = pListe->pTete;
			/*  on parcourt toute la liste */
			while (pt2 != NULL)
			{
				pt1 = pt2;
				pt2 = pt2->pNext;
				/* Il manque un test ici pour sortir de la liste avant la fin
				   Ce test sera sans doute sur event_time... */
			}
 
			if (pt2 == pListe->pTete)
			{
				pListe->pTete = pEvent;
			}
			else
			{
				pt1->pNext = pEvent;
			}
			pEvent->pNext = pt2;
		}
	}
}
 
 
void affichage(struct chainon_event const * const pcTete)
{
	/* pas d'affichage, la liste est vide */
	if (pcTete != NULL)
	{
		struct chainon_event const * pcCourant = pcTete;
		while (pcCourant != NULL)
		{
			printf(" le type de l'evennement est: %c\n", pcCourant->event_type);
			printf(" le temps de l'evennement est: %f\n", pcCourant->event_time);
 
			pcCourant = pcCourant->pNext;
		}
	}
}
 
 
void InsererA(struct liste_events * const liste, float val)
{
 
float t=val;
float h=6+rand()%18;
float    x = h *(b1 - a1) + a1;
float    Tarr = t + x;
Inserer(liste, EVT_A, Tarr);
int q;
++q;
int qmax;
if (q > qmax)
  {
      qmax = q;
  }
 
bool serveur_libre;
  if (serveur_libre)
  {
      Inserer(liste, EVT_S, t);
  }
 
 
}
 
 
void InsererS(struct liste_events * const liste, float val)
{
 
    float Tinact = 0;
    struct list_event *event;
    bool serveur_libre = false;
    int q = q - 1;
 
 
    float t = val;
 
    float h=10+rand()%6;
    float x = h *(b2 - a2) + a2;
 
    float Tdep = t + x;
    Inserer(liste, EVT_S, Tdep);
 
    float Totinact;
 
    Tinact=rand()%1;
 
    if (t-Tinact != 0)
    {
        Totinact = Totinact + (t- Tinact);
    }
}
 
 
void InsererD(struct liste_events * const liste, float val)
{
 
 
    float Tinact;
    bool serveur_libre;
    int Nclient=0;
    int q = 0;
 
   float t = val;
    serveur_libre = true;
 
    Tinact = t;
    Nclient = Nclient + 1;
    if (q != 0)
    {
        Inserer(liste, EVT_D, t);
    }
}
 
int menu(void)
{
    int choix = 0;
    int rv = 0;
 
 
 
    printf("**********GESTION DE LA LISTE**********\n");
    printf(" 1-Inserer un nouvel evennement\n");
    printf(" (a) pour une nouvelle arrivee\n");
    printf(" (s) pour debuter le service\n");
    printf(" (d) pour depart\n");
    printf(" 2-Extraire un evennement\n");
    printf(" 3-Afficher le contenu\n");
    printf(" 4-EXIT\n");
    do
    {
        printf(" Faites votre choix: ");
	/* forcer l'affichage*/
        fflush(stdout);
        rv = scanf("%d", &choix);
 
        purger();
    }
    while (rv != 1 || choix < 1 || choix > 4);
 
 
    return choix;
}
 
int main(void)
{
    bool serveur_libre = true;
 
	struct liste_events liste = { NULL };
 
 
	bool sortie = 0;
	while (!sortie)
	{
		while (!sortie)
		{
			int const choix = menu();
			float val = 0.0;
			char tp = 0;
			int scanned;
 
			switch (choix)
			{
			case 1:
				printf(" entrez le type de l'evenement: ");
				fflush(stdout);
				scanned = scanf("%c",&tp);
				purger();
				if(scanned != 1)
				{
					puts("Erreur.");
					break;
				}
 
				printf(" entrez le temps de l'evenement: ");
				fflush(stdout);
				scanned = scanf("%f", &val);
				purger();
				if(scanned != 1)
				{
					puts("Erreur.");
					break;
				}
 
				if (tp == 'a')
				{
					InsererA(&liste, val);
				}
				else if (tp == 's')
				{
					InsererS(&liste, val);
				}
				else if (tp == 'd')
				{
					InsererD(&liste, val);;
				}
				break;
 
			case 2:
				{
				struct chainon_event *pExtrait = ExtrairePremier(&liste);
				affichage(pExtrait);
				free(pExtrait);
				}
				break;
 
			case 3:
				affichage(liste.pTete);
				pause("Appuyez sur ENTER pour revenir au menu...");
				break;
 
			case 4:
				/*  4 est un choix valide qui signifie quitter */
				sortie = true;
				break;
 
			default:
				printf(" choix inexistant\n");
				break;
			}
		}
		/* Ce return 0; doit être hors du while */
	}
	return 0;
}

au fait le clrscr() ne marche pas avec mon code::blocks même après avoir téléchargé conio.h et ajouté conio.a

je ne comprends plus mon programme maintenant je ne sais plus ce qui s'exécute

[Médinoc]

1. On se moque de clrscr().
2. Si ça compile chez toi avec stdbool, tu peux remettre l'enum bool en commentaire et remettre stdbool.h en normal. Ça ne compile pas chez moi car j'ai Visual.
3. InsererA() insède un A et un S. Est-ce normal ?
4. Les variables q, qmax et serveur_libre ne sont pas initialisées dans InsérerA(). Tu devras sans doure les prendre en paramètre, et q devra sans doute être passé par un pointeur.
5. Totinact n'est pas initilaisé dans InsérerS(), et apparemment lui aussi nécessitera un pointeur.
6. InsererD() n'appellera jamais Inserer(), puisque q sera toujours à zéro. Il faudra sans doute qu'il soit passé en paramètre par un pointeur.

Ce qui nous donne plusieurs variables qu'il faut passer en paramètres aux fonctions:

• qmax, à passer par valeur.
• q, à passer par pointeur.
• serveur_libre, à passer par pointeur.
• totinact, à passer par pointeur.
• Et peut-être tinact à passer par pointeur aussi, je ne sais pas trop à quoi il sert.
• NClient aussi à passer par pointeur apparemment.

[fremen167]

Acacia,

Tous les points d'interrogation de Médinoc montrent une chose : on a du mal à savoir ce que tu veux faire exactement.

Il serait peut être mieux de commencer par le commencement, non ?

[acacia]

Merci beaucoup médinoc et merci à vous tous

ce que je veux faire moi c'est une simulation d'une file d'attente avec un seul serveur chez un médecin

les patients arrivent suivant une loi uniforme (6, 24)
la durée varie d'un patient à un autre et suit la même loi (10, 16)

je dois déterminer le temps total d'incativité pendant une journée de 7heure de travail, le nombre de malade qui ont été examinés sans faire de queue, le max de personne dans la file d'attente et le nombre restant en attente après expiration du temps.

voici ce que je devais faire, et surtout, ce que je n'ai pas fait

j'avais fait une fonction initialisation, qui ne m'a servi à rien du tout

dans la fonction InsererA(..) il y a aussi la fonction InsererS(..) pour dire que quand le serveur est libre, le doc commence l'auscultation.

le Tinact et le temps des inter arrivés et le temps de consultation se génère aléatoirement avec la fonction rand()

[Médinoc]

OK, alors tu ne dois pas faire ainsi.

Je te conseille de dérouler la loi d'arrivée des patients, en remplissant la file au fur et à mesure, jusqu'à ce que les sept heures soient atteintes.

Ensuite, tu n'as plus qu'à faire traiter la file par le médecin.

Donc, tout ce que la file a à contenir, ce sont des patients et l'heure à laquelle ils sont arrivés...

[acacia]

OK, alors tu ne dois pas faire ainsi.

Je te conseille de dérouler la loi d'arrivée des patients, en remplissant la file au fur et à mesure, jusqu'à ce que les sept heures soient atteintes.

Ensuite, tu n'as plus qu'à faire traiter la file par le médecin.

Donc, tout ce que la file a à contenir, ce sont des patients et l'heure à laquelle ils sont arrivés...

donc, je dois refaire depuis le début!

comment je fais le test qui me calcule les 7 heures?

[Médinoc]

Pas forcément depuis le début, mais tu peux simplifier ton code existant.

Pour calculer les sept heures, ce doit être assez simple: Une boucle, un compteur de temps que tu augmentes aléatoirement, et une fonction pour ajouter un patient au bout de la file...

Et tu t'arrêtes quand tu as atteint sept heures.

[acacia]

Pas forcément depuis le début, mais tu peux simplifier ton code existant.

Pour calculer les sept heures, ce doit être assez simple: Une boucle, un compteur de temps que tu augmentes aléatoirement, et une fonction pour ajouter un patient au bout de la file...

Et tu t'arrêtes quand tu as atteint sept heures.

d'accord, je vais essayer de le faire

de toute façon je n'ai pas trop le choix