Discussion :

[astyan42]

Bonsoir a tous
Voila, j'ai un projet a faire pour la fac ( la résolution d'un futoshiki ) et j'ai un petit problème concernant un évènement en fait. Ce qu'il se passe, c'est que quand je decide de revenir au menu a partir de l'écran de jeu, ceci fonctionne et quand je redéclenche l'évènement pour retourner dans le jeu, j'ai une erreur, et celle ci arrive toujours au meme endroit. Enfin trève de bavardage: l'explication avec le code sera ( je l'espère ^^ ) plus explicite.
Merci par avance a ceux qui prendront du temps pour me répondre

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
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
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
 
 
#include <stdlib.h>
#include <stdio.h>
#include <SDL/SDL.h>
#include <SDL/SDL_ttf.h>
#include "affichage.h"
 
//======================================================================================//
//----------------------------------Evenements du menu----------------------------------//
//======================================================================================//
 
 
void evenementsmenu()
{
 
    SDL_Event event ;
    int continuer = 1;
    affichagemenu();
    while (continuer)
    {
        int taillegrille=0;
        FILE* eventmenu;
        eventmenu= fopen("reseventsmenu.txt","w");
        fprintf(eventmenu,"taillegrille=%d",taillegrille);
        SDL_WaitEvent(&event);
        switch(event.type)
        {
            case SDL_QUIT :
                continuer = 0;
                break;
            case SDL_KEYDOWN:
                switch (event.key.keysym.sym)
                {
                    case SDLK_ESCAPE:
                        continuer = 0;
                        break;
                    default:
                        break;
                }
                break;
            case SDL_KEYUP:
                switch (event.key.keysym.sym)
                {
                    case SDLK_KP1:
                        continuer=0;
                        taillegrille = 1;
                        evenementsgrille(taillegrille);
                    break;
 
                    case SDLK_KP2:
                        continuer=0;
                        taillegrille = 2;
                        evenementsgrille(taillegrille);
                    break;
 
                    case SDLK_KP3:
                        continuer=0;
                        taillegrille = 3;
                        evenementsgrille(taillegrille);
                    break;
 
                    case SDLK_KP4:
                        continuer=0;
                        taillegrille = 4;
                        evenementsgrille(taillegrille);
                    break;
 
                    case SDLK_KP5:
                        continuer=0;
                        taillegrille = 5;
                        evenementsgrille(taillegrille);
                    break;
 
                    case SDLK_KP6:
                        continuer=0;
                        taillegrille = 6;
                        evenementsgrille(taillegrille);
                    break;
 
                    case SDLK_KP7:
                        continuer=0;
                        taillegrille = 7;
                        evenementsgrille(taillegrille);
                    break;
 
                    case SDLK_KP8:
                        continuer=0;
                        taillegrille = 8;
                        evenementsgrille(taillegrille);
                    break;
 
                    case SDLK_KP9:
                        continuer=0;
                        taillegrille = 9;
                        evenementsgrille(taillegrille);
                    break;
                    default:
                        break;
                }
                break;
            default:
                break;
        }
}
}
//==================================================================================================================//
//------------------------------------------------- Evenements de la  grille ---------------------------------------//
//==================================================================================================================//
 
void evenementsgrille( int taillegrille)
{
    FILE* eventgrille;
    eventgrille= fopen("reseventsgrille.txt","w");
    fprintf(eventgrille,"taillegrille=%d",taillegrille);
    fclose(eventgrille);
    SDL_Event event ;
    int continuer = 1;
    affichagegrille(taillegrille, "string");
    while (continuer)
    {
 
        SDL_WaitEvent(&event);
        switch(event.type)
        {
            case SDL_QUIT :
                continuer = 0;
                break;
            case SDL_KEYDOWN:
                switch (event.key.keysym.sym)
                {
                    case SDLK_ESCAPE:
                        continuer = 0;
                        break;
 
                    default:
                        break;
                }
                break;
            case SDL_KEYUP:
                switch(event.key.keysym.sym)
                {
                    case SDLK_m:
                        continuer = 0;
                        evenementsmenu();                        ;
                        break;
                    default:
                        break;
                }
                break;
            default:
                break;
        }
    }
}
 
 
 
