Discussion :

[Kallidus]

Bonjour à tous,

Je suis en 1ère Informatique en Haute-Ecole et on me demande de faire un projet en c sur la création d'un examen d'une personne avec l'Organisation séquentielle logique. Le chaînage permettra de lier entre-eux les examens en les classant d'après leur nomenclature (par ordre croissant).

Comme fonctionnalité, on doit juste ajouter un examen et les afficher.

Ma question est comment créer un chaînage à partir de cela?

Voici ma structure :

Code :

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

1
2
3
4
5
6
7
 struct Examens {
    long Nomenclature ;
    char Intitule[30] ;
    float MntMutuelVipo ;
    float MntMutuelAo ;
    float MntTmAo ;
} ;

Merci d'avance de votre réponse.

Kallidus

[Matt_Houston]

Si ce que tu cherches à réaliser est bien une liste chaînée, alors il te faut définir un pointeur sur la structure au sein de cette même structure. Je te laisse te renseigner sur les détails d'implémentation de cette structure de donnée, omniprésente en informatique.

[Kallidus]

Oui c'est cela mais je ne sais pas comment le créer tu n'aurais pas un exemple?

[Matt_Houston]

https://duckduckgo.com/?q=%22liste+c...En%C3%A9e%22+C

Tu vas t'en sortir ou il faut qu'on t'aide à traverser la rue ?

[Kallidus]

Matt_Houston
https://duckduckgo.com/?q=%22liste+c...En%C3%A9e%22+C

Ahahha Merci quand même pour le lien mais si j'aurais trouvé, je n'aurais pas demandé.

Matt_Houston
Tu vas t'en sortir ou il faut qu'on t'aide à traverser la rue ?

Si tu m'aurais expliquer peut-etre mais là je pense que tu doit m'aider à traverser la rue.

[dalfab]

Bonjour,

On pourrait commencer par celà

Code :

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

1
2
3
4
5
6
7
8
struct Examens {
    long Nomenclature ;
    char Intitule[30] ;
    float MntMutuelVipo ;
    float MntMutuelAo ;
    float MntTmAo ;
    struct Examens* pSuivant;
} ;

[Kallidus]

Oui, j'ai déjà ça ainsi que l'initialisation du tableau et l'insertion au début grâce à un site bien expliqué.

Maintenant je dois faire une fonction qui recherche un élément dans le tableau.

Mais comment faire la fonction?

Bien à vous

Kallidus

[ternel]

Et bien, pour chercher, il n'y a qu'une solution.
Tu prends un premier élément, et tu vérifies si c'est celui que tu veux
Si c'est le cas, tu le retournes ou tu retournes son adresse, ou son index dans le tableau.
Si ce n'est pas le cas, tu en prends un suivant et tu recommences.

[Kallidus]

Ok merci leternel.

Sauriez-vous me mettre un exemple en langage C ?

Bien à vous

Kallidus

[Matt_Houston]

Indice pour te donner du courage : le code en question est plus court que ton message (lui-même bien plus court que le poil dans ta main).

[Kallidus]

Je suis pas dans un forum de Psychologie. Je demande de l'aide donc si tu as pas la réponse, merci de ne pas mettre de commentaire.

[dalfab]

Bonjour,

@Kallidus, Matt t'a donné la réponse; le lien qu'il t'a fourni donne des explications et des exemples nombreux.
Essaie d'utiliser les aides, si ça bloque indique ce ce que tu as fait, tu obtiendras ici des explications mais pas des résultats d'exercice.
Mais sincèrement, je ne vois pas ce qui te manque.

[ternel]

Visiblement, tu as raté quelque chose.
Lors de ton inscription, tu as accepté la charte de notre communautée, dont son article IV-N.

Montre nous un peu de code, et nous t'aiderons.

petit indice, si vraiment ca te manque:
un chainage, il y a toujours un pointeur.
partant de la, le premier est évident à déterminer, c'est ta variable locale ou ton parametre
le suivant, c'est le pointeur dans l'élément courant
et recommencer, c'est la récursion.

