Probléme d'argument dans une fonction

Version imprimable

Bonjour à tous,

J'ai décider de m'atteler à un problème que j'ai depuis que j'ai commencé à programmer en C ...

Le passage en argument pour des fonctions !!!!!!
Primordiale pour la découpe d'un code et l'optimisation, je suis confronté à cette lacune.

Voila mon problème:

Dans mon main.c, je défini les 5 objets suivant:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 
SDL_Rect *positionobjet;
positionobjet = malloc (10*sizeof(SDL_Rect) );
for( i=0;i<10;i++)
    {
        positionobjet[i].x  = 0;
        positionobjet[i].y  = 0;
    }
 
Struct B_B_Cercle boxC1objet[10];
Struct B_B_Cercle boxC2objet[10];
 
SDL_Surface *objet[10]; /* il est remplie de sprite de corps céleste ( météorite,planète,étoile ... )
 
int h,w;

La structure B_B_Cercle est :

Code:

1
2
3
4
5
6
7
8
 
typedef struct B_B_Cercle B_B_Cercle;
struct B_B_Cercle
{
   int x;
   int y;
   int rayon;
};

Voila pour les déclarations.
Je souhaite ensuite créer une fonction qui appelle ces 5 objets pour remplir les structures B_B_Cercle boxC1objet et B_B_Cercle boxC1objet.

J'ai crée la fonction suivant:

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
 
double frand_a_b(double a, double b);
 
void init_B_B_cercle_objet(SDL_Rect **position_objet,B_B_Cercle BC1[],B_B_Cercle BC2[],SDL_Surface *objet[],int h,int w)
{
 
    int nombre_aleatoire1=0,nombre_aleatoire2=0, i;
    srand(time(0));
    int a=0;
 
    for( i=0;i<10;i++)
    {
        /* on remplie le tableau de SDl_Rect positionobjet grâce à la fonction aléatoire frand */
        int b1,b2;
        b1=w-objet[i]->w;
        b2=h-objet[i]->h;
        nombre_aleatoire1=frand_a_b(a,b1);
        nombre_aleatoire2=frand_a_b(a,b2);
        position_objet[i]->x  = nombre_aleatoire1 ;
        position_objet[i]->y  = nombre_aleatoire2 ;
 
        /* On remplie le tableau de boite de test C1*/
        BC1[i].x= position_objet[i]->x + objet[i]->w/2;
        BC1[i].y= position_objet[i]->y + objet[i]->h/2;
        BC1[i].rayon=objet[i]->w/2;
 
        /* On remplie le tableau de boite de test C2*/
        BC2[i].x= BC1[i].x;
        BC2[i].y= BC1[i].y;
        BC2[i].rayon=objet[i]->w/2+4;
    }
}
 
double frand_a_b(double a, double b)
{
    return (rand()/(double)RAND_MAX)*(b-a) +a;
}

Elle est plutôt courte ^^
Ensuite j'appelle la fonction dans mon main.

Code:

1
2
 
init_B_B_cercle_objet(&positionobjet,boxC1objet[10],boxC2objet[10],objet[10]),h,w);

... et la c'est le drame :(

J'ai besoin d'un avis extérieur car je suis paumé.

Mercie d'avance

Maxime

Citation:

Envoyé par maximus35

... et la c'est le drame :(

J'ai besoin d'un avis extérieur car je suis paumé.

Mercie d'avance

Maxime

Salut

Pourquoi ta fonction init_B_B_cercle_objet reçoit un SDL_Rect étoile étoile ??? Tu travailles en 1 dimension !!! Ton élément dans ton main() est un simple tableau (tout comme un char *)...

Enlève une étoile dans ta fonction et ce "&" lors de son appel dans le main() et ça devrait fonctionner...
Citation:
Envoyé par maximus35
Code:

1 2 3 4 5 /* il est remplie de sprite de corps céleste ( météorite,planète,étoile ... ) /* on remplie le tableau de SDl_Rect positionobjet grâce à la fonction aléatoire frand */ /* On remplie le tableau de boite de test C1*/ /* On remplie le tableau de boite de test C2*/
Au-moins il y a des commentaires. Dommage seulement que tu aies oublié comment on conjugue un verbe du 2° groupe...

Merci d'avoir répondu

