Organisation séquentielle logique ou chaînée (PTL et PTO)

**Fekcheun** · 13/08/2017, 02h36

Bonsoir à tous et toutes,

Je suis étudiant en BAC1 informatique de gestion et je suis débutant en programmation. J'ai eu des repêchages à repasser, notamment programmation. Dès lors, nous avons une application à réaliser pour le jour de l'examen. Il s'agit des 3 organisations de fichiers, donc organisation indexée directe, organisation séquentielle physique et organisation séquentielle logique ou chaînée. Mais je bloque sur l'organisation séquentielle logique ou chaînée, cela fait déjà 2 semaines et je craque. Ainsi, si une bonne âme parviendrait à me secourir, j'en serai vraiment redevable, en tout cas.

Voici l'énoncé :

Dans le fichier Joueurs :
 Ajout d’un nouveau joueur,
 Affichage, au choix, de tous les joueurs (l’affichage se fera par ordre alphabétique sur le nom) ou uniquement des joueurs de plus de 18 ans.
 Bonus : suppression d'un joueur que l'on recherchera sur base de son nom. (le bonus je n'aurai certainement pas le temps)

On doit utiliser pour cela : les fichiers et obligatoirement un pointeur de tête occupée et libre donc PTO et PTL.

Par exemple :

PTO | PTL | Camille | 3 | Albert | 1 | Jean | NULL |

Camille est en position 1
Albert est en position 2
Jean est en position 3

Albert est le premier élement à afficher vu qu'il est alphabétiquement inférieur à Camille et Jean, ensuite Albert pointera sur Camille et Camille pointera sur Jean. Après, Jean pointera sur NULL ou -1 (vu que c'est un short) car il n'y a plus d'élément.