Et non, je n'écrirai pas le code d'une fonction tant que tu n'auras pas toi même fait une proposition.

Peut-être pourrais-tu commencer par une fonction qui compare deux éléments.

Puisque tu écris une fonction, il faut déjà déterminer son type de retour, et ses arguments. Quels sont-ils d'après toi?

[Kallidus]

OK. Je ne voulais pas que vous me donniez la réponse toute faite mais un exemple en pseudo-code ou un algorithme.

Soit voici mon code et ce que j'essaie de faire c'est trié ma chaine par nomenclature mais je n'arrive pas à insérer mes nomenclatures dans ma liste et les triés pour le chainage.

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
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
#include <stdio.h>
#include <stdlib.h>
 
typedef struct Examens Examens;
struct Examens {
    long Nomenclature ;
    char Intitule[30] ;
    float MntMutuelVipo ;
    float MntMutuelAo ;
    float MntTmAo ;
    Examens *suivant;
} ;
 
typedef struct Liste Liste;
struct Liste
{
    Examens *premier;
};
 
short LireExam(struct Examens *);
void AffExam(struct Examens *,short,short);
short LireEntier(struct Examens *,char *,char *);
short Caractere(char *,short);
short LireReel(struct Examens *,char *,short ,char,char *,short);
Liste *initialisation();
 
int main()
{
    struct Examens New_exam[20];
    struct Examens *pNew_exam;
    pNew_exam = &New_exam[0];
    short choix=0,nbExam=0;
    char reco;
    Liste *maListe = initialisation();
    do
    {
        system("cls");
        printf("\t|-----------------------------------------------------------------------------------|\n"
               "\t|-------------------------------- Menu des examens ---------------------------------|\n"
               "\t|-----------------------------------------------------------------------------------|\n"
               "\t|1: Ajout d\'un nouveau examen                                                      |\n"
               "\t|2: Affichage de tous les examens                                                   |\n"
               "\t|3: Affichage uniquement de ceux qui ont un montant de mutuelle vipo superieur a 50 |\n"
               "\t|4: Quitter                                                                         |\n"
               "\t|-----------------------------------------------------------------------------------|\n");
 
        do
        {
        printf("\n\tEntrer un choix : ");
        scanf("%hd",&choix);
        switch(choix)
        {
            case 1:
                system("cls");
                if(nbExam<20)
                {
                    LireExam(pNew_exam);
                }
                else
                {
                    printf("\nLe nombre d\'examens enregistrable est depasses.\n");
                }
                nbExam++;
                pNew_exam++;
                break;
            case 2:
                system("cls");
                AffExam(New_exam,nbExam,1);
                break;
            case 3:
                system("cls");
                AffExam(New_exam,nbExam,2);
                break;
            case 4:
                reco='n';
                break;
            default :
                printf("erreur");
        }
        }while(choix<1||choix>4);
        if(choix!=4)
        {
            do {
                printf("\n\t Voulez-vous retourner au menu principal (o/n) ? ");
                fflush(stdin);
                scanf("%c",&reco);
            }while(reco!='o'&&reco!='n');
            printf("\n");
        }
    }while(reco=='o');
    return 0;
}
 
/*chainage*/
Liste *initialisation()
{
    Liste *liste = malloc(sizeof(*liste));
    Examens *element = malloc(sizeof(*element));
 
    if (liste == NULL || element == NULL)
    {
        exit(EXIT_FAILURE);
    }
 
    element->Nomenclature = 0;
    element->suivant = NULL;
    liste->premier = element;
 
    return liste;
}
 