Ce fait longtemps que je suis dessu, j'avais même pas vu ces fautes tellement le problème d'argument me tracasse :S

J'ai effectuer le changement.
Maintenant le code tourne mais il me revois 3 comme valeur erreur. c'est du segfault ca.
J'appelle un variable qui n'est pas définie :S.

Voila le code complet.
il est lourd mais comme il marche pas je n'effectue pas encore le découpage en fonction :(

Tous les fprintf marchent jusqu'à celui de la ligne 213.
Aprés, on rentre dans le fonction .... et ca plante :cry:

le code complet.

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
 
#include <stdlib.h>
#include <stdio.h>
#include <SDL.h>
#include <SDL_image.h>
#include <string.h>
#include <time.h>
#include <SDL_ttf.h>
#include "Bounding_Box.h"
#include "Fonction_Collision.h"
#include "init_B_B_cercle_objet.h"
 
void jouer(SDL_Surface *ecran)
{
 
    FILE* fichier = NULL;
    fichier=fopen("test.txt","w");
    fprintf(fichier, "ouverture du fichier\n");
 
    SDL_Surface *univers,*perso,*objet[10],*explosion;
    SDL_Rect position_perso,pos_fond,centreexplosion;
    /*SDL_Rect position_objet0,position_objet1,position_objet2,position_objet3,position_objet4,position_objet5,position_objet6,position_objet7,position_objet8,position_objet9;*/
 
    fprintf(fichier, "okay pour la declaration des variables\n");
 
    univers = SDL_LoadBMP("Environnement.bmp");
    int h,w,i;
    h=univers->h;
    w=univers->w;
 
    fprintf(fichier, "okay pour l'univers\n");
 
     SDL_Rect *positionobjet;
    positionobjet = malloc (10*sizeof(SDL_Rect) );
    for( i=0;i<10;i++)
    {
        positionobjet[i].x  = 0;
        positionobjet[i].y  = 0;
    }
    fprintf(fichier, "okay pour l'allocation du tableau de SDL_Rect positionobjet de taille 10\n");
 
 
    objet[0]= SDL_LoadBMP("meteorite.bmp");
    fprintf(fichier, "okay pour la meteorite\n");
 
    objet[1]= SDL_LoadBMP("asteroide.bmp");
    fprintf(fichier, "okay pour l asteroide\n");
 
    objet[2]= SDL_LoadBMP("petite_planete.bmp");
    fprintf(fichier, "okay pour la petite planete\n");
 
    objet[3]= SDL_LoadBMP("planete.bmp");
    fprintf(fichier, "okay pour la planete\n");
 
    objet[4]= SDL_LoadBMP("grosse_planete.bmp");
    fprintf(fichier, "okay pour la grosse planete\n");
 
    objet[5]= SDL_LoadBMP("grosse_planete.bmp");
    fprintf(fichier, "okay pour la grosse planete\n");
 
    objet[6]= SDL_LoadBMP("soleil_jaune.bmp");
    fprintf(fichier, "okay pour le soleil_jaune\n");
 
    objet[7]= SDL_LoadBMP("soleil_bleu.bmp");
    fprintf(fichier, "okay pour le soleil_bleu\n");
 
    objet[8]= SDL_LoadBMP("soleil_rouge.bmp");
    fprintf(fichier, "okay pour le soleil_rouge\n");
 
    objet[9]= SDL_LoadBMP("naine_blanche.bmp");
    fprintf(fichier, "okay pour la naine_blanche\n");
 
    explosion=SDL_LoadBMP("explosion2.bmp");
    fprintf(fichier, "okay pour l'explosion\n");
 
 
    centreexplosion.x=explosion->w/2;
    centreexplosion.y=explosion->h/2;
 
//on reduit le fond
    SDL_SetColorKey(objet[0], SDL_SRCCOLORKEY, SDL_MapRGB(objet[0]->format, 237,28,36));
    SDL_SetColorKey(objet[1], SDL_SRCCOLORKEY, SDL_MapRGB(objet[1]->format, 237,28,36));
    SDL_SetColorKey(objet[2], SDL_SRCCOLORKEY, SDL_MapRGB(objet[2]->format, 237,28,36));
    SDL_SetColorKey(objet[3], SDL_SRCCOLORKEY, SDL_MapRGB(objet[3]->format, 237,28,36));
    SDL_SetColorKey(objet[4], SDL_SRCCOLORKEY, SDL_MapRGB(objet[4]->format, 237,28,36));
    SDL_SetColorKey(explosion, SDL_SRCCOLORKEY, SDL_MapRGB(explosion->format, 237,28,36));
    fprintf(fichier, "okay pour la transparence\n");
 
    Input in;
	memset(&in,0,sizeof(in));
	fprintf(fichier, "okay pour la gestion des evenements\n");
 
  /* On place le joueur à l'écran */      
    position_perso.x = 460;    
    position_perso.y = 200; 
 
/* On place le joueur à l'écran */
	position_perso.x = ecran->w/4;
	position_perso.y = ecran->h/4;
 
    pos_fond.x=0;
    pos_fond.y=0;
 
    fprintf(fichier, "okay pour les positions\n");
 
    char nom1[]="meteorite";                                                                                            //////////////////////////////////////////////////
    char nom2[]="asteroide";                                                                                            //                                              //
    char nom3[]="petite planete";                                                                                       //                                              //
    char nom4[]="planete";                                                                                              //                                              //
    char nom5[]="grosse planete";                                                                                       // Penser à passer ces constantes dans un header//
                                                                                                                        // avec enum                                    //
                  /* la meteorite *//* l'asteroide *//* la petite planete *//* le planete *//* la grosse planete */     //                                              //
    char *nom[]={        nom1      ,      nom2      ,         nom3         ,      nom4     ,         nom5         };    //                                              //
    int type[]={          1        ,        2       ,           3          ,        4      ,           5          };    //                                              //
    int masse[]={         1        ,        4       ,          12          ,       24      ,          36          };    //////////////////////////////////////////////////
 
    corps M;            //////////////////////////////////////////////////////////////////
    corps A;            // Les structures corps vont servir a stocker les constantes    //
    corps PP;           //  de chaque corps celeste et à permettre un passage           //
    corps P;            //  en argument plus facile pour les divers fonctions           //
    corps GP;           //////////////////////////////////////////////////////////////////
 
 
    corps Perso;        // definie la classe du perso //
 
    M.nom=nom1;
    M.type=type[0];
    M.masse=masse[0];
    M.centrex=objet[0]->w/2;
    M.centrey=objet[0]->h/2;
 
    A.nom=nom2;
    A.type=type[1];
    A.masse=masse[1];
    A.centrex=objet[1]->w/2;
    A.centrey=objet[1]->h/2;
 
    PP.nom=nom3;
    PP.type=type[2];
    PP.masse=masse[2];
    PP.centrex=objet[2]->w/2;
    PP.centrey=objet[2]->h/2;
 
    P.nom=nom4;
    P.type=type[3];
    P.masse=masse[3];
    P.centrex=objet[3]->w/2;
    P.centrey=objet[3]->h/2;
 
    GP.nom=nom5;
    GP.type=type[4];
    GP.masse=masse[4];
    GP.centrex=objet[4]->w/2;
    GP.centrey=objet[4]->h/2;
 
    fprintf(fichier, "Sucee de la creation des structure corps \n");
 
    SDL_Init( SDL_INIT_VIDEO );
 
    if (SDL_Init(SDL_INIT_VIDEO) == -1) // Démarrage de la SDL. Si erreur alors...
    {
        fprintf(fichier, "echec du chargement de la SDL\n");
        exit(EXIT_FAILURE); // On quitte le programme
    }
 
 
    ecran = SDL_SetVideoMode(h, w, 16,SDL_HWSURFACE||SDL_DOUBLEBUF);
    SDL_WM_SetCaption("Galactic Craft Niveau", NULL);
 
    fprintf(fichier, "Sucee de l'initialisation de la SDL \n");
 
    SDL_Event event;
    int continuer = 1;
 
    SDL_ShowCursor(SDL_DISABLE);
 
    while( continuer )
	{
 
        SDL_PollEvent(&event);
        switch(event.type)
        {
            case SDL_QUIT:
            continuer = 0;
            break;
 
            case SDL_KEYDOWN:
            switch (event.key.keysym.sym)
            {
                case SDLK_ESCAPE:
                continuer = 0;
                break;
            }
            break;
 
            case SDL_MOUSEMOTION:
            position_perso.x = event.button.x;
            position_perso.y = event.button.y;
            break;
        }
 
// Box de test du perso//
        B_B_Cercle boxC1perso;
        boxC1perso.x=position_perso.x+objet[1]->w/2;
        boxC1perso.y=position_perso.y+objet[1]->w/2;
        boxC1perso.rayon=objet[0]->w/2+3;
 
        B_B_Cercle boxC2perso;
        boxC2perso.x=boxC1perso.x;
        boxC2perso.y=boxC1perso.y;
        boxC2perso.rayon=objet[0]->w/2;
 
       /*fprintf(fichier,"succe des allocations des boite de test du perso\n"); test okay */
 
// Box de collision des objets//
 
            B_B_Cercle boxC1objet[10];
            B_B_Cercle boxC2objet[10];
 
init_B_B_cercle_objet(positionobjet,boxC1objet,boxC2objet,objet[10],h,w);
 
        fprintf(fichier, "Sucée de la fontion init_B_Bcercle_objet\n");
 
// Variable tampon pour eviter les fuite de memoire//
        SDL_Surface *changement[11];
            changement[0]=objet[0];
            changement[1]=objet[0];
            changement[2]=objet[1];
            changement[3]=objet[2];
            changement[4]=objet[3];
            changement[5]=objet[4];
            changement[6]=objet[5];
            changement[7]=objet[6];
            changement[8]=objet[7];
            changement[9]=objet[8];
            changement[10]=objet[9];
 
       fprintf(fichier, "sucee des allocations de sprites\n");
 
// Boucle de test des collisions du perso avec les corps celeste présent dans l'univers//
            if(CollisionCC(boxC1perso,boxC1objet[0]) == true )
            {
                   fprintf(fichier, "proche de la meteorite\n");
                   if(CollisionCC(boxC2perso,boxC2objet[0]) == true )
                    {
                        changement[0]=changement[2];
                        fprintf(fichier, "absorption de la meteorite\n");
 
                    }
            }
            if (CollisionCC(boxC1perso,boxC1objet[1]) == true)
            {
                 fprintf(fichier, "proche de l asteroide\n");
                 if(CollisionCC(boxC2perso,boxC2objet[1])== true)
                    {
                        changement[2]=explosion;
                        fprintf(fichier, "destruction de l'asteroide\n");
                    }
            }
            if(CollisionCC(boxC1perso,boxC1objet[2]) == true)
            {
                  fprintf(fichier, "proche de la petite planete\n");
                  if(CollisionCC(boxC2perso,boxC2objet[2])== true)
                    {
                        changement[3]=explosion;
                        fprintf(fichier, "destruction de la petite planete\n");
                    }
            }
 
            SDL_FillRect(ecran, NULL, SDL_MapRGB(ecran->format, 0, 0,0));
            SDL_BlitSurface(univers, NULL, ecran, &pos_fond);
            SDL_BlitSurface(changement[0], NULL, ecran, &position_perso);
            SDL_BlitSurface(changement[1], NULL, ecran, &positionobjet[0]);
            SDL_BlitSurface(changement[2], NULL, ecran, &positionobjet[1]);
            SDL_BlitSurface(changement[3], NULL, ecran, &positionobjet[2]);
 
            SDL_Flip(ecran);
	}
 
	SDL_FreeSurface(perso);
	for(i=0;i++;4)
	{
	    SDL_FreeSurface(objet[i]);
	}
	SDL_FreeSurface(univers);
	fclose(fichier);
 
}

