Compilation normale mais rien ne s'affiche dans le main

**mecaplus** · 03/03/2011, 14h42

Bonjour,

Petit souci avec un petit programme en c. Je n'arrive pas à trouver la cause du résultat renvoyé dans le main. Ci-dessous le code C.

En fait la compilation se déroule très bien, sans warning en utilisant l'une des solutions suivante :
gcc -o test.exe test.c -lm
gcc -o test.exe test.c -Wall

pour lancer le programme le tape ./test.exe ou simplement test.exe entrée. Je suis sous Windows avec MinGW.

Lorsque je fais appel seulement à la fonction coucou() dans le main, tout se passe bien, la bonne valeur est renvoyée et affichée.

Dès que je fais appel à la fonction retourne(), plus rien ne s'affiche. Le problème se trouverai donc dans la fonction retourne(). Quelqu'un peut-il m'aider à identifier le problème et à le résoudre?

D'avance merci.

Voici le code source :

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
 
/* code de calcul simplifie */
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <string.h>
#define nmaxg  10
#define nmaxp  100
 
 
struct vecteur{
	double x;
	double y;
	double z;
};
 
struct sphere{
 
  struct vecteur Pi;
  double rayon;
 
};
 
/* Variables globales */
 
struct sphere grosse[nmaxg];
struct sphere petite[nmaxp];
 
int liste[nmaxg][nmaxp];
 
/* Declaration prototype de la fonction retournant le nombre de spheres coupees */
//int retourne(void);
 
 
 
 
/*===================================================== 			
		Programme retournant le nombre de petites spheres
			coupant une grosse sphere  
 =======================================================*/
 
int retourne(void)
 
{
 
int i,j,l,npcut;
double sij,dij,ai,rp;
double r0,dr,Rmax,r;
double xp,yp,zp,xg,yg,zg;
 
 
			/* Initialisation de la liste des petites spheres i coupant la grosse particule j */
 
			 for (j=1;j<nmaxg+1;j++){
			   for(i=1;i<nmaxp+1;i++){
 
			    liste[j][i]=0;
 
			   }
			 }
 
		 /* Initialisation des positions des petites spheres i et de leur rayon ai*/
 
				rp=0.5;
				 for(i=1;i<nmaxp+1;i++){
					petite[i].Pi.x=0.0;
					petite[i].Pi.y=0.0;
					petite[i].Pi.z=0.0;
					petite[i].rayon=rp;
 
				 }
 
 
 
		/* Initialisation des positions des grosses spheres j et de leur rayon r0*/
				r0=0.5;
				 for(j=1;i<nmaxg+1;j++){
					grosse[j].Pi.x=68.709244;
					grosse[j].Pi.y=41.190768;
					grosse[j].Pi.z=46.994176;
					grosse[j].rayon=r0;
				 }	 
 
 
		/* Positions de toutes les petites sphères  (a la main pour le moment)*/
 
					petite[1].Pi.x=68.739818;petite[1].Pi.y=36.338619;petite[1].Pi.z=47.033400;
					petite[2].Pi.x=68.751057;petite[2].Pi.y=35.342589;petite[2].Pi.z=47.046098;
					petite[3].Pi.x=68.733077;petite[3].Pi.y=37.336013;petite[3].Pi.z=47.024592;
					petite[4].Pi.x=68.726898;petite[4].Pi.y=38.333393;petite[4].Pi.z= 47.016701;
					petite[5].Pi.x=68.715185;petite[5].Pi.y=40.328183;petite[5].Pi.z=47.001699;
					petite[6].Pi.x=68.721253;petite[6].Pi.y=39.330804;petite[6].Pi.z=47.009528;
					petite[7].Pi.x=68.703453;petite[7].Pi.y=42.322970;petite[7].Pi.z=46.986340;
					petite[8].Pi.x=68.709359;petite[8].Pi.y=41.325591;petite[8].Pi.z=46.994238 ;
					petite[9].Pi.x=68.691409;petite[9].Pi.y=44.317759;petite[9].Pi.z=46.971378;
					petite[10].Pi.x=68.697063;petite[10].Pi.y=43.320374;petite[10].Pi.z=46.978808 ;
					petite[11].Pi.x=68.678527;petite[11].Pi.y=46.312538;petite[11].Pi.z=46.955216 ;
					petite[12].Pi.x=68.685288;petite[12].Pi.y=45.315164;petite[12].Pi.z=46.963515;
					petite[13].Pi.x=68.667791;petite[13].Pi.y=47.308595;petite[13].Pi.z=46.942774;
 
		 /* Position de la grosse sphere */
 
		         xg=grosse[1].Pi.x;
				 yg=grosse[1].Pi.y;
				 zg=grosse[1].Pi.z;
				 r=grosse[1].rayon;
 
		/* Etape 1 de l'algorithme ci-joint : calcul des distances entre i et j */
 
				dij=0.0;
				Rmax=10;
				dr=Rmax/10;
 
 
				for(i=1;i<nmaxp+1;i++){
					/* recuperation de la position de la sphere i */
				     xp=petite[i].Pi.x;
					 yp=petite[i].Pi.y;
					 zp=petite[i].Pi.z;
					 ai=petite[i].rayon;
 
					 /* Calcul de la distance entre les centres de i et j */
 
				     dij=sqrt((xp-xg)*(xp-xg)+(yp-yg)*(yp-yg)+(zp-zg)*(zp-zg));
 
					 sij=0.0;
					 npcut=0;
					 do{
 
					 /* Calcul de la distance entre les surfaces de i et de j */
 
					 sij=dij-(r+ai);
 
					 /* On identifie les petites spheres qui coupent la grosse sphere 
					 et on incremente le compteur npcut;*/
 
					    if(sij<0.0){
							npcut++;
							liste[1][0]=i; /* On stoke dans les identites des spheres i qui coupent la grosse sphere j=1 */
							l=liste[1][0];
						}
 
					    fprintf(stdout," Le nombre de petites spheres coupant la grosse est : %d \n",npcut);
						fprintf(stdout," Les petites spheres coupant la grosse sont         : %d \n",l);
 
						r+=dr; /* On incremente la valeur de r */
 
					}while(r<Rmax);
 
 
				} /* Fin de la bouche sur les petites particules */
 
 
                 fprintf(stdout,"COUCOU \n");
 
			return(npcut);
 
}
 