short LireExam(struct Examens *pNew_exam)
{
    short erreur,maxm=2;
    char nomen[7],mutvipo[10],mutAo[10],mutTmAo[10],v='.';
    printf("\n\t\t----- Encodage d'un examen -----\n");
 
    do
    {
        printf("\n\t Nomenclature : ");
        fflush(stdin);
        erreur = LireEntier(pNew_exam,&nomen[0],&nomen[0]);
        if (erreur==1)
        {
            printf("\n La nomenclature a au maximum 6 chiffres.\n");
        }
        else if(erreur==2)
        {
            printf("\n La nomenclature ne contient que des chiffres.\n");
        }
    }while(erreur!=0);
    do
    {
        printf("\n\t Intitule : ");
        fflush(stdin);
        erreur=Caractere(pNew_exam -> Intitule,30);
        if(erreur==1)
        {
            printf("\n Votre intitule ne peut contenir que des caracteres \n");
        }
        else if(erreur==2)
        {
            printf("\n Votre intitule ne peut contenir que 30 caracteres \n");
		}
	}
	while(erreur != 0);
    do
    {
        printf("\n\t Montant Mutuel VIPO : ");
        fflush(stdin);
        erreur=LireReel(pNew_exam,&mutvipo[0],maxm,v,&mutvipo[0],1);
        if(erreur==1)
        {
            printf("\n Le montant mutuel Vipo doit etre differents de 0 et comporter maximum 2 décimales\n");
        }
        else if(erreur==2)
        {
            printf("\n Le montant mutuel Vipo doit comporter uniquement des chiffres et un point. \n");
		}
		else
        {
            break;
        }
    }while(erreur!=0);
    do
    {
        printf("\n\t Montant Mutuel AO : ");
        fflush(stdin);
        erreur=LireReel(pNew_exam,&mutAo[0],maxm,v,&mutAo[0],2);
        if(erreur==1)
        {
            printf("\n Le montant mutuel AO doit etre differents de 0 et comporter maximum 2 décimales\n");
		}
        else if(erreur==2)
        {
            printf("\n Le montant mutuel AO doit comporter uniquement des chiffres et un point. \n");
		}
		else
        {
            break;
        }
    }while(erreur!=0);
    do
    {
        printf("\n\t Ticket moderateur : ");
        fflush(stdin);
        erreur=LireReel(pNew_exam,&mutTmAo[0],maxm,v,&mutTmAo[0],3);
        if(erreur==1)
        {
            printf("\n Le Ticket moderateur doit etre differents de 0 et comporter maximum 2 decimales\n");
        }
        else if(erreur==2)
        {
            printf("\n Le Ticket moderateur doit comporter uniquement des chiffres et un point. \n");
		}
        else if(erreur==3)
        {
            printf("\n Le Ticket moderateur doit etre plus petit que le montant mutuel AO. \n");
		}
        else if(erreur==4)
        {
            printf("\n Le Ticket moderateur doit etre plus petit que le montant mutuel VIPO. \n");
		}
		else
        {
            break;
        }
    }while(erreur!=0);
    printf("\n\n\t ____________________________________________\n");
}
 