//===================================================================================================================//
//--------------------------------------------- Initialise l'affichage du menu---------------------------------------//
//===================================================================================================================//
 
 
 
void affichagemenu()
{
    SDL_Surface *ecran = NULL, *fondfenetre = NULL;
    SDL_Rect positionfond ;
    positionfond.x = 0;
    positionfond.y = 0;
    ecran = SDL_SetVideoMode(800, 600, 32, SDL_HWSURFACE); // Ouverture de la fenêtre
    SDL_WM_SetCaption("Futoshiki", NULL); // Je renomme ma fenetre
    SDL_FillRect(ecran, NULL, SDL_MapRGB(ecran->format, 255, 255, 255)); //le fond de la fenetre devient blanc
    fondfenetre = SDL_LoadBMP("menu.bmp");
    SDL_BlitSurface(fondfenetre,NULL,ecran,&positionfond);
    SDL_Flip(ecran);
    //pause();
 
}
 
 
 
 
 
 
 
//==========================================================================================================================//
//                                           Fonction affichant la grille                                                   //
//==========================================================================================================================//
 
 
 
int affichagegrille(int taillegrille,char * string)
 
{
//---------------Initialisation-----------------//
    FILE* affichegrille;
    affichegrille = fopen("resaffichegrille.txt","w");
    int c;
    SDL_Surface *ecran = NULL; // Creation de mon pointeur sur la fenetre
    SDL_Surface **surface; // Creation du pointeur sur ma première case
    SDL_Surface *texte = NULL; // Creation de la surface contenant les textes a afficher
    SDL_Surface *res = NULL;
    surface = malloc((( taillegrille * taillegrille ) + (( taillegrille + taillegrille-1) * taillegrille-1 ))*sizeof(SDL_Surface));
    SDL_Init(SDL_INIT_VIDEO); // Initialisation de la SDL
     // Initialisation de TTF
    TTF_Font *police = NULL; // Initialisation de la police
    SDL_Color couleurNoire = {0, 0, 0};
    police = TTF_OpenFont("carolingia.ttf", 20); //chargement de la police
    fprintf(affichegrille," %d\n",((( taillegrille * taillegrille ) + (( taillegrille + taillegrille-1) * taillegrille-1 ))));
 
 
//---------------    Ecran    ------------------//
 
    ecran = SDL_SetVideoMode(1440, 900, 32, SDL_HWSURFACE); // Ouverture de la fenêtre
    SDL_WM_SetCaption("Futoshiki", NULL); // Je renomme ma fenetre
    SDL_FillRect(ecran, NULL, SDL_MapRGB(ecran->format, 255, 255, 255)); //le fond de la fenetre devient blanc
 
//--------------   Surfaces   ------------------//
 
    for(c=0;c<((taillegrille*taillegrille)+((taillegrille + taillegrille-1) * taillegrille-1));c++) // boucle d'initialisation des surfaces // modifier condition affichage boucle ( avec malloc )
    {
        surface[c]=NULL ;
    }
 
    int i=0;
    int j=0;
    int k=0;
    int abscisse = 20;
    int ordonnee = 20;
    int id_chiffre = 0;
    int id_signe = 0;
    //char* valeur;
    SDL_Rect *positionC, *positionS;
    positionC = malloc ( taillegrille * sizeof(SDL_Rect)); // Tableau des valeurs des positions des chiffres
    positionS = malloc ( ((taillegrille + taillegrille-1) * taillegrille-1) * sizeof(SDL_Rect) ); // Tableau des valeurs des positions des signes (pour une grille n*n: (n+n-1)*n-1 valeurs)
    SDL_Rect Resoudre; // Surface du bouton "Resoudre"
    SDL_Rect positionT;
    positionT.x = 25;
    positionT.y = 25;
 
//-----------------initialisation des tableaux de surface-----------------------//
 
    for(i=0;i<((taillegrille*2)-1);i++) // Pour chaque ligne
    {
        if(i%2==0) // Si c'est une ligne paire
        {
            for(j=0;j<((taillegrille*2)-1);j++) // Il y a soit des chiffres soit des signes // nb ligne = nombre de chiffre *2 -1
            {
                fprintf(affichegrille," i=%d ,j=%d, k=%d \n",i,j,k);
                if( k%2 == 0 ) // si la case est a une place paire sur la ligne: ce sera un chiffre
                {
                    fprintf(affichegrille,"id_chiffre = %d \n",id_chiffre);
                    positionC[id_chiffre].x=abscisse; // placement de la surface
                    positionC[id_chiffre].y=ordonnee;
                    positionT.x = abscisse+20;
                    positionT.y = ordonnee+14;
                    fprintf(affichegrille," %d if",id_signe+id_chiffre );
 
                    //---- Selection de l'image -----//
                    surface[id_signe+id_chiffre]=SDL_LoadBMP("vide.bmp"); // on charge l'image dans la surface
 
                    //sprintf(valeur,"%d",string[1]);
                    //texte = TTF_RenderText_Blended(police, "1" , couleurNoire); // on affiche la valeur dans la case
                    fprintf(affichegrille," ok1 \n");
 
 
                    //---- Fin selection image -----//
 
                    SDL_BlitSurface(surface[id_signe+id_chiffre],NULL, ecran, &positionC[id_chiffre]); // Je blitte la surface sur l'écran
                    SDL_BlitSurface(texte, NULL, ecran, &positionT);
                    id_chiffre++; // J'augmente le compteur des chiffres
                    k++; // Je passe a la case suivante
                    abscisse+=50; // La case a une taille de 50
                  // fprintf(affichegrille,"entre\n");
                }
                else // Si la case est a une place impaire: ce sera un signe
                {
                    fprintf(affichegrille," %d else ",id_signe+id_chiffre );
                    positionS[id_signe].x=abscisse; // placement de la case
                    positionS[id_signe].y=ordonnee;
                    surface[id_signe+id_chiffre]=SDL_LoadBMP("sup.bmp");
                    fprintf(affichegrille," ok1 "); //chargement de l'image dans la surface
                    SDL_BlitSurface(surface[id_signe+id_chiffre],NULL, ecran, &positionS[id_signe]); // Je blit la surface
                    id_signe++; // J'augment le compteur des signes
                    k++; // Je passe a la case suivante
                    abscisse+=50; // la case avait une taille de 50
                    fprintf(affichegrille," ok2 \n");
                }
            }
            abscisse=20; // Passage a la ligne suivante donc remise a zéro des abscisses
            k=0;// Passage a la ligne suivante donc remise a 0 du compteur de case sur la ligne
        }
        else // Si la ligne est impaire: il n'y aura que des signes
        {
            for(j=0;j<taillegrille;j++) // 5 signes sont requis entre les chiffres // x chiffres pour x colonnes
            {
             //   abscisse+=20; // J'augmente l'abscisse de 20 après la surface précédente
                fprintf(affichegrille,"%d for2 ", id_signe+id_chiffre);
                positionS[id_signe].x=abscisse; // placement du signe
                positionS[id_signe].y=ordonnee;
                surface[id_signe+id_chiffre]=SDL_LoadBMP("sup.bmp"); // Chargement de l'image dans la surface
                SDL_BlitSurface(surface[id_signe+id_chiffre], NULL, ecran, &positionS[id_signe]); // Blit de la surface sur l'écran
                abscisse+=100; // Je passe a la case suivante
                id_signe++; // j'augmente le compteur des signes
                fprintf(affichegrille,"ok \n");
            }
            abscisse=20; // Passage a la ligne suivante donc remise a 0 de l'abscisse
 
        }
        ordonnee+=50; // Chaque surface mesure 50 px de haut
    }
    Resoudre.x=180; //placement du bouton RESOUDRE
    Resoudre.y=ordonnee+50;
    res=SDL_LoadBMP("resoudre.bmp");
    SDL_BlitSurface(res, NULL, ecran, &Resoudre);
 
//--------------- Fin affichage ------------//
 
    SDL_Flip(ecran);
    TTF_CloseFont(police);
 
     // Arrêt de la SDL
    fprintf(affichegrille,"test2\n");
    fclose(affichegrille);
 
    return EXIT_SUCCESS; // Fermeture du programme
}