26/02/2012, 18h09
diogene

Citation:

Code:

init_B_B_cercle_objet(&positionobjet,boxC1objet[10],boxC2objet[10],objet[10]),h,w);

L'appel est incorrect. Si tu veux passer les tableaux de structures, tu dois avoir :

Code:

init_B_B_cercle_objet(&positionobjet, boxC1objet, boxC2objet, objet),h,w);

Dans ton code, tu passes les 11-ieme éléments des tableaux (éléments qui d'ailleurs n'existent pas)
26/02/2012, 18h29
Sve@r
Citation:
Envoyé par maximus35

Tous les fprintf marchent jusqu'à celui de la ligne 213.
Aprés, on rentre dans le fonction .... et ca plante :cry:

Code:

1 2 3 ... init_B_B_cercle_objet(positionobjet,boxC1objet,boxC2objet,objet[10],h,w);
En C, invoquer elem[x] signifie qu'on demande l'élément d'indice x. Donc là tu passes à ta fonction le 11° objet de ton tableau (d'un tableau qui, en plus, n'en contient que 10)...

Les paramètres d'une fonction sont simples: tu veux passer un tableau de 10 trucs à une fonction toto, alors tu déclares toto ainsi
Code:

1 2 3 4 <type> toto(truc var[10]) { ... }
Et tu l'appelles ainsi
Code:

