Discussion :

[guipe]

Voici mon code :

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
typedef int sommet; /*indice des sommets*/ 
 
typedef struct chainon { 
 
sommet st; // indice du sommet(de 0 à nmax-1) 
struct chainon *suivant; 
int nb_jetons; 
char type; 
} Couple; 
 
typedef Couple *liste; 
 
typedef struct { 
 
liste a[nmax]; //tableau de liste 
int n; 
 
}reseau; 
 
reseau rl;

Je souhaite remplir mon tableau de listes à l'aide d'un tableau rempli préalablement comme ceci mais ça ne marche pas, j'ai une erreur de segmentation qui doit provenir de ce que j'ai dans la boucle.Si quelqu'un pouvait m'aider, merci d'avance.

Code :

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

1
2
3
4
5
6
for(i=0;i<p;j++) 
{ 
rl.a[i]->st=P[i]; // P étant le tableau rempli préalablement. 
rl.a[i]->type='p'; 
} 
}

[Jerome Briot]

Code :

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

for(i=0;i<p;j++)

C'est normal le j++ ?

[guipe]

Erreur de frappe. Sur mon programme c'est écrit correctement et ça ne marche quand même pâs !

[SofEvans]

Avec ausso peu de code, ca va etre difficile de t'aider.
On peut seulement dire les conseil habituel :

Code :

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

1
2
3
4
5
6
 
for(i=0;i<p;j++) 
{ 
    rl.a[i]->st=P[i]; // P étant le tableau rempli préalablement. 
    rl.a[i]->type='p'; 
}

Verifie que tu as allouer a[i] (absent ici)

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 
for(i=0;i<p;j++) 
{ 
    if (rl.a[i] != NULL)
    {
        rl.a[i]->st=P[i]; // P étant le tableau rempli préalablement. 
        rl.a[i]->type='p';
    }
    else
        fprintf(stderr, "ERREUR !! rl.a[%d] non alloue correctement.\n", i); 
}

Ensuite verifie que 'p' est bien le nombre de case de "rl.a".
Regarde si P[i] est valide.

Voila, si tout est valide, c'est que ca vient d'autre part et il nous faudra un code plus consequent.

[guipe]

Je dois allouer un espace mémoire pour mon tableau de liste a[i]? Mon but est de créer le tableau de listes a[i].Donc dans ma boucle je veux initialiser a[0]=P[0];a[1]=P[1]... Puis je veux voir les successeurs de a[0],a[1]...(qui se trouvent dans un fichier) et donc lister ces successeurs. Je nsais pas trop la forme du prog que je dois utiliser.

[SofEvans]

Et bien, vu que tu fais

Code :

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

typedef Couple *liste;

J'ai penser que

Code :

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

liste a[nmax]; //tableau de liste

Allouer un table unidimentionnel de pointeur vers Couple.
Donc, si ton tableau contient des "Couple*", alors il faut faire un malloc a chaque fois, sinon SegFault.

[SofEvans]

Suite a conversation MSN, voici le code resolvant le probleme.
Il est assez crade au niveau de l'insertion dans les liste chainé.

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
 
#include <stdlib.h>
#include <stdio.h>
 
 
typedef struct Chainon Chainon;
struct Chainon
{
 	int indiceSommet;
 	Chainon *suivant;
 	int nombreJetons;
	char type;
};
 
 
 
typedef struct Reseau Reseau;
struct Reseau
{
	int *Place;
	int nombrePlace;
 
	int *Transition;
	int nombreTransition;
 