Je vous met aussi le code pour montrer que j'ai fait tout mon possible pour essayer d'arriver à un résultat qui tient la route mais en vain (PS : désolé pour les codes en commentaires, j'ai essayé toute tentative)

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
#include <stdio.h>
#include <stdlib.h>
#define ACCES_JEUX  "file/jeux.dat"
#define ACCES_JOUEURS  "joueurs.dat"
#define ACCES_PARTIES  "file/parties.dat"
 
/* Longueur des champs */
#define LG_NOM 25
#define LG_PRENOM 25
#define LG_ADRESSE 35
#define LG_CP 5
#define LG_VILLE 25
#define LG_PAYS 20
#define LG_MAIL 50
#define LG_TEL 15
#define MAX_JOUEURS 30
#define MAX_JEUX 50
 
struct Joueurs {
	long IdJoueur;
	char Nom[LG_NOM];
	char Prenom[LG_PRENOM];
//	DATE DateNaissance;
	char Adresse[LG_ADRESSE];
	char CodePostal[LG_CP];
	char Ville[LG_VILLE];
	char Pays[LG_PAYS];
	char Telephone[LG_TEL];
	char Email[LG_MAIL];
	int position;
	short suivant;
}; typedef struct Joueurs JOUEUR;
 
int nombre_joueurs(FILE*, JOUEUR*);
void Bidonnage_joueurs(JOUEUR*);
void Creation_joueurs(FILE*, JOUEUR*);
//void Init_pto(FILE *fpJoueur, JOUEUR *joueur, JOUEUR *pto, JOUEUR *ptl);
void ajout_Joueurs(JOUEUR*, FILE *, short, short);
 
int main() {
    JOUEUR joueur;
    FILE *fpJoueur;
    short PTO, PTL, i;
 
   // Creation_joueurs(fpJoueur, joueur);
   fpJoueur = fopen(ACCES_JOUEURS, "rb");
   if (fpJoueur == (FILE *) NULL){
        fpJoueur = fopen(ACCES_JOUEURS, "wb");
       if(fpJoueur == (FILE *) NULL){
          printf("Erreur lors de la creation du fichier!!");
 
       } else {
 
            PTO = -1;
            PTL = 0;
            fwrite(&PTO, sizeof(short),1,fpJoueur);
            fwrite(&PTL, sizeof(short), 1, fpJoueur);
     }
   }
            fclose(fpJoueur);
 
    ajout_Joueurs(&joueur, fpJoueur, &PTO, &PTL);
 
 
 
    return 0;
}
 
void ajout_Joueurs(JOUEUR *joueur, FILE *fpJoueur, short PTO, short PTL){
           int taille;
           int temp;
           int i;
           JOUEUR ptemp;
           fpJoueur = fopen(ACCES_JOUEURS, "r+b");
           fread(&PTO, sizeof(short), 1, fpJoueur);
           fread(&PTL, sizeof(short), 1, fpJoueur);
           if(PTL == 9){
              printf("Plus de places disponibles!");
              fclose(fpJoueur);
           } else {
            printf("Ajout\n");
            printf("Nom : ");
            scanf("%s", &joueur->Nom);
 
            if(PTO == -1) {
                fseek(fpJoueur, 2*sizeof(short), SEEK_SET);
                joueur->suivant = PTO;
                fwrite(joueur,sizeof(JOUEUR), 1, fpJoueur);
                PTO = PTL;
                PTL++;
 
            } else {
 
                rewind(fpJoueur);
                fseek(fpJoueur, 2*sizeof(short) + sizeof(JOUEUR)*PTL, SEEK_SET);
                fwrite(joueur, sizeof(JOUEUR), 1, fpJoueur);
                rewind(fpJoueur);
                fseek(fpJoueur, 2*sizeof(short), SEEK_SET);
                joueur->suivant = PTL+1;
                printf("Joueur suivant = %hd", PTL);
 
                /*fread(&ptemp, sizeof(JOUEUR), 1, fpJoueur);
                printf("%s", ptemp.Nom);*/
 
               /*  for(i = 1; i < PTL+1; i++){
                   // printf("PTL = %hd \n", PTL+1);
                    fread(&ptemp, sizeof(JOUEUR), 1, fpJoueur);
                    printf("Position : %d \n", i);
 
                    if(strcmp(ptemp.Nom, joueur->Nom) == 1){
                     printf("%s est plus grand que %s\n", ptemp.Nom, joueur->Nom);
                        PTO = i;
                        joueur->suivant = i;
                        ptemp.suivant = -1;
 
                        printf("%s et %hd\n", ptemp.Nom, ptemp.suivant);
                        printf("%s et %hd\n", joueur->Nom, joueur->suivant);
 
                   // } */
                  //  chaine = ptemp.suivant;
                 }
 
                  /*  rewind(fpJoueur);
                fseek(fpJoueur, 2*sizeof(short), SEEK_SET);
                fread(&precedent, sizeof(JOUEUR), 1, fpJoueur);
                printf("%hd", precedent.position);*/
 
 
           //}
               // PTO = PTL;
                PTL++;
                rewind(fpJoueur);
                fwrite(&PTO,sizeof(short),1,fpJoueur);
                fwrite(&PTL, sizeof(short), 1, fpJoueur);
               // printf("%hd %hd\n",PTO, PTL);
                 rewind(fpJoueur);
 
                fseek(fpJoueur, 2*sizeof(short), SEEK_SET);
                for(i = 0; i < 4; i++) {
                    fread(joueur, sizeof(JOUEUR), 1, fpJoueur);
                    printf("Joueur %s", joueur->Nom);
                    printf("Joueur suivant %s ", joueur->Nom);
 
 
                fclose(fpJoueur);*/
               // fread(joueur, 2*sizeof(short) + sizeof(JOUEUR)*PTO, 1, fpJoueur);
                // printf("pos : %hd\n", joueur->suivant);
 
 
               fclose(fpJoueur);
               /*  fpJoueur = fopen(ACCES_JOUEURS, "rb");
 
                 fseek(fpJoueur, 2*sizeof(short), SEEK_SET);
                 taille = nombre_joueurs(fpJoueur, joueur);
                 for(i = 0; i < taille; i++){
                    fread(joueur, sizeof(JOUEUR), 1, fpJoueur);
                    printf("Nom %d : %s\n", i, joueur->Nom);
                    printf("Son suivant : %hd\n", joueur->suivant);
                 }
            }*/
}
}
 
 
 
 
int nombre_joueurs(FILE *pf, JOUEUR *joueur) {
    int taille;
    pf = fopen(ACCES_JOUEURS, "rb");
 
    fseek(pf, 0L, SEEK_END);
    taille = ftell(pf) / sizeof(*joueur);
 
    return taille;
}

Voilà, j'espère que j'ai été assez clair sur les explications.

Merci d'avance

**b00mzer** · 04/09/2017, 22h35

Moi aussi je suis étudiant, en programmation premier bac.

Je dois aussi repasser programmation mais j'ai fais un exercice avec pto ptl, je te l'envoie même si ce n'est pas le style d'erxercice que tu recherches.
mais tu pourras quand même comprendre à mon avis.

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
#include <stdio.h>
#include <stdlib.h>
 
struct nombre
{
    int nombre;
    char mot [30];
};
 
void initi ();
void fmenu ();
void ajout ();
void affichage ();
 
int main()
{
    initi();
 
    fmenu();
 
    return 0;
}
 
void fmenu()
{
    int choix;
 
    do
    {
        printf("\n\n\t\tMENU\n");
        printf("===============================\n");
        printf("0: exit \n");
        printf("1: ajout du nombre\n");
        printf("2: affichage du nombre\n");
        printf("_____________________________\n");
        printf("\tchoix: ");
        fflush(stdin);
        scanf("%d",&choix);
        system("cls");
 
        switch (choix)
        {
            case 1:
                    ajout();
                    break;
            case 2:
                    affichage();
                    break;
            default:
                    printf("entrer invalide");
        }
    }while (choix != 0);
    system("cls");
}
 
void initi()
{
    FILE *fp;
    int pto = -1, ptl = 2 * sizeof(int);
 
    fp = fopen("test.dat", "r+b");
    if(fp == NULL)
    {
        fclose(fp);
        fp = fopen("test.dat", "wb");
        if(fp != NULL)
        {
            fwrite(&pto, sizeof(int), 1, fp); // ECRITURE PTO
            fwrite(&ptl, sizeof(int), 1, fp); // ECRITURE PTL
        }
        else printf("\n\t[ERREUR] Echec de la creation du fichier.");
    }
    fclose(fp);
}
 
void ajout()
{
    struct nombre nouv, ancien;
    int pto, ptl, offset = -1, recherche, trouve=0, prec, pos;
    FILE *fp;
 
    fp = fopen("test.dat", "r+b");
 
    fread(&pto, sizeof(int),1,fp);
    fread(&ptl, sizeof(int),1,fp);
    recherche = pto;
 
    printf("entrer votre nouveau nombre: ");
    fflush(stdin);
    scanf("%d", &nouv.nombre);
    fseek(fp, ptl, SEEK_SET);
    pos = ftell(fp);
    fwrite(&nouv, sizeof (struct nombre), 1, fp);
    fwrite(&offset, sizeof (int), 1, fp);
 
    //ce positionne en premier car rien écrit
    if(pto == -1)
    {
        pto = ptl;
        ptl = ftell(fp);
        fseek(fp, 0, SEEK_SET);
        fwrite(&pto, sizeof(int), 1, fp);
        fwrite(&ptl, sizeof(int), 1, fp);
    }
    else
    {
        //recherche le positionnenment
        while (recherche != -1 && trouve == 0)
        {
            fseek(fp, recherche, SEEK_SET);
            fread(&ancien, sizeof (struct nombre), 1, fp);
            if (ancien.nombre > nouv.nombre)
            {
                trouve = 1;
            }
            else
            {
                prec = recherche;
                fread(&recherche, sizeof (int), 1, fp);
            }
        }
 
        //en dernier car le nombre est plus grands que tous
        if (trouve == 0)
        {
            pos = ftell(fp);
            fseek(fp, prec + sizeof(struct nombre), SEEK_SET);
            fwrite(&pos, sizeof(int), 1, fp);
            fseek(fp, pos + sizeof(struct nombre) + sizeof (int) ,SEEK_SET);
            ptl = ftell(fp);
            fseek(fp, sizeof (int), SEEK_SET);
            fwrite(&ptl, sizeof(int),1,fp);
        }
 
        else
        {
            //au milieu
            if (recherche != pto)
            {
                fseek(fp, prec + sizeof (struct nombre), SEEK_SET);
                fwrite(&pos, sizeof (int), 1, fp);
                fseek(fp, pos + sizeof (struct nombre), SEEK_SET);
                fwrite(&recherche, sizeof(int), 1, fp);
                ptl = ftell(fp);
                fseek(fp, sizeof (int), SEEK_SET);
                fwrite(&ptl, sizeof(int),1,fp);
            }
            //premier si il y a quelque chose
            else
            {
                fseek(fp, pos + sizeof (struct nombre), SEEK_SET);
                fwrite(&pto, sizeof(int), 1, fp);
                ptl = ftell(fp);
                fseek(fp, 0 , SEEK_SET);
                fwrite(&pos, sizeof(int), 1, fp);
                fwrite(&ptl, sizeof(int), 1, fp);
 
            }
        }
    }
 
    fclose(fp);
}
 
void affichage()
{
    struct nombre affiche;
    int pto, ptl, offset;
    FILE *fp;
 
    fp = fopen("test.dat", "r+b");
 
    fread(&pto, sizeof (int), 1, fp);
    fread(&ptl, sizeof (int), 1, fp);
    offset = pto;
 
    while (offset != -1)
    {
        fseek(fp, offset, SEEK_SET);
        fread(&affiche, sizeof (struct nombre), 1 ,fp);
        fread(&offset, sizeof (int), 1, fp);
        printf("nombre: %d\n", affiche.nombre);
    }
 
    fclose(fp);
}

**Médinoc** · 05/09/2017, 13h14

Faire les manipulations directement dans le fichier binaire? Ouch.

**Fekcheun** · 14/09/2017, 22h57

Bonsoir,

Tout d'abord désolé du retard effectif pour répondre aux messages et ensuite, merci pour vos réponses

.

Hélas, je devais rendre ce travail au plus tard pour le 24 août, j'aurai dû poster ça 1 mois auparavant pour que les gens aient le temps de consulter. Mais merci quand même. En effet, ce que tu m'as posté là, c'était effectivement ça que je devais faire, j'ai échoué mais c'est maintenant je le sais et je m'en sortirai désormais.

Oui Medinoc, c'était bien directement sur le fichier binaire, ce qui rendait la tâche assez difficile.

Merci en tout cas b00mzer

Organisation séquentielle logique ou chaînée (PTL et PTO)

C

Discussions similaires

Partager

Partager