1 2 truc tab[10]; toto(tab);
Eventuellement tu as le droit de ne pas spécifier la taille de la première dimension ou même de la remplacer par un pointeur. Donc pour un tableau en 3D de ce type
Code:

1 2 truc tab[10][20][30]; toto(tab);
La fonction pourra être déclarée ainsi
Code:

1 2 3 4 <type> toto(truc var[10][20][30]) { ... }
ou bien ainsi
Code:

1 2 3 4 <type> toto(truc var[][20][30]) { ... }
ou bien ainsi
Code:

1 2 3 4 <type> toto(truc *var[20][30]) { ... }

Je retien donc pour faire un appelle correct il faut faire:
Code:

1 2 init_B_B_cercle_objet(&positionobjet,boxC1objet,boxC2objet,objet,h,w);
Et ce me retourne bien mes boxC1objets et boxC2objets et mes positionobjets remplient ?

EDIT:
je vien d'effectué les test suivant:
Code:

1 2 3 4 5 fprintf(fichier, "Sucée de la fontion init_B_Bcercle_objet\n"); fprintf(fichier, "test positionobjet 0 %d\n",positionobjet[0].x); fprintf(fichier, "test positionobjet 0 %d\n",positionobjet[0].y);
Le test Sucée de la fonction init_B_Bcercle_objet fonctionne mais après plus rien ....
est ce que en sortant de ma fonction le programme à détruit les actions qu'il avait effectué sur les postionobjets ?
Maxime

