perte du pointeur sur une liste
Bonjour.
J'ai un problème bizarre.
Dans le code que je vous transmet ci dessous, je construis une liste d'éléments de type in.
Je les stocke dans un pointeur, et j'accède à mes éléments grâce à un tableau dynamique.
Ensuite je modifie ma liste. La nouvelle liste a le même nombre d'éléments que l'ancienne (en principe), et je modifie juste un élément.
Ce qui est bizarre, c'est que lorsque la modification porte sur le premier élément, la liste retournée n'a plus le même nombre d'éléments. En fait, elle n'a aucun élément.
Par contre lorsque je modifie n'importe quel autre élément (sauf le premier) j'ai le résultat attendu.
Je vous transmet ci dessous un code minimal qui détaille le problème.
Code:
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
|
#include "stdafx.h"
#include <stdio.h>
#include <stdlib.h>
typedef struct s_in
{
int nombre; //il s'agit du compteur du nombre d'instance
int identifiant;
}in;
typedef in *p_in;
//initialise un pointeur d'in
p_in initialise_pointeur_in()
{
p_in p = (p_in)malloc(sizeof(in));
if(p == NULL)
{
printf("\n initialisation de la liste d'in impossible \n");
}
else
{
p->identifiant = 0;
p->nombre = 0;
}
return p;
}
//initialise une in
in initialise_in(int iden)
{
in inst;
inst.identifiant = iden;
inst.nombre = 0;
return inst;
}
//ajoute une in à un pointeur d'in
p_in ajoute_in_pointeur_in(in ins, p_in pi)
{
p_in p = (p_in)realloc(pi, (pi->nombre + 1)*sizeof(in));
if(p == NULL)
{
printf("\n ajout d'une nouvelle in à une liste d'in impossible \n");
}
else
{
p[p->nombre] = ins;
p->nombre++;
pi = p;
}
return pi;
}
//retourne la nouvelle liste d'instance quand l'instance ins a été traitée
p_in nouvelle_liste(p_in pi, in ins)
{
int j=0;
/*p_in p = initialise_pointeur_in();
while((pi[j].identifiant != ins.identifiant) && (j < pi->nombre))
{
p = ajoute_in_pointeur_in(pi[j], p);
j++;
}
if(pi[j].identifiant == ins.identifiant)
{
p = ajoute_in_pointeur_in(ins, p);
int i;
for(i=j+1; i<pi->nombre; i++)
{
p = ajoute_in_pointeur_in(pi[i], p);
}
return p;
}
else
{
return p;
}*/
for(j=0; j<pi->nombre; j++)
{
if(pi[j].identifiant == ins.identifiant)
{
pi[j] = ins;
}
}
return pi;
}
void affiche_liste_in(p_in p)
{
int i;
for(i=0; i<p->nombre; i++)
{
printf("%d", p[i].identifiant);
printf("\n");
}
}
int main()
{
p_in p = initialise_pointeur_in();
in ins1 = initialise_in(1);
in ins2 = initialise_in(2);
in ins3 = initialise_in(3);
in ins4 = initialise_in(4);
p = ajoute_in_pointeur_in(ins1, p);
p = ajoute_in_pointeur_in(ins2, p);
p = ajoute_in_pointeur_in(ins3, p);
p = ajoute_in_pointeur_in(ins4, p);
//les instructions commentées facilitent le test avec les autres instances
affiche_liste_in(p);
printf("\n le nombre d'élements de la nouvelle liste avec l'instance1 est \n");
//printf("\n le nombre d'élements de la nouvelle liste avec l'instance2 est \n");
printf("%d \n", nouvelle_liste(p, ins1)->nombre);
//printf("%d \n", nouvelle_liste(p, ins2)->nombre);
printf("\n avec nouvelle liste sur instance1 \n");
//printf("\n avec nouvelle liste sur instance2 \n");
affiche_liste_in(nouvelle_liste(p, ins1));
//affiche_liste_in(nouvelle_liste(p, ins2));
free(p);
return 0;
} |
D'avance merci pour le temps que vous m'accordez...
