Initialisation de structures de pointeurs imbriqués

Version imprimable

Bonjour à tous!

Je voudrais votre aide pour m'aider à résoudre une erreur de compilation.

Pour (re-re)faire un solveur de mots mêlés, je dois implémenter des structures de pointeurs qui sont imbriquées. Je bloque pour initialiser, en fait même pour formuler les lvalues pour les pointeurs (assigner des NULL aux pointeurs problématiques ne résoud rien).

Turbo C++ me donne le message suivant : Error Line 103: Illegal structure operation.

Voici les types définies dans mon code:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
typedef long indice_t;
 
typedef struct
{
  char   *listeCars;
  indice_t *listeIndicesCars;
} SousGrille_t;
 
typedef struct
{
  SousGrille_t *y;
} SousGrilleParCar_t;
 
typedef struct
{
  char *grille;
  SousGrilleParCar_t *x;
  int largeur;
  int hauteur;
} GrilleMotsMeles_t;

Le code avec la fameuse ligne 103 (je fais du développement incrémental, ne vous inquiétez pas si le code ne fait rien de censé):

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
130
131
132
133
134
135
 
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <ctype.h>
 
#define MAX_T 100
 
/*TYPES*/
typedef long indice_t;
 
typedef struct
{
  char   *listeCars;
  indice_t *listeIndicesCars;
} SousGrille_t;
 
typedef struct
{
  SousGrille_t *y;
} SousGrilleParCar_t;
 
typedef struct
{
  char *grille;
  SousGrilleParCar_t *x;
  int largeur;
  int hauteur;
} GrilleMotsMeles_t;
 
 
/*PROTOTYPES*/
GrilleMotsMeles_t *initGrilleMotsMeles(FILE *);
char *initCaracteres(FILE *,int *,int *);
SousGrilleParCar_t *initAnalyseCaractere(char *,int,int);
SousGrille_t *initSousGrille(char *,int,int,int,int);
void assure(void *, const char *);
 
int main()
{
GrilleMotsMeles_t *grillemelimelo;
FILE* fGrille;
  fGrille=fopen("tableau.txt","r");
  grillemelimelo=initGrilleMotsMeles(fGrille);
  free(grillemelimelo);
  return 1;
}
 
 
 
 
GrilleMotsMeles_t *initGrilleMotsMeles(FILE *fichierGrille)
{
GrilleMotsMeles_t *p;
  p=malloc(sizeof(GrilleMotsMeles_t));
  p->grille=initCaracteres(fichierGrille,&p->hauteur,&p->largeur);
  p->x=initAnalyseCaractere(p->grille,p->hauteur,p->largeur);
  return p;
}
 
char *initCaracteres(FILE *f,int *hauteur,int *largeur)
{
char tmp[MAX_T];
int j,k;
char *p;
char c;
long taille;
 
  j=0;
  taille=0;
  *largeur=0;
  for (k=0;(c=getc(f))!=EOF; k++)
    if (c!='\n')
    {
      j++;
      taille++;
      *(tmp+k)=toupper(c);
    }
    else
    {
      *largeur=j;
      j=0;
      k--; /*on ne met pas '\n' dans le tableau*/
    };
  *(tmp+taille)='\0';
  *hauteur=taille/(*largeur);
 
  p=calloc(taille+1,sizeof(char));
  assure((void *)p,"initCaracteresGrille:erreur calloc ");
  strcpy(p,tmp);
  return p;
}
 
SousGrilleParCar_t *initAnalyseCaractere(char *grille,int h,int l)
{
SousGrilleParCar_t *p;
SousGrille_t *py;
int i;
 
  p=malloc(sizeof(SousGrilleParCar_t));
  py=p->y=calloc(h*l,sizeof(SousGrille_t));
  for(i=0;i<h*l;i++)
    *(py+i)=initSousGrille(grille,1,2,3,4);
  free(py);
  free(grille);
  return p;
}
 