/* Fonction pour vérifier les entiers */
short LireEntier(struct Examens *pNew_exam,char *pc, char *dbtnomen)
{
    char c;
    short i=0,erreur=0;
    fflush(stdin);
    c=getchar();
    if(c<'0'&& c>'9')
    {
        erreur=2;
    }
    else{
    while((c != '\n')&& (c>='0'&& c<='9'))
	{
		*pc = c;
		pc++;
		i++;
		c = getchar();
		if(c<'0'&& c>'9')
        {
            erreur=2;
            break;
        }
	}
 
	*pc = '\0';
    }
	if(i!=6&&erreur==0)
	{
		erreur = 1;
	}
 
	pNew_exam-> Nomenclature = atol(dbtnomen);
 
    return erreur;
}
/* Fonction pour vérifier des caracteres */
short Caractere(char *pc,short nb)
{
    char c;
    short i=1,erreur=0;
    fflush(stdin);
    c=getchar();
    if ((c>='a'&&c<='z')||(c>='A'&&c<='Z'))
    {
        while (c != '\n')
        {
            *pc=c;
            pc++;
            c=getchar();
            if (c>='0'&&c<='9')
            {
                erreur=1;
            }
            else
            {
                if((c!=0&&c!='\n')||(c==32))
                {
                    i++;
                }
                else if (c=='\n')
                {
                    break;
                }
                else if ((c<'a'||c>'z')&&c!='\n')
                {
                    erreur=1;
                    break;
                }
            }
        }
        *pc = '\0';
        if (i > nb)
        {
            erreur=2;
        }
    }
    else if(c=='\n')
    {
        *pc = '\0';
    }
    else
    {
        erreur=1;
    }
    return erreur;
}
/* Fonction pour vérifier des réels */
short LireReel(struct Examens *pNew_exam,char *pc,short m,char v,char * dbt,short compt)
{
    char c;
    short i=0,a=0,erreur=0;
    fflush(stdin);
    c=getchar();
    if (c<'0'||c>'9')
    {
        erreur=2;
    }
    else
    {
        while (c != v)
        {
            if ((c<'0'||c>'9')&&c!='.')
            {
                erreur=2;
                break;
            }
            i=i*10+(c-48);
            *pc = c;
            pc++;
            c=getchar();
 
        }
        if (c=='.')
        {
            *pc=v;
            pc++;
            c = getchar();
            while (c!='\n')
            {
                if (c<'0'||c>'9')
                {
                    erreur=2;
                    break;
                }
                i=i*10+(c-48);
                *pc = c;
                pc++;
                c=getchar();
                a++;
            }
        }
        *pc = '\0';
        if((a>m||i==0)&&(erreur==0))
        {
            erreur=1;
        }
        if(compt==1)
            pNew_exam-> MntMutuelVipo = atof(dbt);
        else if(compt==2)
            pNew_exam-> MntMutuelAo = atof(dbt);
        else if(compt==3)
            pNew_exam-> MntTmAo = atof(dbt);
        if(pNew_exam-> MntTmAo>=pNew_exam-> MntMutuelAo)
        {
            erreur=3;
        }
        if(pNew_exam-> MntTmAo>=pNew_exam-> MntMutuelVipo)
        {
            erreur=4;
        }
    }
    return erreur;
}
/* Fonction affichage*/
void AffExam(struct Examens *a, short n,short nb)
{
    size_t  i =0;
    if(nb==1)
    {
        while(i<n)
        {
            struct Examens  *p = a + i;
            printf("\n");
            printf("\t\t----- Examen : %hd -----\n",i+1);
            printf("\t\t Nomenclature : %ld",p -> Nomenclature);
            printf("\n\t\t Intitule : %s",p -> Intitule);
            printf("\n\t\t Montant Mutuel VIPO : %.2f",p -> MntMutuelVipo);
            printf("\n\t\t Montant Mutuel Ao : %.2f",p -> MntMutuelAo);
            printf("\n\t\t Ticket moderateur : %.2f",p -> MntTmAo);
            printf("\n\n\t ____________________________________________\n");
            i++;
        }
    }
    else
    {
            while(i<n)
            {
                struct Examens  *p = a + i;
                if(p->MntMutuelVipo>50)
                {
                    printf("\n");
                    printf("\t\t----- Examen : %hd -----\n",i+1);
                    printf("\t\t Nomenclature : %ld",p -> Nomenclature);
                    printf("\n\t\t Intitule : %s",p -> Intitule);
                    printf("\n\t\t Montant Mutuel VIPO : %.2f",p -> MntMutuelVipo);
                    printf("\n\t\t Montant Mutuel Ao : %.2f",p -> MntMutuelAo);
                    printf("\n\t\t Ticket moderateur : %.2f",p -> MntTmAo);
                    printf("\n\n\t ____________________________________________\n");
                }
                i++;
            }
    }
 
}

[sben42]

Bonjour,

Je n'ai pas lu tout le code, mais je ne pense pas que tu ais compris l’intérêt, ni l'utilisation d'une liste chaîné.