/*========================
   Fonction coucou
=========================*/
 
int coucou()
{
 
int a,b,c,s;
    a=1;b=2;c=4;
	s=a+b+c;
	return(s);
 
}
 
/*========================================================================
						MAIN PROGRAM - PROGRAMME PRINCIPAL
======================================================================*/
 
/* Main program */
 
 int main()
 
{
      int nsphere,valeur;
		valeur=coucou();
		//nsphere=retourne();
		fprintf(stdout," Coucou \n");
		fprintf(stdout," valeur =%d \n",valeur);
		fprintf(stdout," Nsphere =%d \n",nsphere);
 
        return EXIT_SUCCESS;
 
}

Invité(e) · 03/03/2011, 15h42

Bonjour,

Pour commencer, tu as un dépassement de tableau là :

Code :

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

1
2
3
4
5
 for (j=1;j<nmaxg+1;j++){
    for(i=1;i<nmaxp+1;i++){
        liste[j][i]=0;
    }
}

En C, les tableaux commencent à 0, il faut donc écrire :

Code :

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

1
2
3
4
5
 for (j=0;j<nmaxg;j++){
   for(i=0;i<nmaxp;i++){
       liste[j][i]=0;
   }
}

Pareil pour les autres accès aux tableaux.

Il y a peut être une erreur dans ta boucle while, ajoute un

Code :

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

printf("r:%lf, rMax: %lf\n", r, Rmax);

Au début de la boucle do-while pour suivre son évolution.

**mecaplus** · 03/03/2011, 17h04

Merci pour ta réponse et pour tes remarques sur mon code. Effectivement grosse erreur de ma part pour l'initialisation des tableaux. L'appel à la fonction retourne() fonctionne correctement.

Il y avait effectivement une erreur d'initialisation dans la boucle do-while, la valeur de r était initialiser avant le début de la boucle for, maintenant elle est initialisée juste avant le début de la boucle do-while est l'incrémentation se fait tant que r ne dépasse pas Rmax. Merci pour ton aide.

Après correction, le code donne ceci :

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
 
/* code de calcul simplifie */
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <string.h>
#define nmaxg  10
#define nmaxp  100
 
 
struct vecteur{
	double x;
	double y;
	double z;
};
 
struct sphere{
 
  struct vecteur Pi;
  double rayon;
 
};
 
/* Variables globales */
 
struct sphere grosse[nmaxg];
struct sphere petite[nmaxp];
 
int liste[nmaxg][nmaxp];
 
/* Declaration prototype de la fonction retournant le nombre de spheres coupees */
//int retourne(void);
 
 
 
 
/*===================================================== 			
		Programme retournant le nombre de petites spheres
			coupant une grosse sphere  
 =======================================================*/
 
int retourne(void)
 