donc voila, plus concretement, quand je rentre dans evenementsmenu la première fois tout se passe bien: j'appuie sur ma touche pour choisir la taille de ma grille, j'arrive a ma grille, je me dis: oups je me suis trompé: j'appuis sur le bouton "m" ("," pour les claviers azerty) et je retourne au menu: je suis censé pouvoir rechoisir ma grille mais la malheureusement: paf erreur dès que je choisis un chiffre au dessus de 3...
Et pour info, je n'ai pas mis ma fonction main car elle ne fait que d'initiliser SDL et lancer la fonction evenementsmenu.
Merci par avance
Cordialement,
Astyan42

[SofEvans]

Il y a beaucoup trop de chose sur lequelle tu dois revenir.

On ne fait appel a SDL_SetVideoMode() qu'une est une seule fois !
En general, c'est dans le main avant la boucle.
Apres, pour avoir la surface d'ecran (qui est un singleton -> variable global), on utilise SDL_GetVideoSurface();

Idem pour SDL_Init(SDL_INIT_VIDEO); !
Une seule fois, dans le main en dehors de la boucle.


Il faut absolument tester le retour des malloc/fopen/TTF_openFont/SDL_Init et afficher le message d'erreur correspondant avec perror()/SDG_getError()/TTF_GetError()
C'est vital !