Une liste chaîné sert (entre autre) à stocker un nombre variable, et surtout imprévisible d'éléments. A la différence d'un tableau, qui lui a une taille fixe.
Pour pallier au problème de taille fixe du tableau il y a 2 méthodes principales (je pense).

1) Alloué un premier tableau (de taille fixé) grâce à la fonction malloc; Puis utiliser la fonction realloc lorsque tu as atteins la taille maximale de ton tableau, de manière à l'"étendre".
C'est parfois nécessaire pour tirer avantage d'une des particularités des tableaux: le fait que tous ses éléments soient consécutifs en mémoire. Ce qui te permet par la suite de parcourir ton tableau grâce à un index.
Seulement, cette méthode peut, lors de la reallocation, nécessiter une copie complète du tableau (lorsque malloc n'a plus de place dans la zone qu'il a précédemment sélectionné). De plus, un tel tableau est coûteux en terme de mémoire, puisqu'il te demande d'allouer constamment plus de mémoire que ce que tu as effectivement besoin.

Pour pallier à ces problèmes il y a la seconde méthode.

2) La liste chaîné. Elle te permet de stocker exactement le nombre d'élément dont tu as besoin. Les différents éléments ne seront pas consécutifs en mémoire, et tu ne pourras donc pas les retrouver via un index.
C'est pourquoi tu auras besoin en plus de ta structure de donnée "utile" (ton examen), un pointeur qui pointeras sur l'élément suivant, s'il y en a un, ou sur NULL le cas contraire.
Pour manipuler cette liste tu devras toujours garder en mémoire "accessible" l'adresse de ton premier élément.
Quand tu voudras parcourir ta liste tu n'auras plus qu'à "sauter" de pointeur en pointeur jusqu'au dernier (celui dont le pointeur sur l'élément suivant pointera sur NULL).

Le principe est le suivant:

Tu créer une structure d'encapsulation de ton élément (dans ton cas, un examen). Cette structure (capsule) ne devrait à mon avis posséder que 2 champs:
-un pointeur vers un élément (alloué avec malloc).
-un pointeur vers la capsule suivante (initialisé à NULL).