{
 
int i,j,l,npcut;
double sij,dij,ai,rp;
double r0,dr,Rmax,r;
double xp,yp,zp,xg,yg,zg;
 
 
			/* Initialisation de la liste des petites spheres i coupant la grosse particule j */
 
			 for (j=0;j<nmaxg;j++){
			   for(i=0;i<nmaxp;i++){
 
			    liste[j][i]=0;
 
			   }
			 }
 
		 /* Initialisation des positions des petites spheres i et de leur rayon ai*/
 
				rp=0.5;
				 for(i=0;i<nmaxp;i++){
					petite[i].Pi.x=0.0;
					petite[i].Pi.y=0.0;
					petite[i].Pi.z=0.0;
					petite[i].rayon=rp;
 
				 }
 
 
 
		/* Initialisation des positions des grosses spheres j et de leur rayon r0*/
				r0=0.5;
				 for(j=0;i<nmaxg;j++){
					grosse[j].Pi.x=68.709244;
					grosse[j].Pi.y=41.190768;
					grosse[j].Pi.z=46.994176;
					grosse[j].rayon=r0;
				 }	 
 
 
		/* Positions de toutes les petites sphères  (a la main pour le moment)*/
 
					petite[0].Pi.x=68.739818;petite[0].Pi.y=36.338619;petite[0].Pi.z=47.033400;
					petite[1].Pi.x=68.751057;petite[1].Pi.y=35.342589;petite[1].Pi.z=47.046098;
					petite[2].Pi.x=68.733077;petite[2].Pi.y=37.336013;petite[2].Pi.z=47.024592;
					petite[3].Pi.x=68.726898;petite[3].Pi.y=38.333393;petite[3].Pi.z= 47.016701;
					petite[4].Pi.x=68.715185;petite[4].Pi.y=40.328183;petite[4].Pi.z=47.001699;
					petite[5].Pi.x=68.721253;petite[5].Pi.y=39.330804;petite[5].Pi.z=47.009528;
					petite[6].Pi.x=68.703453;petite[6].Pi.y=42.322970;petite[6].Pi.z=46.986340;
					petite[7].Pi.x=68.709359;petite[7].Pi.y=41.325591;petite[7].Pi.z=46.994238 ;
					petite[8].Pi.x=68.691409;petite[8].Pi.y=44.317759;petite[8].Pi.z=46.971378;
					petite[9].Pi.x=68.697063;petite[9].Pi.y=43.320374;petite[9].Pi.z=46.978808 ;
					petite[10].Pi.x=68.678527;petite[10].Pi.y=46.312538;petite[10].Pi.z=46.955216 ;
					petite[11].Pi.x=68.685288;petite[11].Pi.y=45.315164;petite[11].Pi.z=46.963515;
					petite[12].Pi.x=68.667791;petite[12].Pi.y=47.308595;petite[12].Pi.z=46.942774;
 
		 /* Position de la grosse sphere */
 
		         xg=grosse[0].Pi.x;
				 yg=grosse[0].Pi.y;
				 zg=grosse[0].Pi.z;
				 r=grosse[0].rayon;
 
		/* Etape 1 de l'algorithme ci-joint : calcul des distances entre i et j */
 
				dij=0.0;
				Rmax=3.733746;
				dr=Rmax/10;
 
				fprintf(stdout,"increment rayon =%lf \n",dr);
 
				for(i=0;i<nmaxp;i++){
					/* recuperation de la position de la sphere i */
				     xp=petite[i].Pi.x;
					 yp=petite[i].Pi.y;
					 zp=petite[i].Pi.z;
					 ai=petite[i].rayon;
 
					 /* Calcul de la distance entre les centres de i et j */
 
				     dij=sqrt((xp-xg)*(xp-xg)+(yp-yg)*(yp-yg)+(zp-zg)*(zp-zg));
 
					 sij=0.0;
					 npcut=0;
					 r=grosse[0].rayon;
					 do{
					 printf("r:%lf, rMax: %lf\n", r, Rmax);
					 /* Calcul de la distance entre les surfaces de i et de j */
 
					 sij=dij-(r+ai);
 
					 /* On identifie les petites spheres qui coupent la grosse sphere 
					 et on incremente le compteur npcut;*/
 
					    if(sij<0.0){
							npcut++;
							liste[0][0]=i; /* On stoke dans les identites des spheres i qui coupent la grosse sphere j=1 */
							l=liste[0][0];
						}
 
						r+=dr; /* On incremente la valeur de r */
 
					}while(r<=Rmax);
 
 
				} /* Fin de la bouche sur les petites particules */
 
 
			return(npcut);
 
}
 
 
/*========================================================================
						MAIN PROGRAM - PROGRAMME PRINCIPAL
======================================================================*/
 
/* Main program */
 
 int main()
 
{
      int nsphere;
 
		nsphere=retourne();
 
		fprintf(stdout," Nsphere =%d \n",nsphere);
 
        return EXIT_SUCCESS;
 
}

Vois-tu d'autres erreurs?

**mecaplus** · 04/03/2011, 17h16

Code revu, permutation des boucles do-while et for. Tout va bien. Merci encore ...

Compilation normale mais rien ne s'affiche dans le main

C

Discussions similaires

Partager

Partager