Attention, TOUTE ALLOCATION MEMOIRE DOIT AVOIR UNE DESALLOCATION sauf exception

Je dis ca en gros, car ton programme genere des fuite de memoire incroyable !

Code :

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

1
2
3
4
5
6
 
    while (continuer)
    {
        int taillegrille=0;
        FILE* eventmenu;
        eventmenu= fopen("reseventsmenu.txt","w");

Tu recharge ton fichier a chaque debut de boucle ? sans compter qu'aucun fclose n'y est associé ?
Mais ton programme ne t'as jamais explosé a la figure ?

Bref, il y a grandement a ameliorer dans ton code avant de se preoccuper de ton probleme "visible" (car les probleme "invisible " sont grave)

[astyan42]

merci pour tout les trucs que je voyais pas ( plus )
je vais changer cela et je reviendrais poster pour vous dire si ca fonctionne ou pas
merci de la rapidité de réponse ( ps: je débute vraiment avec la SDL ^^' c'est une "innovation" pour mon projet )

[SofEvans]

Voici ce que l'on peut faire :

La fonction evenementsmenu revu :

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
 
void evenementsmenu()
{
    /* Ouverture securisé d'un fichier
       TODO : decrire son role */
    FILE* eventmenu = fopen("reseventsmenu.txt","w");
    if (eventmenu == NULL)
    {
        perror("Echec lors de la fonction fopen sur eventmenu dans la fonction evenementsmenu() ");
        return;
    }
 
 
 
    affichagemenu();
 
    int continuer = 1;
    while (continuer)
    {
        SDL_Event event ;
        SDL_WaitEvent(&event);
        switch(event.type)
        {
            case SDL_QUIT :
                continuer = 0;
                break;
 
            case SDL_KEYDOWN:
                switch (event.key.keysym.sym)
                {
                    case SDLK_ESCAPE:
                        continuer = 0;
                        break;
 
                    case SDLK_KP1:
                    case SDLK_KP2:
                    case SDLK_KP3:
                    case SDLK_KP4:
                    case SDLK_KP5:
                    case SDLK_KP6:
                    case SDLK_KP7:
                    case SDLK_KP8:
                    case SDLK_KP9:
                        continuer = 0;
                        fprintf(eventmenu,"taillegrille = %d \n", event.key.keysym.sym - SDLK_0); 
                        evenementsgrille(event.key.keysym.sym - SDLK_0);
                        break;
 
                    default:
                        break;
                }
                break;
            default:
                break;
        }
    }
    fclose(eventmenu);
}

pour la petite explication de ceci :

Code :

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

1
2
 
event.key.keysym.sym - SDLK_0

Il faut savoir que SDLK_0 fait partie d'un enum (SDLKey)
Voici un extrait :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
 
	/* Numeric keypad */
	SDLK_KP0		= 256,
	SDLK_KP1		= 257,
	SDLK_KP2		= 258,
	SDLK_KP3		= 259,
	SDLK_KP4		= 260,
	SDLK_KP5		= 261,
	SDLK_KP6		= 262,
	SDLK_KP7		= 263,
	SDLK_KP8		= 264,
	SDLK_KP9		= 265,

donc, si on fait

SDLK_0 - SDLK_0 = 0
SDLK_1 - SDLK_0 = 1
....
SDLK_9 - SDLK_0 = 9

[astyan42]

Ahh oui c'est vraiment pratique ce petit truc merci beaucoup
bon en fait tu conseilles aussi de libérer la mémoire allouée, mais ce qu'il se passe, c'est que j'ai un problème quand je fais free(mes tableaux de surfaces) mon programme plante aléatoirement en fait :s
(j'ai aussi essayé avec SDL_freesurface et ca fonctionne pas non plus ( j'arrive au meme résultat :/)

[SofEvans]

Cela vient probablement du fait que :

tu libere deux fois la memoire
tu libere la memoire alors que tu en as encore besoins

En tous les cas, il nous faudrai du code


Voici une autre fonction "corrigé"

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
 
void affichagemenu()
{
    SDL_Surface *ecran = SDL_GetVideoSurface();
 
    SDL_Surface *fondfenetre = SDL_LoadBMP("menu.bmp");
    if (fondfenetre == NULL)
    {
        fprintf(stderr, "Erreur lors du chargement de fondfenetre avec le chemin \"menu.bmp\" dans la fonction affichagemenu : %s \n", SDL_GetError());
        return;
    }
 
    /* Si les dimension de fondfenetre == dimension ecran, alors cette ligne est strictement inutile */
    SDL_FillRect(ecran, NULL, SDL_MapRGB(ecran->format, 255, 255, 255)); //le fond de la fenetre devient blanc
    /* Le quatrime argument a NULL correspond aux coordonné (0,0) */
    SDL_BlitSurface(fondfenetre,NULL,ecran,NULL);
    SDL_Flip(ecran);
 
 
    SDL_FreeSurface(fondfenetre);
 
    /* Ceci doit etre fais une fois au debut du main
        SDL_WM_SetCaption("Futoshiki", NULL); // Je renomme ma fenetre
        ecran = SDL_SetVideoMode(800, 600, 32, SDL_HWSURFACE); // Ouverture de la fenêtre
    */
}

[astyan42]

et avec cette fonction SDL_GetVideoSurface(), on est plus obligé de déclarer ecran ce genre de chose la est il a proscrire ? parce que ca fonctionne, mais bon ^^'

Code :

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

1
2
3
4
5
 
    SDL_FillRect(SDL_GetVideoSurface(), NULL, SDL_MapRGB(SDL_GetVideoSurface()->format, 255, 255, 255)); //le fond de la fenetre devient blanc
    fondfenetre = SDL_LoadBMP("menu.bmp");
    SDL_BlitSurface(fondfenetre,NULL,SDL_GetVideoSurface(),&positionfond);
    SDL_Flip(SDL_GetVideoSurface());

au passage les fichiers me servaient simplement de logs pour essayer de tracer mon erreur

[SofEvans]

Bon, tu peut te passer de fichier et faire un fprintf sur stderr ou sur stdout. ca economisera du code.

Pour ton interrogation sur SDL_GetVideoSurface()

Tu peux tout a fait faire ceci. Le seul probleme, c'est que si tu fais une boucle de jeu sur laquelle tu fais 18 blit et un SDL_FLip, tu aura donc a chaque tour de boucle 19 appel alors qu'un seul suffirai.

Les deux methode se valent.

Ton erreur persiste ?

[astyan42]

ben j'essaie de libérer ma mémoire mais ca me fait planter pour le moment je poste, mais je dois pas m'y prendre comme il faut pour libérer mon tableau de surface...

Code :

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

1
2
3
4
5
 
for(i=0;i<id_signe+id_chiffre;i++)
{
     SDL_FreeSurface(surface[id_signe+id_chiffre]);
}

Je fais ca en toute fin de fonction et ca ne fonctionne toujours pas :/

Edit: et pour les SDL_rect alloués avec malloc, je les libères avec un free ? ou il existe une autre fonction de SDL pour libérer la mémoire ?

[SofEvans]

1 malloc = 1 free (mais je ne vois pas pourquoi tu as fait un malloc sur un SDL_Rect)

Pour ton code,

Code :

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

1
2
3
4
5
 
for(i=0;i<id_signe+id_chiffre;i++)
{
     SDL_FreeSurface(surface[id_signe+id_chiffre]);
}

l'indice id_signe+id_chiffre n'evolue pas, c'est i qui evolue, donc tu libere constamment la meme memoire.


Le meiux serai de faire ceci :

Code :

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

1
2
3
4
5
 
for(i=0 ; i<TAILLE_TABLEAU ; i++)
{
     SDL_FreeSurface(surface[i]);
}

A condition que le tableau se nomme surface et que la valeur qui remplace TAILLE_TABLEAU soit effectiviement representative de la taille du tableau.

[astyan42]

euh ben parce que ce sont des tableaux de SDL rect en fait,... pour pouvoir placer chacune de mes surfaces a la bonne place

[SofEvans]

Donc ce n'est pas SDL_Rect qui est alloué, mais SDL_Rect*
Tu obtient donc un tableau unidimentionnel de SDL_Rect (et non SDL_rect*).
Pour liberer ca, tu as juste a faire un free sur le tableau, et non sur chacun des elements.


As tu encore des probleme ?

Je t'invite a reposter ton code si besoin est.

[astyan42]

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<(( taillegrille * taillegrille ) + (( taillegrille + taillegrille-1) * taillegrille-1 )) ; i++)
        {
            SDL_FreeSurface(surface[i]);
        }
 
    SDL_FreeSurface(texte);
    SDL_FreeSurface(res);
    free(positionC);
    free(positionS);
    return EXIT_SUCCESS; // Fermeture du programme

Tu me confirme que je me suis pas trompé sur les free ?
parce que avec des libérations comme cela , ca ne fonctionne pas :s

[fearyourself]

Comment cela ne fonctionne pas ? Il faudrait voir le code entier et compilable pour qu'on puisse te répondre.

Jc

[SofEvans]

En realité, nous avons tenu une conversation MSN pendant laquelle j'ai rectifier les erreurs.
Cela venait du fait que "astyan42" souhaiter modeliser entierement un "Futoshiki" et s'y prenait de maniere plus ou moins adroite, cequi a entrainer des SegFault.

Le code a était entierement remodeler depuis et n'a rien a voir avec le precedent.