	Chainon* *Arcs;
	int nombreArcs;
};
 
 
int main(void)
{
    Reseau Pietri;
 
    /* Initialisation de la structure Pietri */
	Pietri.Place = NULL;
	Pietri.nombrePlace = 0;
	Pietri.Transition = NULL;
	Pietri.nombreTransition = 0;
	Pietri.Arcs = NULL;
	Pietri.nombreArcs = 0;
 
 
 
	FILE* fichier = fopen("reseau.txt","r");
	if (fichier == NULL)
	{
        perror("Erreur lors du chargement du fichier \"reseau.txt\" ");
        return EXIT_FAILURE;
    }
 
 
	/********************************* PLACES *********************************/
    int nombre;
    while (fscanf(fichier, "%d ", &nombre) == 1)
    {
        int *Temporaire = (int*) realloc (Pietri.Place, sizeof(int)*(Pietri.nombrePlace+1));
        if (Temporaire == NULL)
        {
            perror ("realloc a echoue lors de la lecture de la ligne \"Place\" ");
            /* Faire une action, a toi de voir (Quitter, continuer ?) */
        }
        else
        {
            /* On recupere l'ancien tableau avec une case en plus */
            Pietri.Place = Temporaire;
            /* On insere la nouvelle valeur */
            Pietri.Place[Pietri.nombrePlace] = nombre;
            /* et on n'oublie pas ... ^^ */
            Pietri.nombrePlace++;
        }
 
    }
 
 
 
	/****************************** TRANSITIONS *******************************/
	/* On s'est arreter a '*' avant, on va donc avancer d'un caractere */
	fseek(fichier,1,SEEK_CUR);
    while (fscanf(fichier, "%d ", &nombre) == 1)
    {
        int *Temporaire = (int*) realloc (Pietri.Transition, sizeof(int)*(Pietri.nombreTransition+1));
        if (Temporaire == NULL)
        {
            perror ("realloc a echoue lors de la lecture de la ligne \"Place\" ");
            /* Faire une action, a toi de voir (Quitter, continuer ?) */
        }
        else
        {
            Pietri.Transition = Temporaire;
            Pietri.Transition[Pietri.nombreTransition] = nombre;
            Pietri.nombreTransition++;
        }
 
    }
 
 
    /********************************** ARCS* *********************************/
	fseek(fichier,1,SEEK_CUR);
    while (fscanf(fichier, "%d:", &nombre) == 1)
    {
        Chainon **Temp = (Chainon**) realloc (Pietri.Arcs, sizeof(Chainon*)*(Pietri.nombreArcs+1));
        if (Temp == NULL)
        {
            perror ("realloc a echoue lors de la lecture de la ligne \"Place\" ");
            /* Faire une action, a toi de voir (Quitter, continuer ?) */
        }
        else
        {
            Pietri.Arcs = Temp;
            Pietri.Arcs[Pietri.nombreArcs] = NULL;
 
 
            /* On insere tout les arcs chaines */
            int numeroArc;
            if (fscanf(fichier, "%d ", &numeroArc) == 1)
            {
                Pietri.Arcs[Pietri.nombreArcs] = (Chainon*) malloc (sizeof(Chainon));
 
                Pietri.Arcs[Pietri.nombreArcs]->indiceSommet = numeroArc;
                //Pietri.Arcs[Pietri.nombreArcs]->nombreJetons
                Pietri.Arcs[Pietri.nombreArcs]->suivant = NULL;
                //Pietri.Arcs[Pietri.nombreArcs]->type
 
                Chainon* pointeur = Pietri.Arcs[Pietri.nombreArcs];
 
                while (fscanf(fichier, "%d ", &numeroArc) == 1)
                {
                    Chainon *nouveau = (Chainon*) malloc (sizeof(Chainon));
                    nouveau->indiceSommet = numeroArc;
                    //nouveau->nombreJetons
                    nouveau->suivant = NULL;
                    //nouveau->type
 
                    pointeur->suivant = nouveau;
                    pointeur = nouveau;
                }
 
            }
 
            Pietri.nombreArcs++;
            fseek(fichier,1,SEEK_CUR);
        }
    }
 
 
    int i;
    for (i=0 ; i<Pietri.nombreArcs ; i++)
    {
        printf("%d:", i);
        Chainon* parcours;
        for (parcours=Pietri.Arcs[i] ; parcours!=NULL ; parcours=parcours->suivant)
            printf("%d ", parcours->indiceSommet);
        printf("\n");
    }
 
 
 
 
    return EXIT_SUCCESS;
}

et voici la tete que dois avoir le fichier d'entre, noté qu'il faut que chaque ligne se termine par '*' (ca aussi c'est crade, mais ca va vite et c'est simple).

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
1 2 3 7 8 9 *
4 5 6 10 11 *
1:4 *
2:4 6 *
3:6 *
4:7 *
5:2 *
6:9 *
7:10 *
8:5 *
9:11 *
10:1 8 *
11:3 8 *

[Pouet_forever]

C'est assez lourd comme fichier
Tu pourrais découper ton code en fonctions, ce qui te permettrait d'avoir plus de facilités pour ajouter / supprimer des maillons dans ta liste chaînée. Et aussi de lire plus facilement tes données
Au lieux d'utiliser fscanf tu pourrais utiliser fgets avec des appels successifs à strtol en récupérant le deuxième argument de strtol. Ca t'éviterais de mettre des * à la fin de chaque ligne