Erreur dans for

**darkwall_37** · 17/05/2008, 13h34

Bonjour,

J'ai un problème avec tous mes 'for' !

Ce que me retourne Dev C++

voici le 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
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 <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <SDL/SDL.h>
#include <windows.h>
 
void pause();
 
int main (int argc, char *argv[])
{
 
    /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    //                                                   SDL                                                           //
    /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
    SDL_Surface *ecran = NULL; 
 
 
    SDL_Init(SDL_INIT_VIDEO);
 
    ecran = SDL_SetVideoMode(640, 480, 32, SDL_HWSURFACE); 
    if (ecran == NULL) 
    {
        fprintf(stderr, "Impossible de charger le mode vidéo : %s\nq", SDL_GetError());
        exit(EXIT_FAILURE);
    }
 
    SDL_WM_SetCaption("PROJET SDL", NULL);
 
    pause();
 
    SDL_Quit();
 
    return EXIT_SUCCESS;
}
 
 
 
    /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    //                                      GENERATION D'UN TABLEAU DE VALEURS POUR E                                  //
    /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
    int i, j;
    float E[641][481];
 
    for ( i=0 ; i<=640 ; i++ )
        {
              for ( j=0 ; j<=480 ; j++ )
                  {
                        E[i][j]=(1000/(i*j+1));
                  }
        }
 
    ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    //                                                 NORMALISATION DU CHAMPS                                           //
    ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
    int k, l;
    float E_NORM[641][481];
 
    for ( i=0 ; i<=640 ; i++ )
        {
              for ( j=0 ; j<=480 ; j++ )
                  {
                        E_NORM[i][j]=E[i][j]/E[0][0];
                  }
        }
 
    ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    //                                                ASSOCIATION DES COULEURS                                           //
    ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
    int m, n;
    float intervalle0=0;
    float intervalle1=0.01;
    int pas=0;
    Uint32 couleur[641][481];
 
    for ( m=0 ; m <= 640 ; m++ )
		     {
                  for ( n=0 ; n <= 480 ; n++ )
		      	      {
                                   while ( intervalle1 <= 2 )
                                    	  {
                                                      if  (   ( E[m][n] >= -1 + intervalle0 )&&( E[m][n] >= -1 + intervalle1 )   )
                                                          {
                                                              couleur[m][n]= SDL_MapRGB (  ecran -> format, pas, pas, pas);
                                                          }
 
                                                    else  {  intervalle0 = intervalle0 +0.01 ; intervalle1 = intervalle +0.01 ; pas++; }
                                          }
                       }
 
     //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
     //                                                  AFFICHAGE DU CHAMP                                              //
     //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
     int o, p;
     SDL_Rect position;
     SDL_Surface *pixel[641][481]=NULL;
 
     for ( o=0 ; o <= 640 ; o++ )
		     {
                 for ( p=0 ; p <= 480 ; p++ )
          		     {
                           position.x=o;
                           position.y=p;
                           SDL_FillRect   ( pixel[o][p] , NULL, Couleur[o][p]            );
				           SDL_BlitSurface( pixel[o][p] , NULL, ecran        , &position );                                                      //position à définir
			         }
 
     SDL_Flip(ecran);
 
 
 
 
 
}
 
 
void pause()
{
    int continuer = 1;
    SDL_Event event;
 
    while (continuer)
    {
        SDL_WaitEvent(&event);
        switch(event.type)
        {
            case SDL_QUIT:
                continuer = 0;
        }
    }
}

Cordialement

**droggo** · 17/05/2008, 13h59

Gao,

Envoyé par darkwall_37

Code :

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

1
2
3
4
5
6
7
8
9
...
/* à partir d'ici, le code n'est pas dans une fonction,
    je n'ai pas lu plus loin */
    int i, j;
    float E[641][481];
 
    for ( i=0 ; i<=640 ; i++ )
        {
...

**darkwall_37** · 17/05/2008, 16h13

Ah oui merci ! et dans la hate j'avais oublier certain truks ^^

Maintenant y'a plus d'erreur de compilation, mais j'ai du faire des sottises une fois de plus avec les pointeurs, encore un problème de mémoire je suppose.

Voici le nouveau 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
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
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <SDL/SDL.h>
#include <windows.h>
 
void pause();
 
int main (int argc, char *argv[])
{
 
    /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    //                                                   SDL                                                           //
    /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
    SDL_Surface *ecran = NULL; 
 
 
    SDL_Init(SDL_INIT_VIDEO);
 
    ecran = SDL_SetVideoMode(640, 480, 32, SDL_HWSURFACE); 
    if (ecran == NULL) 
    {
        fprintf(stderr, "Impossible de charger le mode vidéo : %s\nq", SDL_GetError());
        exit(EXIT_FAILURE);
    }
 
    SDL_WM_SetCaption("PROJET SDL", NULL);
 
 
 
 
 
 
    /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    //                                      GENERATION D'UN TABLEAU DE VALEURS POUR E                                  //
    /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
    int i, j;
    float E[641][481];
 
    for ( i=0 ; i<=640 ; i++ )
        {
              for ( j=0 ; j<=480 ; j++ )
                  {
                        E[i][j]=(1000/(i*j+1));
                  }
        }
 
    ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    //                                                 NORMALISATION DU CHAMPS                                           //
    ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
    int k, l;
    float E_NORM[641][481];
 
    for ( i=0 ; i<=640 ; i++ )
        {
              for ( j=0 ; j<=480 ; j++ )
                  {
                        E_NORM[i][j]=E[i][j]/E[0][0]; //E[0][0] étant la valeur max du tableau 
                  }
        }
 
    ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    //                                                ASSOCIATION DES COULEURS                                           //
    ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
    int m, n;
    float intervalle0=0;
    float intervalle1=0.01;
    int pas=0;
    Uint32 couleur[641][481];
 
    for ( m=0 ; m <= 640 ; m++ )
		     {
                  for ( n=0 ; n <= 480 ; n++ )
		      	      {
                                   while ( intervalle1 <= 2 )
                                    	  {
                                                      if  (   ( E_NORM[m][n] >= -1 + intervalle0 )&&( E_NORM[m][n] >= -1 + intervalle1 )   )
                                                          {
                                                              couleur[m][n]= SDL_MapRGB (  ecran -> format, pas, pas, pas);
                                                          }
 
                                                    else  {  intervalle0 = intervalle0 +0.01 ; intervalle1 = intervalle1 +0.01 ; pas++; }
                                          }
                       }
             }
     //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
     //                                                  AFFICHAGE DU CHAMP                                              //
     //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
     int o, p, s, t;
     SDL_Rect position;
     SDL_Surface *pixel[641][481]={NULL};
 
 
     for ( s=0 ; s <= 640 ; s++ )
		     {
                 for ( t=0 ; t <= 480 ; t++ )
          		     {
                           pixel[s][t]=SDL_CreateRGBSurface(SDL_HWSURFACE, 1, 1, 32, 0, 0, 0, 0);                                                 //position à définir
			         }
             }
 
 
     for ( o=0 ; o <= 640 ; o++ )
		     {
                 for ( p=0 ; p <= 480 ; p++ )
          		     {
                           position.x=o;
                           position.y=p;
                           SDL_FillRect   ( pixel[o][p] , NULL, couleur[o][p]            );
				           SDL_BlitSurface( pixel[o][p] , NULL, ecran        , &position );                                                      //position à définir
			         }
             }
 
     SDL_Flip(ecran);
 
 
     pause();
 
     int q, r;
 
     for ( q=0 ; q <= 641 ; q++ )
         {
               for ( r=0 ; r <= 481 ; r++ )
                   {
                         SDL_FreeSurface(pixel[q][r]);
                   }
         }
 
     SDL_FreeSurface(ecran);
 
     SDL_Quit();
 
     return EXIT_SUCCESS;   
 
 
}
 
 
void pause()
{
    int continuer = 1;
    SDL_Event event;
 
    while (continuer)
    {
        SDL_WaitEvent(&event);
        switch(event.type)
        {
            case SDL_QUIT:
                continuer = 0;
        }
    }
}

Merci d'avance

**droggo** · 17/05/2008, 17h33

Jai,

Il serait agréable pour nous que tu fasses un effort pour nous dire quel est le problème.

**darkwall_37** · 17/05/2008, 18h01

Je ne peux rien ajouter de plus si cela n'est que j'e n'ai pas d'erreur à la compilation et que lorsque le programme se lance il plante et la fenêtre d'erreur de windows apparait avec 'envoyer' ou 'ne pas envoyer' !
Je suis désolé Dev C++ ne me dit rien de plus !

**souviron34** · 17/05/2008, 18h29

je répète encore une fois, meilleure méthode de débuggage dans ce cas-là :

mettre en commentaires des blocs les uns après les autres, et voir lequel fait planter.

Puis investiger pourquoi..

Sinon se servir d'un vrai debugger, et quand ça crashe, remonter à l'origine...

**Emmanuel Delahaye** · 21/05/2008, 23h05

Envoyé par darkwall_37

Ah oui merci ! et dans la hate j'avais oublier certain truks ^^

Maintenant y'a plus d'erreur de compilation, mais j'ai du faire des sottises une fois de plus avec les pointeurs, encore un problème de mémoire je suppose.

Code :

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

1
2
3
4
         float E[641][481];
         float E_NORM[641][481];
         Uint32 couleur[641][481];
         SDL_Surface *pixel[641][481] = { {NULL} };

Trop de données en mémoire automatique.
Quick and dirty hack :

Code :

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

1
2
3
4
         static float E[641][481];
         static float E_NORM[641][481];
         static Uint32 couleur[641][481];
         static SDL_Surface *pixel[641][481] = { {NULL} };

Je ne sais pas où tu en es du C, mais tu devrais utiliser un tableau de structure plutôt de 4 tableaux de même dimensions et tailles...

Ensuite, les gros objets, en principe on les allouent dynamiquement mais le 'static' est OK dans un main()...

Ceci commence à fonctionner. Bien lire mon commentaire :

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
 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <SDL/SDL.h>
#include <windows.h>
 
void pause (void)
{
   int continuer = 1;
 
   while (continuer)
   {
      SDL_Event event;
      SDL_WaitEvent (&event);
      switch (event.type)
      {
      case SDL_QUIT:
         continuer = 0;
      }
   }
}
 
int main (int argc, char *argv[])
{
/* SDL */
 
 
   SDL_Init (SDL_INIT_VIDEO);
   {
      SDL_Surface *ecran = SDL_SetVideoMode (640, 480, 32, SDL_HWSURFACE);
      if (ecran == NULL)
      {
         fprintf (stderr, "Impossible de charger le mode vidéo : %s\nq",
                  SDL_GetError ());
         exit (EXIT_FAILURE);
      }
      else
      {
         static float E[641][481];
         static float E_NORM[641][481];
         static Uint32 couleur[641][481];
         static SDL_Surface *pixel[641][481] = { {NULL} };
 
         SDL_WM_SetCaption ("PROJET SDL", NULL);
 
/* GENERATION D'UN TABLEAU DE VALEURS POUR E */
         {
            int i, j;
 
            for (i = 0; i <= 640; i++)
            {
               for (j = 0; j <= 480; j++)
               {
                  E[i][j] = (1000 / (i * j + 1));
               }
            }
         }
 
/* NORMALISATION DU CHAMP */
         {
            int i;
 
            for (i = 0; i <= 640; i++)
            {
               int j;
               for (j = 0; j <= 480; j++)
               {
/* E[0][0] étant la valeur max du tableau */
                  E_NORM[i][j] = E[i][j] / E[0][0];
               }
            }
         }
 
/* ASSOCIATION DES COULEURS */
         {
            int m, n;
            float intervalle0 = 0;
            float intervalle1 = 0.01;
            int pas = 0;
 
            for (m = 0; m <= 640; m++)
            {
               for (n = 0; n <= 480; n++)
               {
#if 0
/* -ed- j'ai isolé cette boucle. On en sort jamais...
        Je ne sais pas ce que tu cherches à faire,
        mais ça ne fonctionne pas...
*/
                  while (intervalle1 <= 2)
                  {
                     if ((E_NORM[m][n] >= -1 + intervalle0)
                         && (E_NORM[m][n] >= -1 + intervalle1))
                     {
                        couleur[m][n] =
                           SDL_MapRGB (ecran->format, pas, pas, pas);
                     }
                     else
                     {
                        intervalle0 = intervalle0 + 0.01;
                        intervalle1 = intervalle1 + 0.01;
                        pas++;
                     }
                  }
#endif
               }
            }
         }
 
/* AFFICHAGE DU CHAMP */
 
         {
            int o, p, s, t;
            SDL_Rect position;
 
            for (s = 0; s <= 640; s++)
            {
               for (t = 0; t <= 480; t++)
               {
/* position à définir */
                  pixel[s][t] = SDL_CreateRGBSurface (SDL_HWSURFACE, 1, 1, 32, 0, 0, 0, 0);
               }
            }
 
            for (o = 0; o <= 640; o++)
            {
               for (p = 0; p <= 480; p++)
               {
                  position.x = o;
                  position.y = p;
                  SDL_FillRect (pixel[o][p], NULL, couleur[o][p]);
/* position à définir */
                  SDL_BlitSurface (pixel[o][p], NULL, ecran, &position);
               }
            }
         }
         SDL_Flip (ecran);
 
         pause ();
 
         {
            int q, r;
 
            for (q = 0; q <= 641; q++)
            {
               for (r = 0; r <= 481; r++)
               {
                  SDL_FreeSurface (pixel[q][r]);
               }
            }
         }
         SDL_FreeSurface (ecran);
      }
   }
   SDL_Quit ();
 
   return EXIT_SUCCESS;
 
}

**darkwall_37** · 23/05/2008, 14h49

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
 
int a,b;
int c=0;
Uint32 couleur[300][300];
float pas=1/255;
float intervalle0=0;
float intervalle1=pas;
 
for ( a=0 ; a <= 299 ; a++ )
{
    for ( b=0 ; b <= 299 ; b++ )
   {		
        while ( intervalle1 <= 1 )
        {                                   
            if  (   ( E_NORM[a][b] >= intervalle0 )&&( E_NORM[a][b] <= intervalle1 ) ) // On test les valeur de E_NORM à des intervalles prédéfinis (0 à 1/255) pour lui associer une couleur 
            {
                 couleur[a][b]= SDL_MapRGB (  ecran -> format, (int)(intervalle1*255), (int)(intervalle1*255), (int)(intervalle1*255) );  // Si E_NORM appartient à l'intervalle, on lui associe un code couleur
            }
            else   
            {                        
                  intervalle0 = (intervalle0 + pas ); // Si E_NORM n'appartient pas à l'intervalle, on incrémente les bornes de l'intervalle et le pas
                  intervalle1 = (intervalle1 + pas );  
            }
        }
   }
}

En fait le tableau E est une simulation des valeurs que prend un champ éléctrique. E_NORM correspond en fait à la normalisation de E c'est à dire que j'ai ramené les valeurs du champs dans un intervalle de 0 à 1. J'ai besoin de faire ça car la norme du champ n'est pas toujours la même, pour le moment si mais plus tard non un utilisateur choisira le nombre de charges.... et y'aura les vrai formule. Là je cherche à voir si déjà l'affichage du champs marche !
Cette boucle me permet normalement d'assoscier une couleur au pixel en fonction de l'intensité du champ. J'ai choisi un pas de 1/255 puisque je progresse ainsi 0,0,0 1,1,1 .... 255,255,255. Et normalement je n'ai pas de débordement, je suis sur que le code couleur est correct. Si la norme est compris dans l'intervalle on lui associe un code couleur. Si ce n'est pas le cas on recommence le test en incrémentant l'intervalle !

Il y'avait encore des erreurs dans la boucle. J'avais oublié de remettre les test sur 0-1, c'était encore sur -1-1 et puis pas++; en fait ne sert pas c'est une de mes lubies ^^. Cependant ça plante toujours ! J'espère que vous avec mieux compris ce que je veux faire avec cette boucle !

Merci d'avance

**Overcrash** · 29/05/2008, 13h29

dev cpp ...

conseil : cours chercher code blocks ("gratuit")

devcpp ça fait longtemps qu'il évolue plus !

++ over

Erreur dans for

C

Vue hybride

Discussions similaires

Partager

Partager