Problème de dépassement de tableau

Bonsoir,

Voila je fais une affectation toute bête dans un tableau à 2 dimensions et lorsque j'exécute mon programme j'ai droit à un beau stack overflow...:( Hélas je n'arrive même pas à voir ou:cry:

Voici le code:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 int map[600][600]; for(i = 0; i < 600; i++) { for(j = 0; j < 600; j++) { z = rand() % (200+1); if(z > 190) { map[i][j] = 1; } else { map[i][j] = 0; } } }
Si quelqu'un arrive à voir ce qui va pas parce que moi non :roll: Merci :)

Probablement parce que ta pile n'est pas assez grande pour contenir le tableau map, ce qui est possible sous DOS ou un Linux très ancien. Poste un code complet simple qui expose ton problème et précise le compilateur que tu utilises.

En fait j'essaie de faire un jeu de la vie en SDL. C'est le tableau "map" qui me pose problème. Si je décommente certaines de ses occurences il plante. Voici donc le code:

life.h

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
 
#ifndef LIFE_H_INCLUDED
#define LIFE_H_INCLUDED
 
typedef struct pclic
{
    int x;
    int y;
} clic;
 
int create_life(SDL_Surface* screen);
int check_position(int map[L_WINDOW][H_WINDOW], int i, int j);
int action(clic *a_clic);
void print_square(int i, int j, SDL_Surface* surface, SDL_Surface* screen, SDL_Color* color);
 
#endif /* LIFE_H_INCLUDED */

life.c

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
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
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
 
#include <stdlib.h>
#include <stdio.h>
#include <SDL/SDL.h>
#include "const.h"
#include "life.h"
 
int create_life(SDL_Surface* screen)
{
    SDL_Surface *surface = NULL; /* surface servant a' afficher les cases */
    SDL_Color black, white, red, green, blue, yellow;
    SDL_Color color_of_case;
    clic my_clic;
 
    int map[L_WINDOW][H_WINDOW];
    int time_now = 0, time_before = 0;
    int i, j;
    int generation = 0;
    int game = 0; /* Permet de savoir l'etat du jeu: start, pause, stop */
    int speed = SLOW;
    int z = 0; /* variable servant a tout */
 
    signed int world = SUCCESS;
 
    surface = SDL_CreateRGBSurface(SDL_HWSURFACE, SIZE_OF_CASE, SIZE_OF_CASE, 32, 0, 0, 0, 0); /* On forme une surface generale de type carre */
 
    black.r = 0;
    black.g = 0;
    black.b = 0;
    white.r = 250;
    white.g = 250;
    white.b = 250;
    red.r = 250;
    red.g = 0;
    red.b = 0;
    green.r = 0;
    green.r = 250;
    green.g = 0;
    blue.r = 0;
    blue.g = 0;
    blue.b = 250;
    yellow.r = 250;
    yellow.g = 240;
    yellow.b = 0;
 
    /* Ici on choisit une unique fois la couleur des cases */
    color_of_case = red;
 
    /* On initialise chaque case aleatoirement*/
    for(i = 0; i < L_WINDOW; i++)
    {
        for(j = 0; j < H_WINDOW; j++)
        {
            z = rand() % (200+1);
            if(z > 190)
            {
                print_square(i, j, surface, screen, &color_of_case);  /* Voir plus bas dans le code */
				//map[i][j] = FULL;
            }
            else
            {
                //map[i][j] = BLANK; /* BLANK = case vide */
            }
        }
    }
 
    while(world == SUCCESS) /* On demarre la boucle des vies */
    {
        SDL_FillRect(screen, NULL, SDL_MapRGB(screen->format, 0, 0, 0)); /* On affiche le fond */
 
        time_now = SDL_GetTicks()/1000;
 
        if((time_now-time_before) >= speed) /* Si le temps ecoule' est >= a' la vitesse du jeu alors : */
        {
            time_before = time_now;
 
            if(game != PAUSE || game != STOP)
            {
                generation++;
 
                for(i = 0; i < L_WINDOW; i++) /* On calcul les possibilites des cases FULL */
                {
                    for(j = 0; j < H_WINDOW; j++)
                    {
//                        if(map[i][j] == FULL)
//                        {
//                            if(game != PAUSE) /* Si le jeu n'est pas en pause */
//                            {
//                                z = check_position(map, i, j);
//
//                                if(z <= 1 || z >= 4)
//                                {
//                                    map[i][j] = DEAD; /* cellule morte */
//                                }
//                            }
//                        }
                    }
                }
 
                for(i = 0; i < L_WINDOW; i++) /* On calcul les possibilites des cases BLANK */
                {
                    for(j = 0; j < H_WINDOW; j++)
                    {
//                        if(map[i][j] == BLANK)
//                        {
//                            if(game != PAUSE)
//                            {
//                                z = check_position(map, i, j);
//
//                                if(z == 3)
//                                {
//                                    map[i][j] = NEAR;
//                                }
//                            }
//                        }
                    }
                }
 
                for(i = 0; i < L_WINDOW; i++) /* On affiche les cellules */
                {
                    for(j = 0; j < H_WINDOW; j++)
                    {
//                        if(map[i][j] == FULL)
//                        {
//                            print_square(i, j, surface, screen, &color_of_case);
//                        }
//                        else if(map[i][j] == NEAR)
//                        {
//                            print_square(i, j, surface, screen, &color_of_case);
//                            map[i][j] = FULL;
//                        }
//                        else if(map[i][j] == DEAD)
//                        {
//                            map[i][j] = BLANK;
//                        }
                    }
                }
            }
        }
        else /* Si le temps ne s'est pas ecoule', on affiche quand même toutes les cellules */
        {
            for(i = 0; i < L_WINDOW; i++)
            {
                for(j = 0; j < H_WINDOW; j++)
                {
//                    if(map[i][j] == FULL)
//                    {
//                        print_square(i, j, surface, screen, &color_of_case);
//                    }
                }
            }
        }
 
        z = action(&my_clic); /* On ve'rifie ce que fait l'utilisateur, voir plus bas dans le code */
 
        if(z == Q)
        {
            world = ERROR; /* On quitte */
        }
        else if(z == P)
        {
            game = PAUSE; /* On met le jeu en pause */
        }
        else if(z == S)
        {
            game = START; /* On (re)lance le jeu */
        }
        else if(z == V)
        {
            if(speed == SLOW)
            {
                speed = MEDIUM;
            }
            else if(speed == MEDIUM)
            {
                speed = SLOW;
            }
        }
        else if(z == CLIC)
        {
//            if(map[my_clic.x/SIZE_OF_CASE][my_clic.y/SIZE_OF_CASE] == BLANK)
//            {
//                i = my_clic.x/SIZE_OF_CASE;
//                j = my_clic.y/SIZE_OF_CASE;
//
//                print_square(i, j, surface, screen, &color_of_case);
//                map[my_clic.x/SIZE_OF_CASE][my_clic.y/SIZE_OF_CASE] = FULL;
//            }
//
//            else if(map[my_clic.x/SIZE_OF_CASE][my_clic.y/SIZE_OF_CASE] == FULL)
//            {
//                map[my_clic.x/SIZE_OF_CASE][my_clic.y/SIZE_OF_CASE] = BLANK;
//            }
        }
        else if(z == RAZ) /* L'utilisateur veut tout supprimer */
        {
            for(i = 0; i < L_WINDOW; i++)
            {
                for(j = 0; j < H_WINDOW; j++)
                {
//                    map[i][j] = BLANK;
                }
            }
        }
 
        SDL_Flip(screen); /* On met a' jour l'e'cran */
    }
 
    SDL_FreeSurface(surface);
 
    return SUCCESS;
}
 
int check_position(int map[L_WINDOW][H_WINDOW], int i, int j) /* On calcul les possibilites de la cellule en position i,j */
{
    int z = 0;
 
    if((i+1) < L_WINDOW)
    {
//        if(map[i+1][j] != BLANK || map[i+1][j] == DEAD)
//        {
//            z++;
//        }
    }
 
    if((j+1) < H_WINDOW)
    {
//        if(map[i][j+1] == FULL || map[i][j+1] == DEAD)
//        {
//            z++;
//        }
    }
 
    if((i+1) < L_WINDOW && (j+1) < H_WINDOW)
    {
//        if(map[i+1][j+1] == FULL || map[i+1][j+1] == DEAD)
//        {
//            z++;
//        }
    }
 
    if((i-1) > 1)
    {
//        if(map[i-1][j] == FULL || map[i-1][j] == DEAD)
//        {
//            z++;
//        }
    }
 
    if((i-1) > 1 && (j+1) < H_WINDOW)
    {
//        if(map[i-1][j+1] == FULL || map[i-1][j+1] == DEAD)
//        {
//           z++;
//        }
    }
 
    if((j-1) > 1)
    {
//        if(map[i][j-1] == FULL || map[i][j-1] == DEAD)
//        {
//            z++;
//        }
    }
 
    if((i+1) < L_WINDOW && (j-1) > 0)
    {
//        if(map[i+1][j-1] == FULL || map[i+1][j-1] == DEAD)
//        {
//            z++;
//        }
    }
 
    if((i-1) > 1 && (j-1) > 1)
    {
//        if(map[i-1][j-1] == FULL || map[i-1][j-1] == DEAD)
//        {
//            z++;
//        }
    }
 
    return z;
}
 
int action(clic *a_clic)
{
    SDL_Event event;
    int rslt = NOTHING;
 
    while(SDL_PollEvent(&event))
    {
        if(event.type == SDL_QUIT)
        {
            rslt = Q;
        }
        else if(event.type == SDL_MOUSEBUTTONUP)
        {
            if (event.button.button == SDL_BUTTON_LEFT)
            {
                /*
                    Volonte' de tuer ou de creer ainsi,
                    on stock la position en x et y du clic.
                */
                a_clic->x = event.button.x;
                a_clic->y = event.button.y;
                fprintf(stdout, "Clic en (%d;%d) de l'utilisateur\n", a_clic->x, a_clic->y);
                rslt = CLIC;
            }
        }
        else if(event.type == SDL_KEYUP)
        {
            if(event.key.keysym.sym == SDLK_p)  /* P = PAUSE, S = START, Q = QUITTER et V = VITESSE*/
            {
                rslt = P;
                fprintf(stdout, "Jeu en pause\n");
            }
            else if(event.key.keysym.sym == SDLK_s)
            {
                rslt = S;
                fprintf(stdout, "Jeu commence'\n");
            }
            else if(event.key.keysym.sym == SDLK_a) /* q en azrty = a en qwerty or la sdl = qwerty */
            {
                rslt = Q;
                fprintf(stdout, "Fin du programme\n");
            }
            else if(event.key.keysym.sym == SDLK_v)
            {
                rslt = V;
                fprintf(stdout, "Changement de vitesse\n");
            }
            else if(event.key.keysym.sym == SDLK_r)
            {
                rslt = RAZ;
                fprintf(stdout, "Suppression de toutes les cellules\n");
            }
        }
        else
        {
            rslt = NOTHING;
        }
    }
 
    return rslt;
}
 
void print_square(int i, int j, SDL_Surface* surface, SDL_Surface* screen, SDL_Color* color)
{
    SDL_Rect position;
    int r = 0, g = 0, b = 0;
 
    r = color->r;
    g = color->g;
    b = color->b;
 
    position.x = i*SIZE_OF_CASE;
    position.y = j*SIZE_OF_CASE;
    SDL_FillRect(surface, NULL, SDL_MapRGB(screen->format, r, g, b));
    SDL_BlitSurface(surface, NULL, screen, &position);
}

const.h

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
 
#ifndef CONST_H_INCLUDED
#define CONST_H_INCLUDED
 
#define ERROR           -1
#define SUCCESS         0
 
#define SLOW            2 /* 2 secondes par etapes */
#define MEDIUM          1 /* 1 seconde */
 
#define SIZE_OF_CASE    10 /* en pixels */
#define NBR_OF_CASES    60
#define L_WINDOW        SIZE_OF_CASE*NBR_OF_CASES
#define H_WINDOW        SIZE_OF_CASE*NBR_OF_CASES
 
enum{BLANK, DEAD, NEAR, FULL};
enum{NOTHING, CLIC, P, S, Q, V, RAZ};
enum{START, PAUSE, STOP};
 
#endif /* CONST_H_INCLUDED */

Mon compilateur est Visual Studio 2010. Je sais que je peux augmenter la taille reserver pour la pile dans les propriétés mais je sais pas si c'est correct de faire ça:oops: et si oui combien mettre:aie:

Moi aussi je me suis un petit peu planté :oops:. En fait, je croyais qu'un tableau de 600 * 600 int c'est petit mais en fait c'est gigantesque ! La taille de ce tableau est 600 * 600 * sizeof(int) soit 1 440 000 octets, c'est-à-dire nettement plus de 1 Mo or 1 Mo c'est la taille par défaut de chaque pile sous Windows. Plutôt que d'augmenter la taille de la pile, pour des tableaux aussi grands, il est toujours recommandé de créer le tableau avec malloc. Sinon, déclare le tableau statique ( static int map[L_WINDOW][H_WINDOW]; ).

En effet le fait d'ajouter "static" à résolu le problème :) Merci beaucoup:ccool: