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.

[guipe]

Ca ne suffit pas de faire ça?

Code :

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

1
2
3
4
5
6
7
8
typedef struct { 
 
liste a[nmax]; //tableau de liste 
int n; 
 
}reseau; 
 
reseau rl;

Comment je dois faire mon malloc et ou? Dans la boucle ?

[SofEvans]

Le probleme provient du fait que je ne suis pas sûr du type de liste.

si liste equivaut a "Couple", alors pas de malloc et il faut utiliser rl.a[i].st=P[i]; et non rl.a[i]->st=P[i];

si liste equivaut a "Couple*", alors il faut utiliser malloc dans la boucle.

Ca ne suffit pas de faire ça?

Code :

Code :

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

1
2
3
4
5
6
7
8
typedef struct { 
 
liste a[nmax]; //tableau de liste 
int n; 
 
}reseau; 
 
reseau rl;

Comment je dois faire mon malloc et ou? Dans la boucle ?

Non, si liste == Couple*, ca suffit pas.
Tu peux faire le malloc dans la boucle.

Code :

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

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

[guipe]

Code :

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

a[i]= malloc(sizeof(?));

[SofEvans]

Si

liste == Couple*

alors

a[i]= (Couple*) malloc(sizeof(Couple));



Le cast du retour n'est pas obligatoire selon certaine personne

[Pouet_forever]

Le cast du retour n'est pas obligatoire selon certaine personne

Non, et j'ai eu l'explication du pourquoi
C'est parce qu'en fait au début dans la première «sortie» du C (ANSI je crois) le prototype du malloc était : char *malloc(int size) (pour le int je suis pas sûr)
Il n'y avais pas de pointeur générique (void*) et du coup le cast était obligatoire !
Après il ya a eu «une mise à jour» (ISO je crois) qui a introduit le pointeur générique (void*) et le cast du malloc est devenu facultatif.

[guipe]

Contenu du fichier dont je me sers pour créer mon tableau de listes :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
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

Voici mon code complet.
Explications: J'ai un fichier dans lequel sont contenus des caractères(voir au dessus).
Dans un premier temps je remplis 1 tableau P correspondant aux caractères de la 1ere ligne. Puis un tableau T correspondant aux caractères de la 2eme ligne.
Puis ce que je veux faire ensuite c'est créer un tableau de liste a[nmax]. Dans a[0],a[1],a[2].. je veux insérer le premier caractère de chaque ligne de mon fichier à partir de la 3ème ligne jusqu'à la dernière du fichier(a[0]=1,a[1]=2,a[2]=3...).Puis après je veux faire une liste chainée des caractères que je trouve après chaque":" de chaque ligne. Je veux chainer le premier caractère de la ligne(contenu dans mon tableau a[nmax] avec le ou les caractères qui suivent le ":" (ex: a[0]=1 chainé avec 4, a[1]=2 chainé avec 4 et 6...)Je pense que je suis un peu maladroit et que je ne m'y prends pas comme il faut.

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
//
//  Projet
//
 
#include <stdio.h>
#include <stdlib.h>
#define nmax 200 //definit le nombre max de sommet
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;
Couple *ptrcouple;
 
typedef struct {
 
	liste a[nmax]; //tableau de liste
	int n;
 
} reseau;
 
 reseau rl;
 
 
int main()
{
 
	char c[4];
	char tmp;
	liste q,tmp2,tmp3,tmp4;
	int P[6];
	int T[20];
	int H[200];
	int i=0,p=0,t=0,h=0,j=0;
 
 
	FILE*fp;
	fp=fopen("reseau.txt","r");
 
 
	/****************************** PLACES *******************************/
	do
	{
		tmp=fgetc(fp);
		if(tmp==' ' || tmp=='\n') 
		{
			c[i]='\0';
			P[p]=atoi(c);
			i=0;
			p++;
		}
		else
		{
		c[i]= tmp;
		i++;
		}
 
	}while(tmp != '\n');
 
	/****************************** TRANSITIONS *******************************/
	do
	{
		tmp=fgetc(fp);
		if(tmp==' ' || tmp=='\n') 
		{
			c[i]='\0';
			T[t]=atoi(c);
			i=0;
			t++;
		}
		else
		{
			c[i]= tmp;
			i++;
		}
 
	}while(tmp != '\n');
 
	printf("Sommets\n");
	printf("places : " );
 
	for(i=0;i<p;i++)
	{
		printf("%d ",P[i]);
	}
	printf("\n");
	printf("transitions : ");
 
	for(i=0;i<t;i++)
	{
		printf("%d ",T[i]);
	}
	printf("\n");
 
	for(i=0;i<p;i++)
	{
		rl.a[i].st=P[i];
		rl.a[i].type='p';
	}
	printf("\n");
	i=p;
	while((i<(t+p))&&(j<t))
	{
			rl.a[i].st=T[j];
			rl.a[i].type='t';
            i++;
			j++;
	}
	for(i=0;i<(t+p);i++)
	{
		printf("%d ",rl.a[i].st);
	}
 
	for(i=0;i<(t+p);i++)
	{
		do
		{
			do
			{
				tmp=fgetc(fp);
				if(tmp==rl.a[i].st)
				{
					ptrcouple=malloc(sizeof(Couple));
					ptrcouple->st=tmp;
					rl.a[i]->suivant=ptrcouple;
					ptrcouple=&(rl.a[i]);
				}
			}while(tmp!=':');
 
			/*tmp=0;
			do
			{
				tmp=fgetc(fp);
				if(tmp==' ' || tmp=='\n') 
				{
					c[i]='\0';
					H[h]=atoi(c);
					tmp3=malloc(sizeof(Couple));
					tmp3.st=H[h];
					rl.a[i]->suivant=tmp3;
					tmp3=rl.a[i];
					i=0;
					h++;
					}
					else
						{
						c[i]= tmp;
						i++;
						}
			}while(tmp!='\n');
		*/	
		}while(tmp != EOF);
	} 
return(0);
}

[guipe]

Je veux chainer a[0] avec 4 puis a[1] avec 4 et 6 ... Je pense que vous pouvez m'aider.

a[0](1)->4

a[1](2)->4->6

a[2](3)->6

a[3](4)->7

a[4](5)->2

a[5](6)->9

a[6](7)->10

a[7](8)->5

a[7](9)->11

a[7](10)->1->8

a[7](11)->3->8

[Bbaboulinet]

Salut,
utilise plutot la fonction fread() ça éviterai dans ton cas de faire toutes tes boucles while.
Et mettre des noms de variable qui ont du sens aussi, parceque le mono-lettre ce n'est pas facile à lire.

[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