SousGrille_t *initSousGrille(char *grille,int i, int h, int l, int numDirection)
{
SousGrille_t *p;
int j;
 
  p=calloc(8,sizeof(SousGrille_t));
  /*CODE*/
  free(grille);
  j=numDirection;
  j=i;
  j=h;
  j=l;
  l=j;
  return p;
}
 
 
void assure(void *ptr, const char *msg)
{
  if (ptr==NULL)
  {
    fprintf(stderr,"\n");
    fprintf(stderr,msg);
    fprintf(stderr,"\n");
    exit(EXIT_FAILURE);
  }
}

Merci beaucoup pour votre aide :?

Sans regarder ce que fait le code :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 SousGrilleParCar_t *initAnalyseCaractere(char *grille,int h,int l) { ... SousGrille_t *py; i... for(i=0;i<h*l;i++) *(py+i)=initSousGrille(grille,1,2,3,4); ... } SousGrille_t *initSousGrille(char *grille,int i, int h, int l, int numDirection) {...
- initSousGrille() renvoie un SousGrille_t * (pointeur sur structure)
- py est un SousGrille_t *
- *(py+i) (ou ce qui est équivalent py[i]) est donc un SousGrille_t (donc une structure)
- *(py+i)=initSousGrille(grille,1,2,3,4) correspond donc à SousGrille_t = SousGrille_t * ce qui est incompatible (structure = pointeur)

06/11/2014, 23h59
lautrec1

Encore une fois, assigner NULL au membre de de gauche ne change pas le message d'erreur. Par contre py=NULL marche très bien, mais ce n'est pas le but.

Je cherche absolument à avoir une lvalue indiçable, c'est pour ça que j'ai mis l'opérateur d'indirection.

Si dans le boucle, je ne mets que (py+i)=NULL; ou py++=NULL;, alors il y a l'erreur lvalue required.

Si *py++=NULL;, alors il y a l'erreur illegall structure operation

Tu vois que je sue ....

Merci pour ta réponse quand même :zoubi:
07/11/2014, 08h48
Médinoc

initSousGrille retourne un pointeur sur un tableau de huit structures, tu ne peux pas écraser un structure simple avec ça. Si tu veux écraser huit structures d'un coup, utilise memcpy.

Citation:

Envoyé par Médinoc

initSousGrille retourne un pointeur sur un tableau de huit structures, tu ne peux pas écraser un structure simple avec ça. Si tu veux écraser huit structures d'un coup, utilise memcpy.

Veux-tu dire cela ? :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 SousGrilleParCar_t *initAnalyseCaractere(char *grille,int h,int l) { SousGrilleParCar_t *p; SousGrille_t *py; int i; p=malloc(sizeof(SousGrilleParCar_t)); py=p->y=calloc(h*l,sizeof(SousGrille_t)); for(i=0;i<h*l;i++) memcpy(py+i,initSousGrille(grille,1,2,3,4),8*sizeof(SousGrille_t)); free(py); free(grille); return p; }
Et plus de message d'erreur.
Merci :)

Attention, initSousGrille() retourne un pointeur vers un buffer alloué, tu ne dois pas oublier ce pointeur avant d'avoir fait un free() dessus.
Donc, ce serait plutôt:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 SousGrilleParCar_t *initAnalyseCaractere(char *grille,int h,int l) { SousGrilleParCar_t *p; SousGrille_t *py; int i; p = malloc(sizeof(SousGrilleParCar_t)); py = p->y = calloc(h*l,sizeof(SousGrille_t)); for(i=0 ; i<h*l ; i++) { SousGrille_t *pHuitSousGrilles = initSousGrille(grille,1,2,3,4); memcpy(py+i, pHuitSousGrilles, 8*sizeof(SousGrille_t)); free(pHuitSousGrilles); } free(py); free(grille); return p; }
De plus:

Tu ne dois pas faire free(py) alors que la structures pointée par p contient encore un pointeur dessus: ça coupe l'herbe sous le pied de p->y.
Dans l'état actuel, ta boucle déborde du tableau, car tu finis par faire un memcpy sur py+(h*l)-1, débordant donc de sept sous-grilles.

Merci beaucoup8-)

Je ne comprends pas bien ce que tu me dis avec le débordement. Le but est d'avoir L*H adresses qui pointent chacun vers un groupe de 8 adresses.

Plus grave, pour le moment, je n'arrive pas à accéder aux élements de ma structure :
Aux lignes 68 et 69? le compilo donne "Pointer to structure required on left side of -> or ->*"

