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
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
| #include<stdio.h>
#include<stdlib.h>
#include<stddef.h>
#include<errno.h>
typedef struct liste_tableau TAB, *TAB_PTR; //raccourci
char s[BUFSIZ];
struct liste_tableau//structure de la liste chainée
{
int *allocation_tableau;//pointeur qui pointe sur un tableau dynamique de taille unique sur chaque liste
int taille_tableau; //taille du tableau specifié (pose probleme pour fread car impossible d'alloue les tableaux si la taille est inconnu hors connaitre la taille implique de lire la structure qui
//du coup il ecrase les donnees du tableau sur des emplacements non alloue probleme de design :)? j'ai trouvé une solution
TAB_PTR liste_suivante;
TAB_PTR liste_precedente;// liste double chaine
};
void destroy_all_tableau(TAB_PTR liste_de_tableau);//declaration fonction debut
void modif_fichier(TAB_PTR liste_tete,int nombre_listecompte_instancie);
TAB_PTR destroy_all_liste(TAB_PTR liste_tete,int *nombre_listecompte_instancie,int *fonction_execute);
void menu_principal(void);
void montrer_liste(TAB_PTR liste_tete,int nombre_listecompte_instancie);
void montrer_tableau(TAB_PTR liste_courant);
void ecrire_tableau(TAB_PTR liste_tete,int nombre_listecompte_instancie);
int selection_indice_tableau(void);
void alloc_liste_insertion(TAB_PTR liste_tete,int *nombre_listecompte_instancie_ptr,int nombre_listecompte_instancie,TAB_PTR *liste_fin,TAB_PTR *liste_tete_ptr);
void alloc_tableau_unique(TAB_PTR liste_courant,int nombre_listecompte_instancie);
void desalloue_liste_unique(TAB_PTR liste_tete,int *nombre_listecompte_instancie_ptr,int nombre_listecompte_instancie,TAB_PTR *liste_fin,TAB_PTR *liste_tete_ptr);
char insertion_post_liste_courant_question(void);
TAB_PTR selection_liste(TAB_PTR liste_tete,int nombre_listecompte_instancie);
void alloc_tableau_sans_demande(TAB_PTR liste_tete,int nombre_listecompte_instancie,int *fonction_execute);
int Ftaille_tableau(void);
TAB_PTR alloc_structure(TAB_PTR liste_tete,int *nombre_listecompte_instancie,TAB_PTR *liste_fin);
int nombre_de_liste_a_cree(void);
void initialisation(TAB_PTR liste_a_initialise);
void lire_fichier(int *nombre_listecompte_instancie_ptr,TAB_PTR *liste_fin,TAB_PTR *liste_tete_ptr,int nombre_listecompte_instancie,int *fonction_execute);
void alloc_structure_pour_lire_fichier(TAB_PTR **liste_fin,TAB_PTR **liste_tete_ptr,int nombre_listecompte_instancie);
void alloc_tableau_pour_lire_fichier(TAB_PTR liste_tete,int nombre_listecompte_instancie,int **fonction_execute,int *taille_tableau_dans_fichier,int liste_compteur);
void destroy_all_liste_pour_lire_liste(TAB_PTR **liste_tete,int **nombre_listecompte_instancie,int **fonction_execute,TAB_PTR **liste_fin);//declaration fonction fin
void lire_fichier(int *nombre_listecompte_instancie_ptr,TAB_PTR *liste_fin,TAB_PTR *liste_tete_ptr,int nombre_listecompte_instancie,int *fonction_execute)// fonction pour lire un fichier
{
TAB_PTR liste_courant=NULL; //la liste selectionnee
int liste_compteur=0; // le nombre de liste que l'on a traité
FILE *fichier=NULL;
char charactere_demande; //pour une question
int *taille_tableau_dans_fichier=NULL;
printf("lire des donnee depuis un fichier implique de detruire les donnee temporaires allouee dans le programme etes vous sur de continuer? ");
while (getchar()!='\n');// vide le tampon
charactere_demande=getchar();//question
if(charactere_demande=='y'||charactere_demande=='Y')
{
fichier=fopen("hello.dat","r");
if (fichier==NULL)// fichier n'existe pas
{
printf("Error READING FILE \n");
return;
}
destroy_all_liste_pour_lire_liste(&liste_tete_ptr,&nombre_listecompte_instancie_ptr,&fonction_execute,&liste_fin);// dans le cas ou on a utilisé le programme pour alloue des liste etc.. on supprime tout pour lire
rewind(fichier);
fread(nombre_listecompte_instancie_ptr,sizeof(int),1,fichier);//on lit une variable qui contient le nombre de liste pour pouvoir les allouer
nombre_listecompte_instancie=*nombre_listecompte_instancie_ptr;// certaine fonction utilise la variable au lieu du pointeur (lecture seule)
taille_tableau_dans_fichier=calloc(nombre_listecompte_instancie,sizeof(int));// pour corriger les probleme d'acces a la taille du tableau j'ai cree un tableau qui enregistre la taille du tableau de chaque liste qui peut etre différent voir la fonction modif_fichier qui ecris ce tableau dans le fichier juste apres les listes
fseek(fichier,sizeof(int),SEEK_SET);// pointe sur la variable nombre_listecompte_instancie_ptr dans le fichier
fseek(fichier,(nombre_listecompte_instancie*sizeof(TAB)),SEEK_CUR);//pointe sur la derniere liste dans le fichier
fread(taille_tableau_dans_fichier,sizeof(int),nombre_listecompte_instancie,fichier);// lit le tableau qui contient la taille de chaque tableau de *allocation_tableau dans chaque liste
fseek(fichier,sizeof(int),SEEK_SET);// pointe sur la variable nombre_listecompte_instancie_ptr dans le fichier (on recommence au debut)
alloc_structure_pour_lire_fichier(&liste_fin,&liste_tete_ptr,nombre_listecompte_instancie);// on alloue les listes ,il ya nombre_listecompte_instancie de liste
liste_courant=*liste_tete_ptr;// on selectionne liste_tete_ptr : la liste de tete
//fread(liste_courant,sizeof(TAB),1,fichier); //obsolete
//alloc_tableau_pour_lire_fichier(liste_courant,nombre_listecompte_instancie,&fonction_execute);//idem
for(liste_compteur;liste_compteur<*nombre_listecompte_instancie_ptr;liste_compteur++)// pour parcourir chaque liste
{
//fread(liste_courant->taille_tableau,sizeof(int),1,fichier);//obsolete
alloc_tableau_pour_lire_fichier(liste_courant,nombre_listecompte_instancie,&fonction_execute,taille_tableau_dans_fichier,liste_compteur);// on alloue le tableau de *allocation_tableau de chaque liste
fread(liste_courant,sizeof(TAB),1,fichier);//on lit la liste
liste_courant=liste_courant->liste_suivante;// on selectionne la liste suivante
fseek(fichier,sizeof(TAB),SEEK_CUR);// on pointe sur la liste que l'on a lu dans le fichier
}
fclose(fichier);
}
}
void modif_fichier(TAB_PTR liste_tete,int nombre_listecompte_instancie)//fonction pour enregistre les listes chainées + leur tableau alloue
{
TAB_PTR liste_courant=NULL;//pour selectionner la liste
int liste_compteur=0;// le nombre de liste que l'on a traité
FILE *fichier=NULL;
int *taille_tableau_dans_fichier=NULL; //pointeur qui pointe sur le tableau qui contient la taille du tableau de chaque liste.
liste_courant=liste_tete;// selectionne liste la liste de tete (lecture seule)
fichier=fopen("hello.dat","w");
if (fichier==NULL){
printf("Error READING FILE \n");
return;
}
taille_tableau_dans_fichier=calloc(nombre_listecompte_instancie,sizeof(int));// alloue le tableau qui contient la taille du tableau de chaque liste.
rewind(fichier);
fwrite(&nombre_listecompte_instancie,sizeof(int),1,fichier);//ecris dans le fichier le nombre de liste
fseek(fichier,sizeof(int),SEEK_SET);//pointe sur nombre_listecompte_instancie
for(liste_compteur;liste_compteur<nombre_listecompte_instancie;liste_compteur++) // parcour les listes
{
taille_tableau_dans_fichier[liste_compteur]=liste_courant->taille_tableau; //ecris la taille du tableau de chaque liste dans le tableau taille_tableau_dans_fichier
fwrite(liste_courant,sizeof(TAB),1,fichier);//enregistre la liste dans le fichier
fseek(fichier,sizeof(TAB),SEEK_CUR);//pointe sur le la liste dans le fichier
liste_courant=liste_courant->liste_suivante;//selectionne la liste suivante
}
fwrite(taille_tableau_dans_fichier,sizeof(int),nombre_listecompte_instancie,fichier);//enregistre le tableau qui contient la taille du tableau de chaque liste dans le fichier
fclose(fichier);
}
void initialisation(TAB_PTR liste_a_initialise)// initialise le pointeur de allocation_tableau a NULL
{
liste_a_initialise->allocation_tableau=NULL;
}
int nombre_de_liste_a_cree(void)// demande et renvoi le nombre de liste a creer
{
int nombre_de_liste=0;
while ((nombre_de_liste=getchar())!='\n');
printf("combien de liste a cree ");
scanf("%d",&nombre_de_liste);
return nombre_de_liste;
}
void alloc_tableau_pour_lire_fichier(TAB_PTR liste_tete,int nombre_listecompte_instancie,int **fonction_execute,int *taille_tableau_dans_fichier,int liste_compteur)// fonction pour la fonction lire_fichier elle alloue un tableau pour chaque liste a lire: TAB_PTR liste_tete pour la liste de tete , int nombre_listecompte_instancie //obsolete ,**fonction_execute sert a certifier que l'on a
// alloue des tableaux cela empeche l'utilisation de alloc_tableau_sans_demande de façon a ne pas ecraser les tableaux,int *taille_tableau_dans_fichier pointe sur le tableau qui contient la taille de allocation_tableau dans chaque liste,int liste_compteur la liste que l'on a selectionnée pour enregistrer la taille de allocation_tableau de cette liste
{
TAB_PTR liste_courant=NULL;//selectionne la liste
int compteur_liste_local=1;//obsolete
liste_courant=liste_tete;// selectionne la liste de tete
liste_courant->allocation_tableau=calloc(taille_tableau_dans_fichier[liste_compteur],sizeof (int)); // alloue un tableau qui pointe sur *allocation_tableau
if(liste_courant->allocation_tableau==NULL)
{
printf("ERREUR liste_tete->allocation_tableau non alloue\n");
return;
}
/*for(compteur_liste_local;compteur_liste_local<nombre_listecompte_instancie;compteur_liste_local++) //obsolete
{
liste_courant=liste_courant->liste_suivante;
liste_courant->allocation_tableau=calloc(liste_courant->taille_tableau,sizeof (int));
if(liste_courant->allocation_tableau==NULL)
{
printf("ERREUR liste_tete->allocation_tableau non alloue\n");
return;
}
}*/
**fonction_execute=1; //empeche d'ecraser les tableaux par alloc_tableau_sans_demande
}
void alloc_structure_pour_lire_fichier(TAB_PTR **liste_fin,TAB_PTR **liste_tete_ptr,int nombre_listecompte_instancie)//alloue les listes pour la fonction lire_fichier:int nombre_listecompte_instancie le nombre de liste
{
TAB_PTR liste_courant=NULL;//selection de la liste
TAB_PTR liste_NEW=NULL;//nouvelle liste alloue
int compteur_liste_local=1; //le nombre de liste alloue la liste de tete est deja alloue donc 1
**liste_tete_ptr=NULL;
liste_courant=malloc(sizeof (TAB));
if(liste_courant==NULL)
{
printf("ERREUR liste_tete non alloue\n");
return;
}
liste_courant->liste_precedente=NULL;
liste_courant->liste_suivante=NULL;
**liste_tete_ptr=liste_courant;//liste de tete alloue
for(compteur_liste_local;compteur_liste_local<nombre_listecompte_instancie;compteur_liste_local++)//parcours des liste
{
liste_NEW=malloc(sizeof (TAB));
if(liste_NEW==NULL)
{
printf("ERREUR liste_NEW non alloue\n");
return;
}
liste_courant->liste_suivante=liste_NEW;
liste_NEW->liste_precedente=liste_courant;
liste_NEW->liste_suivante=NULL;
liste_courant=liste_NEW;//liste alloue
}
**liste_fin=liste_courant;//liste de fin attribuée
printf("%d liste effectivement alloue\n",nombre_listecompte_instancie);
}
TAB_PTR alloc_structure(TAB_PTR liste_tete,int *nombre_listecompte_instancie,TAB_PTR *liste_fin)// alloue les listes ,cette fonction est utilisée quand l'utilisateur desir cree la liste de tete(obligatoire) et aussi alloue en un appel un nombre de listes
{
int nombre_liste_voulu_a_instancier=0;//le nombre de liste que l'on veut allouer
TAB_PTR liste_courant=NULL;//liste selectionner
TAB_PTR liste_NEW=NULL;//nouvelle liste allouée
if (liste_tete==NULL)//verifie qu'il n'y a pas de liste de tete deja alloue pour ne pas l'ecrasée
{
nombre_liste_voulu_a_instancier=nombre_de_liste_a_cree();//question sur le nombre de liste a allouée
if (nombre_liste_voulu_a_instancier>=1) // pour une liste (celle de tete)
{
liste_NEW=malloc(sizeof (TAB));
if (liste_NEW==NULL)
{
printf("ERREUR liste_tete non alloue\n");
printf("ERREUR liste non alloue\n");
return liste_tete;//NULL
}
liste_tete=liste_NEW;//liste de tete alloue
liste_tete->liste_suivante=NULL;
liste_tete->liste_precedente=NULL;
initialisation(liste_NEW);
liste_courant=liste_tete;//on selectionne la liste de tete
*nombre_listecompte_instancie=1;// le nombre de listes effectivement allouée
*liste_fin=liste_courant;//liste de fin si on alloue pas d'autre liste
if (nombre_liste_voulu_a_instancier>=2)// pour + d'une liste
{
for (*nombre_listecompte_instancie;*nombre_listecompte_instancie<nombre_liste_voulu_a_instancier;(*nombre_listecompte_instancie)++)//on parcours les listes
{
liste_NEW=malloc(sizeof (TAB));
if (liste_NEW==NULL)
{
printf("ERREUR liste_NEW non alloue\n");
printf("ERREUR liste non alloue\n");
printf(" il a %d liste alloue(liste_tete compris)\n",*nombre_listecompte_instancie);
return liste_tete;
}
initialisation(liste_NEW);
liste_courant->liste_suivante=liste_NEW;
liste_NEW->liste_precedente=liste_courant;
liste_NEW->liste_suivante=NULL;
liste_courant=liste_NEW;//liste chainée... :)
}
}
*liste_fin=liste_courant;//liste de fin attribué
printf("%d liste effectivement alloue\n",*nombre_listecompte_instancie);
return liste_tete;
}
}
else
{
printf("ERREUR tentative d'ecrasement liste_tete\n");
return liste_tete;
}
if(nombre_liste_voulu_a_instancier==0)
{
printf("vous n'avez cree aucune structure \n");
return liste_tete;
}
return liste_tete;
}
int Ftaille_tableau(void)//question pour la taille du tableau de *allocation_tableau de chaque liste
{
int taille_tableau=0;
printf("quelle taille les tableaux?\n");
scanf("%d",&taille_tableau);
return taille_tableau;
}
void alloc_tableau_sans_demande(TAB_PTR liste_tete,int nombre_listecompte_instancie,int *fonction_execute)//fonction pour alloue chaque tableau de *allocation_tableau de chaque liste en un bloc avec une taille identique pour tout les tableaux
{
int nb_tableaucompteur=1;//tableau effectivement alloue
TAB_PTR liste_courant=NULL;
int taille_tableau=0;//taille desirée
if (liste_tete!=NULL)// si la liste de tete est allouée
{
taille_tableau=Ftaille_tableau();//question sur la taille du tableau
liste_tete->taille_tableau=taille_tableau;// ecris la taille du tableau dans une variable de la liste
if (liste_tete->taille_tableau!=0)// si le tableau a une taille =>1
{
liste_courant=liste_tete;
liste_tete->allocation_tableau=calloc(liste_tete->taille_tableau,sizeof (int));//alloue le tableau
if(liste_tete->allocation_tableau!=NULL)
{
for(nb_tableaucompteur;nb_tableaucompteur<nombre_listecompte_instancie;nb_tableaucompteur++)//parcours les listes
{
liste_courant=liste_courant->liste_suivante;//liste chainée...
if (liste_courant!=NULL)
{
liste_courant->taille_tableau=taille_tableau;
liste_courant->allocation_tableau=calloc(liste_courant->taille_tableau,sizeof (int));//alloue le tableau de la liste
if (liste_courant->allocation_tableau==NULL)
{
printf("ERREUR allocation tableau echoue de liste_courant\n");//pas assez memoire
printf("%d tableau alloue\n",nb_tableaucompteur);
*fonction_execute=1;// empeche l'utilisation ulterieur de alloc_tableau_sans_demande sauf si on desalloue
return ;
}
}
else
{
printf("ERREUR liste non alloue\n");//la liste ou l'on veut alloue un tableau n'est pas alloue
*fonction_execute=1;
return ;
}
}
}
else
{
printf("ERREUR allocation tableau echoue de liste_tete\n");//pas assez memoire
return ;
}
printf("%d tableau effectivement alloue\n",nb_tableaucompteur);
*fonction_execute=1;//c'est bon
return ;
}
else
{
printf("erreur taille tableau==0\n");//la taille choisie 0 ...
return ;
}
}
else
{
printf("ERREUR liste_tete non alloue\n");//liste de tete inexistante
}
}
TAB_PTR selection_liste(TAB_PTR liste_tete,int nombre_listecompte_instancie)//fonction pour selectionner une liste ,destiné a certaine fonction
{
TAB_PTR liste_courant=NULL;// liste selectionné
int liste_compteur=1;//nombre de liste deja parcouru
int liste_selectionne=0;//la liste selectionné
printf("quelle liste selectionner?\n");
scanf("%d",&liste_selectionne);
if (liste_selectionne>nombre_listecompte_instancie)
{
printf ("erreur selection liste > au nb liste\n");//debordement de liste
return liste_courant;
}
if (liste_selectionne==0)
{
printf("erreur de selection de liste\n");// aucune liste
return liste_courant;
}
if (liste_selectionne>=1)//liste de tete
{
liste_courant=liste_tete;
if(liste_selectionne>=2)// les listes suivantes
{
liste_courant=liste_tete;
for(liste_compteur;liste_compteur<liste_selectionne;liste_compteur++)//parcours des listes
{
liste_courant=liste_courant->liste_suivante;
}
}
printf("unit %i \n",liste_selectionne);
return liste_courant;
}
return liste_courant;
}
char insertion_post_liste_courant_question(void)//question si on insert une liste avant celle qui est selectionné ou apres
{
char insertion_post_liste_courant;
printf("post insertion de liste (Y)? ou pre insertion de liste (N)\n");
while ((insertion_post_liste_courant=getchar())!='\n');
insertion_post_liste_courant=getchar();
return insertion_post_liste_courant;
}
void desalloue_liste_unique(TAB_PTR liste_tete,int *nombre_listecompte_instancie_ptr,int nombre_listecompte_instancie,TAB_PTR *liste_fin,TAB_PTR *liste_tete_ptr)//fonction pour supprimer une liste
{
TAB_PTR liste_courant=NULL;//liste selectionnée
TAB_PTR liste_post=NULL;//liste apres liste_courant
TAB_PTR liste_pre=NULL;//liste avant liste_courant
liste_courant=selection_liste(liste_tete,nombre_listecompte_instancie);// la liste est selectionné
if(liste_courant!=NULL)//si la liste existe
{
liste_post=liste_courant->liste_suivante;//on attribue la liste suivante
liste_pre=liste_courant->liste_precedente;//on attribue la liste precedente
destroy_all_tableau(liste_courant);//on desalloue le tableau de *allocation_tableau de liste_courant
free(liste_courant);//on desalloue la liste
liste_courant=NULL;//dangling pointeur neutralisé :)
if(liste_post!=NULL)liste_post->liste_precedente=liste_pre;//si il ya une liste suivante a liste_courant
else
{
liste_post=NULL;
*liste_fin=liste_pre;//sinon la liste precedente est attribuée comme liste de fin (car liste_courant etait la liste de fin)
}
if(liste_pre!=NULL)liste_pre->liste_suivante=liste_post;// si il ya une liste precedente a liste_courant
else
{
liste_pre=NULL;
*liste_tete_ptr=liste_post;//sinon la liste suivante est attribuée comme liste de tete (car liste_courant etait la liste de tete)
}
(*nombre_listecompte_instancie_ptr)--;//on decremente le nombre de liste effectivement allouée
printf("liste effectivement desalloue\n");//c'est bon ca a marché
}
else printf("ERREUR liste non alloue\n");//la liste selectionné n'existe pas
}
void alloc_tableau_unique(TAB_PTR liste_courant,int nombre_listecompte_instancie)//fonction pour alloue un tableau unique pour la fonction alloc_liste_insertion
{
if(liste_courant!=NULL)
{
liste_courant->taille_tableau=Ftaille_tableau();//question la taille du tableau de *allocation_tableau
if (liste_courant->taille_tableau!=0)
{
liste_courant->allocation_tableau=calloc(liste_courant->taille_tableau,sizeof (int));//tableau alloue
if (liste_courant->allocation_tableau==NULL)
{
printf("ERREUR allocation tableau echoue de liste_courant\n");
return ;
}
}
else
{
printf("ERREUR taille tableau==0\n");// taille choisie 0 ...
return ;
}
}
else
{
printf("ERREUR liste non alloue\n");//liste n'existe pas
return ;
}
printf("tableau alloue de %d taille",liste_courant->taille_tableau);// ca a marché
return ;
}
void alloc_liste_insertion(TAB_PTR liste_tete,int *nombre_listecompte_instancie_ptr,int nombre_listecompte_instancie,TAB_PTR *liste_fin,TAB_PTR *liste_tete_ptr)//fonction pour ajouter une liste
{
TAB_PTR liste_courant=NULL;//liste selectionnée
TAB_PTR liste_NEW=NULL;
TAB_PTR liste_tmp=NULL;
char insertion_post_liste_courant;//reponse si la liste doit etre insere avant ou apres la liste selectionnée
if(liste_tete!=NULL && liste_fin!=NULL)// si il ya une liste de tete et une liste de fin
{
if(liste_NEW=malloc(sizeof (TAB)))
{
if(liste_courant=selection_liste(liste_tete,nombre_listecompte_instancie))
{
insertion_post_liste_courant=insertion_post_liste_courant_question();//question si la liste inserée apres ou avant la liste selectionnée
if(insertion_post_liste_courant=='y'||insertion_post_liste_courant=='Y')//y == post insertion
{
printf("post_insertion choisie\n");
liste_tmp=liste_courant->liste_suivante;//liste suivante a liste_courant attribué a un pointeur temporaire
liste_courant->liste_suivante=liste_NEW;//nouvelle liste attribué comme liste suivante a liste_courant
liste_NEW->liste_suivante=liste_tmp;//l'ancienne liste suivante de liste_courant est attribué a la liste suivante de liste_NEW
if(liste_tmp!=NULL)liste_tmp->liste_precedente=liste_NEW;// si la liste suivante existe :)
else *liste_fin=liste_NEW; // liste_NEW devient la liste de fin
liste_NEW->liste_precedente=liste_courant;
initialisation(liste_NEW);
(*nombre_listecompte_instancie_ptr)++;//nombre de liste incrementé
nombre_listecompte_instancie=*nombre_listecompte_instancie_ptr;//syncro entre variable pour alloc_tableau_unique
alloc_tableau_unique(liste_NEW,nombre_listecompte_instancie);// alloue un tableau pour la liste inserée
}
else
{
printf("pre_insertion choisie\n");// meme raisonnement mais c'est une liste inserée avant la liste selectionnée
liste_tmp=liste_courant->liste_precedente;
liste_courant->liste_precedente=liste_NEW;
liste_NEW->liste_precedente=liste_tmp;
if(liste_tmp!=NULL)liste_tmp->liste_suivante=liste_NEW;
else *liste_tete_ptr=liste_NEW;
liste_NEW->liste_suivante=liste_courant;
initialisation(liste_NEW);
(*nombre_listecompte_instancie_ptr)++;
nombre_listecompte_instancie=*nombre_listecompte_instancie_ptr;
alloc_tableau_unique(liste_NEW,nombre_listecompte_instancie);
}
}
else //la liste selectionnée n'existe pas
{
printf("liste_selectionne non alloue\n");
return;
}
}
else // pas assez de memoire
{
printf("ERREUR impossible d'allouer une liste\n");
return;
}
}
else //il n'y a pas de liste de tete et de liste de fin (pas de liste du tout normalement)
{
printf("ERREUR liste_tete et liste_fin non alloue\n");
}
}
int selection_indice_tableau(void)// selectionne un indice du tableau de *allocation_tableau d'une liste afin d'en modifier le contenu (destiné à ecrire_tableau)
{
int indice_tableau=0;
printf("selectionner un indice du tableau\n");
scanf("%d",&indice_tableau);
return indice_tableau;
}
void ecrire_tableau(TAB_PTR liste_tete,int nombre_listecompte_instancie)//fonction pour modifier le contenu d'un indice du tableau de *allocation_tableau d'une liste
{
char caractere_de_demande_continuer_liste;//reponse pour changer de liste
char caractere_de_demande_continuer_tableau;// reponse pour changer d'indice du tableau
do//boucle pour changer de liste
{
TAB_PTR liste_courant=selection_liste(liste_tete,nombre_listecompte_instancie);//selection d'une liste
if(liste_courant!=NULL)//si la liste selectionnée existe
{
do//boucle pour changer d'indice tableau
{
int indice_tableau_de_ecrire_tableau=selection_indice_tableau();//question sur l'indice du tableau
if(liste_courant->allocation_tableau!=NULL)//si le tableau est effectivement alloué
{
int *adresse_tableau=liste_courant->allocation_tableau;//raccourci
if (indice_tableau_de_ecrire_tableau<liste_courant->taille_tableau)//si l'indice choisi ne deborde pas du tableau
{
printf("introduire une valeur dans le tableau\n");
scanf("%d",&adresse_tableau[indice_tableau_de_ecrire_tableau]);//change le contenu du tableau
}
else
{
printf("ERREUR tentative de debordement de tableau\n");// debordement du tableau...
}
}
else
{
printf("ERREUR tentative d'ecriture sur un tableau non alloue\n");//tableau non alloue
}
printf("un autre indice de tableau a selectionner O ou N?\n");
while (getchar()!='\n');//vide tampon
caractere_de_demande_continuer_tableau=getchar();//question pour changer d'indice de tableau
}while(caractere_de_demande_continuer_tableau=='o'||caractere_de_demande_continuer_tableau=='O');
}
else printf("ERREUR liste non alloue\n");// liste non alloue
printf("une autre liste a selectionner O ou N?\n");
while (getchar()!='\n');//vide tampon
caractere_de_demande_continuer_liste=getchar();
}while(caractere_de_demande_continuer_liste=='o'||caractere_de_demande_continuer_liste=='O');//question pour changer de liste
}
void destroy_all_tableau(TAB_PTR liste_de_tableau)//detruit un tableau a chaque appel
{
if (liste_de_tableau->allocation_tableau==NULL)//le tableau n'est pas alloué
{
printf("ERREUR tableau non alloue\n");
return;
}
free(liste_de_tableau->allocation_tableau);
liste_de_tableau->allocation_tableau=NULL;//dangling pointeur neutralisé
liste_de_tableau->taille_tableau=0;//taille =0
}
TAB_PTR destroy_all_liste(TAB_PTR liste_tete,int *nombre_listecompte_instancie,int *fonction_execute)// fonction pour desallouer tout les liste(et les tableaux indirectement)
{
TAB_PTR liste_courant=NULL;//liste selectionnée
int liste_compteur=1;//nombre de liste desalloué
TAB_PTR liste_a_detruire=NULL;//liste a desallouée
if(liste_tete!=NULL)//si liste de tete existe
{
liste_a_detruire=liste_tete->liste_suivante;
destroy_all_tableau(liste_tete);//desalloue le tableau de *allocation_tableau de liste de tete
free(liste_tete);//desalloue liste de tete
liste_tete=NULL;//dangling pointeur neutralisé
printf("liste_tete effectivement desalloue\n");
for(liste_compteur;liste_compteur<*nombre_listecompte_instancie;liste_compteur++)//parcours les listes
{
if(liste_a_detruire!=NULL)//si la liste existe
{
liste_courant=liste_a_detruire->liste_suivante;
destroy_all_tableau(liste_a_detruire);//desalloue le tableau de *allocation_tableau de liste_a_detruire
free(liste_a_detruire);//desalloue liste_a_detruire
liste_a_detruire=liste_courant;
}
else
{
printf("ERREUR liste non alloue\n");//la liste n'existe pas
return liste_tete;
}
}
liste_a_detruire=NULL;//dangling pointeur neutralisé
liste_courant=NULL;//dangling pointeur neutralisé
*nombre_listecompte_instancie=0;// 0 liste allouée
*fonction_execute=0;//on peut utilisé alloc_tableau_sans_demande
printf("toute les listes effectivement desalloues\n");
return liste_tete;//c'est bon
}
else
{
printf("ERREUR liste_tete non alloue\n");
return liste_tete;//liste de tete inexistante
}
return liste_tete;//devrai jamais servir
}
void destroy_all_liste_pour_lire_liste(TAB_PTR **liste_tete,int **nombre_listecompte_instancie,int **fonction_execute,TAB_PTR **liste_fin)//fonction similaire destroy_all_liste mais est conçu pour
//desalloue toute les listes avant de lire des listes dans un fichier avec lire_liste
{
TAB_PTR liste_courant=NULL;//liste selectionné
int liste_compteur=1;//liste effectivement desallouée
TAB_PTR liste_a_detruire=NULL;//liste a desalloué
if(**liste_tete!=NULL)//si la liste de tete existe
{
liste_a_detruire=(**liste_tete)->liste_suivante;
destroy_all_tableau(**liste_tete);//desalloue le tableau de *allocation_tableau de la liste de tete
free(liste_tete);//desalloue la liste de tete
**liste_tete=NULL;//dangling pointeur neutralisé
printf("liste_tete effectivement desalloue\n");
for(liste_compteur;liste_compteur<**nombre_listecompte_instancie;liste_compteur++)//parcours les listes
{
if(liste_a_detruire!=NULL)//si liste_a_detruire n'existe pas
{
liste_courant=liste_a_detruire->liste_suivante;
destroy_all_tableau(liste_a_detruire);//desalloue le tableau de *allocation_tableau de liste_a_detruire
free(liste_a_detruire);//desalloue liste_a_detruire
liste_a_detruire=liste_courant;
}
else
{
printf("ERREUR liste non alloue\n");//liste_a_detruire n'existe pas
return;
}
}
liste_a_detruire=NULL;//dangling pointeur neutralisé
liste_courant=NULL;//dangling pointeur neutralisé
**liste_fin=NULL;//dangling pointeur neutralisé
**nombre_listecompte_instancie=0;//liste 0
**fonction_execute=0;// alloc_tableau_sans_demande peut etre utilisé
printf("toute les listes effectivement desalloues\n");
return;//c'est bon
}
else
{
printf("ERREUR liste_tete non alloue\n");
return;//liste tete n'existe pas
}
;
}
void montrer_tableau(TAB_PTR liste_courant)//fonction pour afficher les tableaux
{
int indice_tableau_compteur=0;
int buffer_out;//raccourci
for (indice_tableau_compteur;indice_tableau_compteur<liste_courant->taille_tableau;indice_tableau_compteur++)//parcours l'indice du tableau et affiche tout les indices
{
if (liste_courant->allocation_tableau!=NULL)//tableau existe
{
buffer_out=liste_courant->allocation_tableau[indice_tableau_compteur];
printf("|%d",buffer_out);//affiche l'indice
}
else
{
printf("ET");//tableau non alloue
}
}
}
void montrer_liste(TAB_PTR liste_tete,int nombre_listecompte_instancie)
{
int liste_compteur=0;
TAB_PTR liste_courant=NULL;
liste_courant=liste_tete;
if(liste_courant!=NULL)//liste existe
{
for (liste_compteur;liste_compteur<nombre_listecompte_instancie;liste_compteur++)//parcours les listes
{
montrer_tableau(liste_courant);//affiche le tableau de la liste
printf("\n");
if(liste_courant->liste_suivante!=NULL)//si une liste suivante existe
{
liste_courant=liste_courant->liste_suivante;//liste suivante
}
}
}
else//liste tete n'existe pas
{
printf("ERREUR liste_tete non alloue\n");
}
}
void menu_principal(void)//menu interactif
{
static int nombre_listecompte_instancie=0;//le nombre de liste qui existe
static int fonction_execute=0;// permet a 0 l'utilisation de alloc_tableau_sans_demande
char caractere_choix;// variable pour choisir les actions
static TAB_PTR liste_tete=NULL;// liste de tete
static TAB_PTR liste_fin=NULL;//liste de fin
static char charnom[BUFSIZ];//obsolete
printf("tapez h pour plus d'info\n");
debut_fonction: printf("menu < ");
caractere_choix=getchar();
switch (caractere_choix)
{
case 'h':
printf(" a: permet l'allocation en un bloc de tout les listes dont la liste de tete(obligatoire pour cette derniere) a utiliser en premier\n t: permet l'allocation en un bloc d'un tableau pour chaque liste d'une taille commune (apres a on utilise t)\n e: permet d'ecrire le contenu de chaque indice du tableau de chaque liste(apres a et t)\n q: permet de quitter\n d: detruit tout les tableau et toute les listes\n m: montre tout le contenu du tableau de chaque liste\n u: insert une liste\n s: supprime une liste\n w: enregistre les listes et leur contenu dans un fichier\n l: lit les liste et leur contenu d'un fichier\n");
break;
case 'a':
liste_tete=alloc_structure(liste_tete,&nombre_listecompte_instancie,&liste_fin);
break;
case 't':
if (liste_tete!=NULL)
{
if (fonction_execute==0) alloc_tableau_sans_demande(liste_tete,nombre_listecompte_instancie,&fonction_execute);
else
{
printf("ERREUR alloc_tableau_sans_demande deja effectue\n");
}
}
else
{
printf("ERREUR liste_tete non alloue ,impossible d'allouer des tableaux\n");
}
break;
case 'e':
if (liste_tete!=NULL)
{
ecrire_tableau(liste_tete,nombre_listecompte_instancie);
}
else printf("ERREUR liste_tete non alloue ,impossible d'ecrire dans les tableaux\n");
break;
case 'q':
printf("exit\n");
liste_tete=destroy_all_liste(liste_tete,&nombre_listecompte_instancie,&fonction_execute);
exit(EXIT_SUCCESS);
break;
case 'd':
printf("destroy all\n");
liste_tete=destroy_all_liste(liste_tete,&nombre_listecompte_instancie,&fonction_execute);
break;
case 'm':
printf("montrer liste tableau\n");
montrer_liste(liste_tete,nombre_listecompte_instancie);
break;
case 'u':
printf("insertion liste\n");
alloc_liste_insertion(liste_tete,&nombre_listecompte_instancie,nombre_listecompte_instancie,&liste_fin,&liste_tete);
break;
case 's':
printf("suppression d'une liste\n");
desalloue_liste_unique(liste_tete,&nombre_listecompte_instancie,nombre_listecompte_instancie,&liste_fin,&liste_tete);
break;
case 'w':
modif_fichier(liste_tete,nombre_listecompte_instancie);
break;
case 'l':
lire_fichier(&nombre_listecompte_instancie,&liste_fin,&liste_tete,nombre_listecompte_instancie,&fonction_execute);
break;
}
while (getchar()!='\n');
goto debut_fonction;
}
int main()
{
menu_principal();
} |
a propos de fwrite/fread
Envoyé par Fifou625
Une réponse vous a été utile ? Remerciez son auteur en cliquant le pouce vert !
Répondre avec citation
Partager