Pour manipuler cette structure, tu auras besoin:
-d'un pointeur vers ta première capsule (initialisé à NULL) - Ce sera ta "liste", ne perds jamais ce pointeur, c'est lui qui te permettra de manipuler tes examens.
-d'une fonction de création d'une capsule (avec la copie d'élément à l’intérieur).
-d'une fonction d'ajout de la nouvelle capsule à la liste.
-d'une fonction de destruction de ta liste.

Je met en fichier joint un exemple de ces structures/fonctions. Le code est très peu commenté, pour te laisser l'étudier.

liste.c

Tu remarqueras que dans cette version, la liste se retrouve "à l'envers" je te laisse également trouver pourquoi et comment y remédier.
Si tu as des questions je suis disponible.
Une fois que tu auras maîtrisé cette nouvelle façon de créer et stocker tes données, on pourra voir ensemble comment les triés

Bon courage!

[Kallidus]

Mon programme c'est de mettre en œuvre l'organisation logique chaînée prévue pour stocker les structures dans un tableau qui pourra en accueillir 20.

Organisation séquentielle logique (ou chaînée) : le chaînage permettra de lier entre-eux les examens en les classant d'après leur nomenclature (par ordre alphabétique croissant) et de lier
entre eux les champs libres (non initialisés ou supprimés).

Voici ma fonction qui crée et stocke les données.

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
short LireExam(struct Examens *pNew_exam)
{
    short erreur,maxm=2;
    char nomen[7],mutvipo[10],mutAo[10],mutTmAo[10],v='.';
    printf("\n\t\t----- Encodage d'un examen -----\n");
 
    do
    {
        printf("\n\t Nomenclature : ");
        fflush(stdin);
        erreur = LireEntier(pNew_exam,&nomen[0],&nomen[0]);
        if (erreur==1)
        {
            printf("\n La nomenclature a au maximum 6 chiffres.\n");
        }
        else if(erreur==2)
        {
            printf("\n La nomenclature ne contient que des chiffres.\n");
        }
    }while(erreur!=0);
    do
    {
        printf("\n\t Intitule : ");
        fflush(stdin);
        erreur=Caractere(pNew_exam -> Intitule,30);
        if(erreur==1)
        {
            printf("\n Votre intitule ne peut contenir que des caracteres \n");
        }
        else if(erreur==2)
        {
            printf("\n Votre intitule ne peut contenir que 30 caracteres \n");
		}
	}
	while(erreur != 0);
    do
    {
        printf("\n\t Montant Mutuel VIPO : ");
        fflush(stdin);
        erreur=LireReel(pNew_exam,&mutvipo[0],maxm,v,&mutvipo[0],1);
        if(erreur==1)
        {
            printf("\n Le montant mutuel Vipo doit etre differents de 0 et comporter maximum 2 décimales\n");
        }
        else if(erreur==2)
        {
            printf("\n Le montant mutuel Vipo doit comporter uniquement des chiffres et un point. \n");
		}
		else
        {
            break;
        }
    }while(erreur!=0);
    do
    {
        printf("\n\t Montant Mutuel AO : ");
        fflush(stdin);
        erreur=LireReel(pNew_exam,&mutAo[0],maxm,v,&mutAo[0],2);
        if(erreur==1)
        {
            printf("\n Le montant mutuel AO doit etre differents de 0 et comporter maximum 2 décimales\n");
		}
        else if(erreur==2)
        {
            printf("\n Le montant mutuel AO doit comporter uniquement des chiffres et un point. \n");
		}
		else
        {
            break;
        }
    }while(erreur!=0);
    do
    {
        printf("\n\t Ticket moderateur : ");
        fflush(stdin);
        erreur=LireReel(pNew_exam,&mutTmAo[0],maxm,v,&mutTmAo[0],3);
        if(erreur==1)
        {
            printf("\n Le Ticket moderateur doit etre differents de 0 et comporter maximum 2 decimales\n");
        }
        else if(erreur==2)
        {
            printf("\n Le Ticket moderateur doit comporter uniquement des chiffres et un point. \n");
		}
        else if(erreur==3)
        {
            printf("\n Le Ticket moderateur doit etre plus petit que le montant mutuel AO. \n");
		}
        else if(erreur==4)
        {
            printf("\n Le Ticket moderateur doit etre plus petit que le montant mutuel VIPO. \n");
		}
		else
        {
            break;
        }
    }while(erreur!=0);
    printf("\n\n\t ____________________________________________\n");
}

Les fonctions LireEntier, LireReel et Caractere c'est juste des getchar() pour demander er vérifier ce que je rentre comme données.

Puis je mais un pointeur de structure dans ma structure

Code :

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

1
2
3
4
5
6
7
8
9
typedef struct Examens Examens;
struct Examens {
    long Nomenclature ;
    char Intitule[30] ;
    float MntMutuelVipo ;
    float MntMutuelAo ;
    float MntTmAo ;
    Examens *suivant;
} ;

Mais après je ne sais pas où le mettre dans mon code pour qu'il soit lier à l'adresse suivante.

[sben42]

Bien compris.

C'est pourquoi je t'ai mis en fichier joint un exemple de leurs utilisation...

Si tu veux plus d'explications, je pense qu'on ne saurait être plus explicite que ce qu'il y a écrit un peu plus loin sur ce même site: http://chgi.developpez.com/pile/

[Kallidus]

Bonjour, merci pour ton aide.

Oui mais dans le main sur le site, dans la fonction Push comme deuxième paramètre, il utilise une valeur prédéfinie alors que moi c'est une valeur que l'utilisateur entre alors je l'ai changé par nomenclature.

Mais maintenant c'est pour passer à l'adresse suivante de mon tableau de structure.

Je ne sais pas quoi mettre et où.

Bien à vous

Kallidus

[Kallidus]

Un de ma classe m'as aidé. Merci quand même.

Kallidus