J'écris grillemelimelo->x[i]->y[j]->listeCars pour la structure suivante, grillemelimelo étant de type GrilleMotsMeles_t *:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
 
typedef long indice_t;
 
typedef struct
{
  char   *listeCars;
  indice_t *listeIndicesCars;
} SousGrille_t;
 
typedef struct
{
  SousGrille_t *y;
} SousGrilleParCar_t;
 
typedef struct
{
  char *grille;
  SousGrilleParCar_t *x;
  int largeur;
  int hauteur;
} GrilleMotsMeles_t;

Voici tout le code (pour les plus passionnées)

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
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
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <ctype.h>
 
#define MAX_T 100
#define DIM_MAX 100
#define EOF_LIST -1
 
/*TYPES*/
typedef long indice_t;
 
typedef struct
{
  char   *listeCars;
  indice_t *listeIndicesCars;
} SousGrille_t;
 
typedef struct
{
  SousGrille_t *y;
} SousGrilleParCar_t;
 
typedef struct
{
  char *grille;
  SousGrilleParCar_t *x;
  int largeur;
  int hauteur;
} GrilleMotsMeles_t;
 
 
/*PROTOTYPES*/
GrilleMotsMeles_t *initGrilleMotsMeles(FILE *);
char *initCaracteres(FILE *,int *,int *);
SousGrilleParCar_t *initTabSousGrilleParCar(char *,int,int);
SousGrille_t *initTabSousGrille(char *,int,int,int);
SousGrille_t *initElementSousGrille(char *,int,int,int,int);
void assure(void *, const char *);
 
enum  directions {NORD=0,EST,SUD,OUEST,NORDEST,SUDEST,SUDOUEST,NORDOUEST};
const short incr1[8]= {-1,0,1,0,-1,1,1,-1};
const short incr2[8]= {0,1,0,-1,1,1,-1,-1};
 
 
int main()
{
GrilleMotsMeles_t *grillemelimelo;
FILE* fGrille;
/*DEBUG*/
int i,j;
indice_t *pind;
/*FIN DEBUG*/
  freopen("DEBUGT.TXT","w",stdout);
  fGrille=fopen("tableau.txt","r");
  grillemelimelo=initGrilleMotsMeles(fGrille);
  /*DEBUG*/
  printf("\nGRILLE:\n%s\n",grillemelimelo->grille);
  printf("\n LARGEUR: %d\n",grillemelimelo->largeur);
  printf("\n HAUTEUR: %d\n",grillemelimelo->hauteur);
  fflush(stdout);
  for (i=0;i<(grillemelimelo->largeur)*(grillemelimelo->largeur);i++)
  {
    for(j=0;j<8;j++)
    {
      printf("\n**************\n");
      printf("DIRECTION : %d\n", j);
      printf("Sousgrille : %s ; ",grillemelimelo->x[i]->y[j]->listeCars);
      pind=grillemelimelo->x[i]->y[j]->listeIndicesCars;
      while(*pind!=EOF_LIST)
	printf("%d ",*pind++);
      printf("\n");
    };
    fflush(stdout);
  }
  /*FIN DEBUG*/
  free(grillemelimelo);
  return 1;
}
 
 
 
 
GrilleMotsMeles_t *initGrilleMotsMeles(FILE *fichierGrille)
{
GrilleMotsMeles_t *p;
  p=malloc(sizeof(GrilleMotsMeles_t));
  p->grille=initCaracteres(fichierGrille,&p->hauteur,&p->largeur);
  p->x=initTabSousGrilleParCar(p->grille,p->hauteur,p->largeur);
  return p;
}
 
char *initCaracteres(FILE *f,int *hauteur,int *largeur)
{
char tmp[MAX_T];
int j,k;
char *p;
char c;
long taille;
 
  j=0;
  taille=0;
  *largeur=0;
  for (k=0;(c=getc(f))!=EOF; k++)
    if (c!='\n')
    {
      j++;
      taille++;
      *(tmp+k)=toupper(c);
    }
    else
    {
      *largeur=j;
      j=0;
      k--; /*on ne met pas '\n' dans le tableau*/
    };
  *(tmp+taille)='\0';
  *hauteur=taille/(*largeur);
 
  p=calloc(taille+1,sizeof(char));
  assure((void *)p,"initCaracteresGrille:erreur calloc ");
  strcpy(p,tmp);
  return p;
}
 