Citation:
Envoyé par maximus35
Je retien donc pour faire un appelle correct il faut faire:
Code:

1 2 init_B_B_cercle_objet(&positionobjet,boxC1objet,boxC2objet,objet,h,w);
Tu as lu mon premier post ???

Citation:

Envoyé par maximus35

Et ce me retourne bien mes boxC1objets et boxC2objets et mes positionobjets remplient ?

Ben ça ça dépend de comment a été programmé la fonction. Et ici il faut mettre un accord et non un verbe conjugué.
Citation:
Envoyé par maximus35
EDIT:
je vien d'effectué les test suivant:
Code:

1 2 3 4 5 fprintf(fichier, "Succès de la fontion init_B_Bcercle_objet\n"); fprintf(fichier, "test positionobjet 0 %d\n",positionobjet[0].x); fprintf(fichier, "test positionobjet 0 %d\n",positionobjet[0].y);
Le test Sucée de la fonction init_B_Bcercle_objet fonctionne mais après plus rien ....
est ce que en sortant de ma fonction le programme à détruit les actions qu'il avait effectué sur les postionobjets ?
Maxime
Non sortir d'une fonction ne détruit rien de ce qui a été fait avant. Mais j'ai l'impression que tu n'as pas étudié assez ce langage pour te lancer dans ce genre de manipulations...

26/02/2012, 22h51
maximus35

.... no comment .... 8O
Je vais laisser le projet de côté pendant une journée ou deux ca me fera du bien, parfois faut savoir s'arreter pour mieux reprendre.
Même en ayant lu des cours de C et fais des TP, je ne suis pas autodidacte dans ce domaine. J'ai besoin d'un mentor ou d'un professeur pour apprendre vite et bien.

Merci beaucoup, ca fonctionne à présent ^^ je vais tout de suite commenté mon code ca me permet d'assimiler.

Je vais surement poster de nouveau vu que je suis à la partie charnière du projet.
Je commence à imbriqué mes fonctions les une des les autres pour que le jeux fonctionne

Pourrais je, si vous me le permettez, vous solliciter pour regarder ?

Merci encore

Maxime
27/02/2012, 00h26
Sve@r

Citation:

Envoyé par maximus35

Pourrais je, si vous me le permettez, vous solliciter pour regarder ?

On est là pour ça car ta réussite nous grandit tous.