Problème sur un projet en C++

Bonjour,
je suis en ce moment en train de travailler sur un projet en C++ dans le cadre de mes études et il me reste un probleme dans mon programme, qui malgres l'aide d'amis assez doué en programmation, qui n'a pas été résolu.
En effet, dans mon programme(que j'ai mis en ci-dessous) j'ai un segmentation falt avant le main et je ne voit ni où ni comment(même après l'utilisation du debuggeur).

Mon programme:

Main.cpp

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
 
#include <iostream>
#include <cmath>
#include <fstream>
#include"Coordonnee.h"
#include"List_define.h"
 
using namespace std;
 
 
//Creation et initialisation du tableau d'etat (en mode global) dont les valeurs permettrons d'influancer le comportement du programme (toutes les cases sont a 0 lors de l'initialisation):
	 int tableau_etat[9];	//Caracterisation de chacun des emplacement memoire:
								//Case 0: Une variable est dans un domaine interdit;
								//Case 1: Met fin  a la boucle 0;
								//Case 2: Met fin a la boucle 1;
								//Case 3: Met fin a la boucle 2;
								//Case 4: Numero de la boucle en cours d'execution(0,1,2);
								//Case 5: La condition 1 est validee;
								//Case 6: La condition 2 est validee
								//Case 7: Met fin a la boucle 3;
								//Case 8: Indique si la fonction brassage_boucle a ete appelee
 
 
//Marge epsilon pour la comparaison de 2 reels
double epsilon_test=0.1;
double pi=3.141592;
 
int main()
{
	// Declaration des variables (Dans le système SI):
	//Constantes:
	double c=3*pow(10.,11.);
	//Parametres
	double lambda=0.1;
	double k=(2*pi)/lambda;
	double f=c/lambda;
	double A=1.;										                                     //Amplitude des sources
	int N_sources_total=100;						        	            //nombre de sources
	int N_coordonnee=3*N_sources_total;					//Nombre total de coordonnees
	double n=0.1;									                                	//iteration sur la distance pour le test
	double n_source=0.1;							                        	//iteration sur la distance pour les sources
	double n_phase=pi/2;							                    		//Iteration sur la phase
	double temps=1.;								                            	//iteration sur le temps
	double r1=1.;
	double r2=2.;
	double a=0.2;
	double a_int=a/2.;
	double erreur_sur_r1=0.2;							//Approximation sur r1 du resultat final
	double erreur_sur_a=0.2;							//Approximation sur a du resultat final
	double margeder1=erreur_sur_r1 ;
	double margedea=erreur_sur_a*N_sources_total*A;
 
	double z=0.0;
 
	for(int i=0;i<9;i++)
{
    tableau_etat[i]=0;
}
 
	//Ouverture du fichier texte ou seront stocke les resutats:
	ofstream fichier;
	fichier.open("Resultat_de_la_simulation.txt");
 
 
//On fait varier le nombre de sources entre 0 et N_sources:
for(int N=9;N<N_coordonnee;N=N+3)
{
	cout<<"Loading("<<((N*100)/N_coordonnee)<<" %) --> Nombre de Sources"<<endl;
 
	//Definition de la taille des tableaux
	int N_source =N/3;
	cout<<"Definition de la taille des tableaux"<<endl;
 
	coord_source *T1;
	coordonnee *T2;
	coordonnee *T3;
	phase *T4;
 
	T1=new coord_source[N];
	T2=new coordonnee[3];
	T3=new coordonnee[3];
	T4=new phase[N_source];
 
	for (int i=0;i<N;i=i+3)
	{
		T1[i]=coord_source(1,r2);
		T1[i+1]=coord_source(2,r2);
		T1[i+2]=coord_source(3,r2);
	}
	T2[0]=coordonnee(r1,r1+100);
	T2[1]=coordonnee(sqrt(pow(r1,2)-pow(T2[0].coord,2)),r1+100);
	T2[2]=coordonnee(sqrt(pow(r1,2)-pow(T2[0].coord,2)-pow(T2[1].coord,2)),sqrt(pow(r1,2)-pow(T2[0].coord,2)-pow(T2[1].coord,2)));
 
	T3[0]=coordonnee(a_int,a_int+100);
	T3[1]=coordonnee(sqrt(pow(a_int,2)-pow(T3[0].coord,2)),a_int+100);
	T3[2]=coordonnee(sqrt(pow(a_int,2)-pow(T3[0].coord,2)-pow(T3[1].coord,2)),sqrt(pow(a_int,2)-pow(T3[0].coord,2)-pow(T3[1].coord,2)));
 
	for (int i=0;i<N_source;i++)
	{
		T4[i]=phase();
	}
 
	cout<<"Done"<<endl;
 
	//Variables utiles pour construire le loading des combinaisons de sources
	int num_comb3=1;
	double exposant_source_pour_loading=0;
	for(double i=1;i<=N_source;i++)
    {exposant_source_pour_loading+=i;}
 
	//Combinaison de chaque coordonnees et Verification avec les conditions initiales:
	do{
		TE_num_boucle_en_execution=0;					//On indique que l'on est dans la boucle 0
		fonction_brassage_boucle(T1,N-1,n_source);		// On remonte dans l'arborescence et on ajoute +1 à l'iteration d'une coordonnee de la meme maniere que des boucles imbriquées
 
		if(TE_appel_fonction_brassage==0)				//Pour eviter de faire 2 iteration a la suite ( il y a une iteration dans fontion_brassage_boucle)
		{
			T1[N-1].iteration(n_source,N-1,T1);			//On rajoute +1 a la coordonnee la plus basse dans l'arbre des combinaisons
		}
		else{TE_appel_fonction_brassage=0;}
 
		cout<<endl;
		cout<<"Combinaison de source --> Loading( "<<((num_comb3*100.)/(pow(((2*pi*r2)/n_source),exposant_source_pour_loading)))<<" %) & Nbre de source="<<N_source<<endl;
		num_comb3++;
 
 
		//On saute la combinaison si un point est dans un domaine interdit
		if(TE_valeur_interdite==1)
		{
			TE_valeur_interdite=0;
		}
        else            //On ne fait la suite de la simulation que si aucune des valeurs n'est dans un domaine interdit
        {
		//Variables utiles pour construire le loading des combinaisons de phases
		int num_comb4=1;
		double exposant_phase_pour_loading=0;
		for(double i=1;i<=N_source;i++)
		{exposant_phase_pour_loading+=i;}
 
		//Iteration sur la phase
		do{
			TE_num_boucle_en_execution=3;					//on indique que l'on passe dans la boucle 4
			fonction_brassage_boucle(T4,N_source-1,n_phase);
			if(TE_appel_fonction_brassage==0)				//Pour eviter de faire 2 iteration a la suite ( il y a une iteration dans fontion_brassage_boucle)
			{
				T4[N_source-1].iteration(n_phase);			//On rajoute +1 a la coordonnee la plus basse dans l'arbre des combinaisons
			}
			else{TE_appel_fonction_brassage=0;}
 
			cout<<endl;
			cout<<"Combinaison de phase --> Loading( "<<(num_comb4*100)/(pow((2*pi)/n_phase,exposant_phase_pour_loading))<<" %) & Nbre de source="<<N_source<<endl;
			//cout<<"Combinaison de phase --> Loading( "<<(num_comb4*n_phase*100)/(pow((2*pi*r2),exposant_phase_pour_loading))<<" %) & Nbre de source="<<N_source<<endl;
			num_comb4++;
 
			//Iteration des conditions sur le temps pour qu'elles soient vraient pour tout t:
               bool flag_boucle_test_temp=1;
               int t=0;
			do
			{
				cout<<"Test sur le temps: Loading("<<(t)*100./5.<<" %)"<<endl;
				//Condition 1
				int num_comb1=1;	//Variable qui indiquera quelle combinaison le programme est en train de tester
				//Debut boucle de test:
                        bool flag_boucle_2=1;       //Permet de simuler un break
				do{
					//On indique que l'on passe dans la boucle 1
					TE_num_boucle_en_execution=1;
					fonction_brassage_boucle(T2,2,n);
					if(TE_appel_fonction_brassage==0)														 //Pour eviter de faire 2 iteration a la suite ( il y a une iteration dans fontion_brassage_boucle)
					{
						T2[2].iteration(n);										 //On rajoute +1 a la coordonnee la plus basse dans l'arbre des combinaisons
					}
					else{TE_appel_fonction_brassage=0;}
 
 
					//On saute la combinaison si un point est dans un domaine interdit
					if(TE_valeur_interdite==1)
					{
						TE_valeur_interdite=0;
					}
					else            //On ne fait la suite de la simulation que si aucune des valeurs n'est dans un domaine interdit
					{
					//Iteration sur la phase
 
					//Calcul de  z=Somme des sources en un point de l'espace (x,y,z):
					//double z=0.0;
					z=0.0;
 
					for(int j=0;j<N;j=j+3)
					{
						z+=A*cos((2*pi*f*t)-(k)*(sqrt(pow(T1[j].coord-T2[0].coord,2)+pow(T1[j+1].coord-T2[1].coord,2)+pow(T1[j+2].coord-T2[2].coord,2)))+T4[j/3].phase1);
                        cout << T1[j].coord<<" "<<T2[0].coord<<" "<<T1[j+1].coord<<" "<<T2[1].coord<<" "<<T1[j+2].coord<<" "<<T2[2].coord<<" "<<  j << endl;
					}
 
					//Test sur la condition 1:
					if(z>=(-margeder1) && z<=margeder1)
					{
						TE_validation_condition_1=1;
 
						//Afichage de l'avancement du teste de la condition 1
						cout<<"Condition 1 --> Loading( "<<(int)((num_comb1*100)/pow((2*r1)/n,3*N))<<" %)"<<endl;
						num_comb1++;
					}
					else
					{
						TE_validation_condition_1=0;
						if (num_comb1!=1)
						{
							cout<<"Condition 1 --> Echec sur une valeur --> Arret du test"<<endl;
						}
						flag_boucle_2=0;
					}
					cout<<"Test Condition 1 --> Done"<<endl;
					}
				}while(TE_casse_boucle_2==0 && flag_boucle_2==1);
				//Remise a 0 du casse-boucle 2
				TE_casse_boucle_2=0;
 
 
 
				//Condition 2 :
				int num_comb2=1;	//Variable qui indiquera quelle combinaison le programme est en train de tester
 
				//On indique que l'on passe dans la boucle 2
				TE_num_boucle_en_execution=2;
				//Debut boucle de test
                    bool flag_boucle_3=1;
				do{
 
					if (TE_validation_condition_1==0)
					{
						cout<<"Saut de la condition 2 car la condition 1 n'a pas ete validee"<<endl;
						flag_boucle_3=0;
					}
					else        //Permet de sauter la condition 2 si la condition 1 n'est pas respectee
                    {
                        T3[2].iteration(n);
                        fonction_brassage_boucle(T3,2,n);
 
                        //On saute la combinaison si un point est dans un domaine interdit
                        if(TE_valeur_interdite==1)
                        {
                            TE_valeur_interdite=0;
                        }
                        else
                        {
                            //Calcul de  z=Somme des sources en un point de l'espace (x,y,z):
                            double z=0;
                            for(int j=0;j<N;j=j+3)
                            {
                                z+=A*cos((2*pi*f*t)-(k)*(sqrt(pow(T1[j].coord-T3[0].coord,2)+pow(T1[j+1].coord-T3[1].coord,2)+pow(T1[j+2].coord-T3[2].coord,2)))+T4[j/3].phase1);
                            }
 
                        //Test sur la condition 2:
                            if(z>=N*A-margedea && z<=N*A)
                            {
                                TE_validation_condition_2=1;
 
                                //Affichage du numero de la combinaison testee
                                cout<<"Condition 2 --> Loading(  "<<(int)(num_comb2/pow((2*a_int)/n,3*N))<<" %)"<<endl;
                                num_comb2++;
                            }
                            else
                        {
                                TE_validation_condition_2=0;
                                if (num_comb2!=1)
                                {
                                    cout<<"Condition 2 --> Echec sur une valeur --> Arret du test"<<endl;
                                }
                                flag_boucle_3=0;
                            }
                            cout<<"Test Condition 2--> Done"<<endl;
                        }
                    }
				}while(TE_casse_boucle_3==0 && flag_boucle_3==1);
				//Remise a 0 du casse-boucle 3
				TE_casse_boucle_3=0;
 
				//Reinitialisation de T2 et T3:
				cout<<"Reinitialisation des Tableaux"<<endl;
 
				T2[0]=coordonnee(r1,r1+100);
				T2[1]=coordonnee(sqrt(pow(r1,2)-pow(T2[0].coord,2)),r1+100);
				T2[2]=coordonnee(sqrt(pow(r1,2)-pow(T2[0].coord,2)-pow(T2[1].coord,2)),sqrt(pow(r1,2)-pow(T2[0].coord,2)-pow(T2[1].coord,2)));
 
				T3[0]=coordonnee(a_int,a_int+100);
				T3[1]=coordonnee(sqrt(pow(a_int,2)-pow(T3[0].coord,2)),a_int+100);
				T3[2]=coordonnee(sqrt(pow(a_int,2)-pow(T3[0].coord,2)-pow(T3[1].coord,2)),sqrt(pow(a_int,2)-pow(T3[0].coord,2)-pow(T3[1].coord,2)));
 
				//Condition sur t pour continuer a iterer: que la cominaison respecte les conditions pour tout t
				if(TE_validation_condition_1==0 || TE_validation_condition_2==0)
				{
					cout<<" ---> NON"<<endl;
					flag_boucle_test_temp=0;
				}
				t++;
			}while(t!=6 && flag_boucle_test_temp==1);               //on fait une iteration jusqu a t=5 et tant que le flag n est pas egal a 0
			//Enrengistrement des potentiels resultats et remise a zero des cases du tableau d'etat correspondant a la validation des conditions 1 et 2:
			//cout<<"Enrengistrement des potentiels resultats";
			if(TE_validation_condition_1==1 && TE_validation_condition_2==1)
			{
				cout<<" ---> OUI"<<endl;
				fichier<<endl;
				fichier<< "Combinaison de coordonnees de source valide: "<<endl;
				for(int j=0;j<N;j++)
				{
					fichier<<"Source numero "<<j<<":				"<<T1[j].coord<<"			  "<<T1[j+1].coord<<"			 "<<T1[j+2].coord<<"			 et de phase:"<<T4[j].phase1<<endl;
				}
			}
 
			//Remise a zero des conditions 1 et 2 pour une nouvelle combinaison des sources
			TE_validation_condition_1=0;
			TE_validation_condition_2=0;
 
		}while(TE_casse_boucle_4==0);
		TE_casse_boucle_4=0;
        }
	}while(TE_casse_boucle_1==0);
	//Remise a 0 du casse-boucle 1
	TE_casse_boucle_1=0;
 
 
	//Destruction des anciens tableaux pour qu'ils soient reconstruit lors de la prochaine iteration
	delete[] T1;
	delete[] T2;
	delete[] T3;
	delete[] T4;
 
}
	//Fermeure de la Simulation
	cout<<"Fin du Programme de Simulation"<<endl;
	fichier.close();
	return 0;
}

Coordonnee.cpp

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
 
#include <iostream>
#include <cmath>
#include <fstream>
#include "Coordonnee.h"
 
 
coordonnee::coordonnee()
{}
 
coordonnee::coordonnee(double valeur_depart1, double valeur_interdite1)
{
    coord=0;
    valeur_depart= valeur_depart1;
    nbre_iteration=0;
    valeur_interdite=valeur_interdite1;
    fin_iteration=0;
}
 
void coordonnee::iteration(double n)
{
    coord=-valeur_depart+nbre_iteration*n;
    nbre_iteration++;
    if(coord<-valeur_interdite && coord>valeur_interdite)
    {
        TE_casse_boucle_1=1;
    }
    if(coord>=valeur_depart-epsilon_test && coord<=valeur_depart+epsilon_test)
    {
        fin_iteration=1;
    }
}
 
 
 
coord_source::coord_source()
{}
 
coord_source::coord_source(int nature_coord1,double rayon1)
{
    coord=0;
    nature_coord=nature_coord1;
    rayon=rayon1;
    nbre_iteration=0;
    fin_iteration=0;
}
 
void coord_source::iteration(double n,int iteration_en_cours,coord_source *T)
{
    double epsilon=0;
 
    if (nature_coord==1)    // --> x
    {
        coord=-rayon+nbre_iteration*n;
        nbre_iteration++;
        if(coord>=rayon-epsilon_test && coord<=rayon+epsilon_test){fin_iteration=1;}
    }
    if (nature_coord==2)    // --> y
    {
        coord=-sqrt(pow(rayon,2)-pow(T[iteration_en_cours-1].coord,2))+nbre_iteration*n;        //On commence a iterer "y" sur le bord situe dans les negatifs
        nbre_iteration++;
        if(coord>=sqrt(pow(rayon,2)-pow(T[iteration_en_cours-1].coord,2))-epsilon_test && coord<=sqrt(pow(rayon,2)-pow(T[iteration_en_cours-1].coord,2))+epsilon_test){fin_iteration=1;}        //Arret de l'iteration si y depasse le disque(avec une bande de 2*epsilon)
    }
 
    if (nature_coord==3)    // --> z
    {
        if (nbre_iteration==0)
        {epsilon=1;}
        if (nbre_iteration==1)
        {
            epsilon=-1;
            fin_iteration=1;
        }
        coord=epsilon*sqrt(pow(rayon,2)-pow(T[iteration_en_cours-1].coord,2)-pow(T[iteration_en_cours-2].coord,2));
        nbre_iteration++;
    }
}
 
 
phase::phase()
{
    phase1=0;
    nbre_iteration=0;
    fin_iteration=0;
}
 
void phase::iteration(double n)
{
    phase1=nbre_iteration*n;
    nbre_iteration++;
    if(phase1>=2*pi-epsilon_test && phase1<=2*pi+epsilon_test){fin_iteration=1;}
}
 
 
//Fonctions brassage
 
void fonction_brassage_boucle(coordonnee *T,int N,double n)
{
    bool flag = 1;
    int i=N;
    while ((i>=0)&&(flag))      // pour i allant de N à 0 par pas de -1
    {
        if(i==0)
        {
             if(TE_num_boucle_en_execution==1)
                {
                    TE_casse_boucle_2=1;
                    flag = 0;
                }
 
            if(TE_num_boucle_en_execution==2)
                {
                    TE_casse_boucle_3=1;
                   flag = 0;
                }
        }
    if (flag==0)        //Pour eviter que l'on fasse une iteration sur la case -1 du tableau si i=0 && T[i].fin_iteration=1
    {}
        else
        {
            if(T[i].fin_iteration==1)
                {
                    T[i-1].iteration(n);
                    T[i].fin_iteration=0;
                    T[i].nbre_iteration=0;
                    TE_appel_fonction_brassage=1;
                    flag = 0;
                }
        }
        i--;
    }
 
}
 
void fonction_brassage_boucle(coord_source *T,int N,double n)
{
    bool flag = 1;
    int i=N;
    while ((i>=0)&&(flag))
    {
            if(i==0)
            {
                if(TE_num_boucle_en_execution==0)
                    {
                        TE_casse_boucle_1=1;
                        flag = 0;
                    }
        }
 
    if (flag==0)        //Pour eviter que l'on fasse une iteration sur la case -1 du tableau si i=0 && T[i].fin_iteration=1
    {}
        else
        {
            if(T[i].fin_iteration==1)
                {
                    T[i-1].iteration(n,i-1,T);
                    T[i].fin_iteration=0;
                    T[i].nbre_iteration=0;
                    TE_appel_fonction_brassage=1;
                    flag = 0;
                }
        }
        i--;
    }
}
 
void fonction_brassage_boucle(phase *T,int N,double n)
{
        bool flag = 1;
        int i=N;
    while ((i>=0)&&(flag))
    {
        if(i==0)
        {
            if(TE_num_boucle_en_execution==3)
                {
                    TE_casse_boucle_4=1;
                    flag = 0;
                }
        }
 
    if (flag==0)        //Pour eviter que l'on fasse une iteration sur la case -1 du tableau si i=0 && T[i].fin_iteration=1
    {}
        else
        {
            if(T[i].fin_iteration==1)
                {
                    T[i-1].iteration(n);
                    T[i].fin_iteration=0;
                    T[i].nbre_iteration=0;
                    TE_appel_fonction_brassage=1;
                    flag = 0;
                }
        }
    i--;
    }
}

Coordonnee.h

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
 
#ifndef COORDONNEE_H_INCLUDED
#define COORDONNEE_H_INCLUDED
#include<iostream>
#include"List_define.h"
using namespace std;
 
class coordonnee {
    private:
 
    public:
    //Attributs
    double coord;
    double valeur_depart;
    int nbre_iteration;
    double valeur_interdite;
    int fin_iteration;
 
    //Constructeur:
    coordonnee();
    coordonnee(double valeur_depart1, double valeur_interdite1);
 
    //Methode
    void iteration(double n);
 
};
 
void fonction_brassage_boucle(coordonnee *T,int N,double n);
 
 
class coord_source
{
    private:
 
    public:
    //Attributs
    double coord;
    int nature_coord;
    double rayon;
    int nbre_iteration;
    int fin_iteration;
 
 
    //Constructeur:
    coord_source();
    coord_source(int nature_coord1,double rayon1);
 
    //Methode
    void iteration(double n,int iteration_en_cours,coord_source *T);
};
 
void fonction_brassage_boucle(coord_source *T,int N,double n);
 
 
class phase
{
    private:
 
    public:
    //Attributs
    double phase1;
    int nbre_iteration;
    int fin_iteration;
 
    //Constructeur:
    phase();
 
    //Methode
    void iteration(double n);
};
 
void fonction_brassage_boucle(phase *T,int N,double n);
 
//
//Importation du tableau depuis le main
extern int tableau_etat[9];
extern double epsilon_test;
extern double pi;
 
////Creation et initialisation du tableau d'etat (en mode global) dont les valeurs permettrons d'influancer le comportement du programme (toutes les cases sont a 0 lors de l'initialisation):
//	 int tableau_etat[9];	//Caracterisation de chacun des emplacement memoire:
//								//Case 0: Une variable est dans un domaine interdit;
//								//Case 1: Met fin  a la boucle 0;
//								//Case 2: Met fin a la boucle 1;
//								//Case 3: Met fin a la boucle 2;
//								//Case 4: Numero de la boucle en cours d'execution(0,1,2);
//								//Case 5: La condition 1 est validee;
//								//Case 6: La condition 2 est validee
//								//Case 7: Met fin a la boucle 3;
//								//Case 8: Indique si la fonction brassage_boucle a ete appelee
//
//
////Marge epsilon pour la comparaison de 2 reels
//double epsilon_test=0.1;
//double pi=3.141592;
 
 
#endif // COORDONNEE_H_INCLUDED

et enfin

List_define.h

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
 
//Caracterisation de chacun des emplacement memoire:
	//Case 0: Une variable est dans un domaine interdit;
	//Case 1: Met fin  a la boucle 0;
	//Case 2: Met fin a la boucle 1;
	//Case 3: Met fin a la boucle 2;
	//Case 4: Numero de la boucle en cours d'execution(0,1,2);
	//Case 5: La condition 1 est validee;
	//Case 6: La condition 2 est validee
	//Case 7: Met fin a la boucle 3;
	//Case 8: Indique si la fonction brassage_boucle a ete appelee
#define TE_valeur_interdite tableau_etat[0]
#define TE_casse_boucle_1 tableau_etat[1]
#define TE_casse_boucle_2 tableau_etat[2]
#define TE_casse_boucle_3 tableau_etat[3]
#define TE_num_boucle_en_execution tableau_etat[4]
#define TE_validation_condition_1 tableau_etat[5]
#define TE_validation_condition_2 tableau_etat[6]
#define TE_casse_boucle_4 tableau_etat[7]
#define TE_appel_fonction_brassage tableau_etat[8]

Je vous remercie d'avance, vous me rendriez un grand service.

Bonsoir,

ce programme s'exécute sans crash, et valgrind ne détecte rien d'illégal au niveau des accès mémoire

note : j'utilise une machine 32 bits et j'ai compilé avec g++ 4.2.1

Bonjour,

Je n'ai par regardé le code complet ( il est un peu long :aie: ) mais, je pense que le bug apparait que dans un cas bien spécifique, dans lequel bruno_pages n'est peut être pas passé.
Donc, s'il vous plait, veuillez nous dire comment on reproduit le bug ( paramètre, condition d'execution ), et nous verrons s'il y a quelque chose d'anormal.

Salut,

Citation:

Envoyé par jprog007

j'ai un segmentation falt avant le main

S'il s'agit d'un plantage avant l'entrée dans le main, à priori, je vois 2 possibilités :
-> Un problème dans le constructeur de variables statiques (fiasco ?) ;
-> Un tableau trop grand dès le début du main.

Pour faire apparaitre le "segmentation falt" il suffit de lancer le debugger(Je ne sait pour quelle raison, il n'y a aucune erreur lors de la compilation).

Je pense que le segmentation falt est sur le tableau créé avant la main: tableau_etat (mais je ne voit pas pourquoi). Car dans le programme ce tableau gère le sortie de boucle de type do...while et le programme passe par toutes les boucles sans faire 2 iterations à la suite (sauf la boucle principale qui ne dépend pas de ce tableau).
Pour donner une idée: le programme est en gros plusieurs boucles les unes dans les autres sachant que chaque boucle doit faire a peu pres 10 000 iterations --> ça fait beaucoup de calculs et le programme s'exécute en 20 seconde max...d'où mon problème.

Merci d'avance.

Citation:

S'il s'agit d'un plantage avant l'entrée dans le main, à priori, je vois 2 possibilités :
-> Un problème dans le constructeur de variables statiques (fiasco ?) ;

Je ne pense pas car le tableau en question (tableau_etat) est définit avant le main comme un tableau d'entier => il ne fait appel à aucune fonction dans un autre fichier.

Citation:

-> Un tableau trop grand dès le début du main

Le tableau ne fait que 9 cases donc je ne pense pas que le problème vienne de là.

Citation:

Envoyé par jprog007

Pour faire apparaitre le "segmentation falt" il suffit de lancer le debugger

sous quel OS (Windows, Linux ..) ?
quel compilateur et version ?
en 32 bits ou 64 ?
est-ce que le plantage arrive si on exécute en dehors du debugger ?
le fait de compiler avec ou sans optimisation a-t-il de l'importance ?

sous quel OS (Windows, Linux ..) ?
--->Windows XP 32 bits mais j'ai aussi essayé sous linux: même probleme

quel compilateur et version ?
-->GNU GCC Compiler ( compilateur de base téléchargé avec Code Block récement(~4 mois)) et essayé également avec Dev C++(et son debuggeur par defaut): même problème

en 32 bits ou 64 ?
-->32 bits

est-ce que le plantage arrive si on exécute en dehors du debugger ?
--> le programme s'excute avec ou sans debuggeur (mais en ne faisant pas ce que je lui ait demandé(voir la description plus detaillé de ce que fait le programme ci dessus)) à la seule différence où le compilateur n'indique pas qu'il y a un segmentation falt alors que le debuggeur le fait.

le fait de compiler avec ou sans optimisation a-t-il de l'importance ?
--> Je ne suis pas sûre de ce que vous entendez par optimisation(je suis un peu un débutant) mais je n'ai touché aucun paramètre du compilateur depuis que je l'ai installé.

Bonjour,

et bien c'est très bizarre car pour moi tout se passe bien, mais comme cela produit plus de 6000 lignes je ne vais pas les publier ici

avez-vous essayé de l'exécuter avec valgrind ?

Bonjour à tous,
Voila j'ai appriori trouvé le probleme: j'avait fait une erreur dans la structure du programme et maintenant, il tourne(il met plus de 20 sec pour s'executer).
Je ne sait toujours pas pourquoi j'ai un segmentation falt à chaque fois que je fait un debuggage mais bon il semblerait que ça vienne de chez moi puisque aucun d'entre vous avez eu la même erreur...

En tout cas merci à tous de votre aide et de votre rapidité. Je pense que je n'ai pas fini d'en baver avec ce programme mais vous m'avez aidé à franchir un cap.

Cordialement.