Discussion :

[lautrec1]

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 :

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 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 :

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
 
#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

[diogene]

Sans regarder ce que fait le code :

Code :

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

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)

[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

[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.

[lautrec1]

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 :

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

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

[Médinoc]

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 :

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
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.