SousGrilleParCar_t *initTabSousGrilleParCar(char *grille,int h,int l)
{
SousGrilleParCar_t *p;
SousGrille_t *py;
SousGrille_t *tmp;
int i;
 
  p=malloc(sizeof(SousGrilleParCar_t));
  py=p->y=calloc(h*l,sizeof(SousGrille_t));
  for(i=0;i<h*l;i++)
  {
    tmp=initTabSousGrille(grille,i,h,l);
    memcpy(py+i,tmp,8*sizeof(SousGrille_t));
    free(tmp);
  };
  free(py);
  free(grille);
  return p;
}
 
SousGrille_t *initTabSousGrille(char *grille,int i, int h, int l)
{
SousGrille_t *p;
SousGrille_t *tmp;
int j;
 
  p=calloc(8,sizeof(SousGrille_t));
  for(j=0;j<8;j++)
  {
    tmp=initElementSousGrille(grille,i,h,l,j);
    memcpy(p+j,tmp,sizeof(SousGrille_t));
    free(tmp);
  };
  return p;
}
 
SousGrille_t *initElementSousGrille(char *grille,int i, int h, int l, int numDirection)
{
char *tmpCar;
indice_t *tmpInd;
int k,increment;
SousGrille_t *p;
 
    p=malloc(sizeof(SousGrille_t));
 
    tmpCar=calloc(DIM_MAX,sizeof(char));
    tmpInd=calloc(DIM_MAX,sizeof(indice_t));
    increment=incr1[numDirection]*l+incr2[numDirection];
    k=0;
    do
    {
      tmpInd[k]=i;
      tmpCar[k]=*(grille+i);
      i+=increment;
      k++;
    } while (i>=0 && i<l*h && i%l!=(increment<0)*(l-1));
    tmpInd[k]=EOF_LIST;
    tmpCar[k]='\0';
 
    p->listeCars=calloc(k,sizeof(char));
    assure(p->listeCars,"initSousGrille:erreur calloc");
    strcpy(p->listeCars,tmpCar);
    free(tmpCar);
 
    p->listeIndicesCars=calloc(k,sizeof(char));
    assure(p->listeCars,"initSousGrille:erreur calloc");
    for (i=0;i<=k;i++)
      *((p->listeIndicesCars)+i)=tmpInd[i];
    free(tmpInd);
    return p;
}
 
 
 
 
void assure(void *ptr, const char *msg)
{
  if (ptr==NULL)
  {
    fprintf(stderr,"\n");
    fprintf(stderr,msg);
    fprintf(stderr,"\n");
    exit(EXIT_FAILURE);
  }
}

07/11/2014, 17h35
lautrec1

Je m'en sors avec un horrible:

(((((grillemelimelo->x)+i)->y)+j)->listeCars)

Merci beaucoup. Il me reste un memory leak, mais c'est à moi de corriger cette bêtise tout seul :roll:
07/11/2014, 18h07
Invité

Bonjour,

Avec des points :

Code:

grillemelimelo->x[i].y[j].listeCars

À noter aussi :

Code:

printf("%ld ",*pind++);

pind étant un pointeur sur indice_t, alias d'un long.
07/11/2014, 20h46
Médinoc

Citation:

Envoyé par lautrec1

Merci beaucoup8-)

Je ne comprends pas bien ce que tu me dis avec le débordement. Le but est d'avoir L*H adresses qui pointent chacun vers un groupe de 8 adresses.

Dans ce cas, vérifie tes types, car pour l'instant tu as L*H structures SousGrille_t (qui ne sont pas des pointeurs) que tu veux faire pointer chacune vers des groupes de huit structures SousGrille_t (mais elle ne contiennent aucun pointeur de ce type).

Donc, soit ta fonction initSousGrille n'alloue et ne retourne pas le bon type, soit ton tableau de L*H SousGrille_t n'est pas bon, soit il manque à ta structure SousGrille_t un pointeur du bon type.