constant is long in function main

**ben_tiba_asma** · 03/11/2011, 16h13

Salut, je suis débutant en C. Ci dessous un extrait d'un code où il me dit que la constante est grande

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
#include <stdlib.h>
#include <time.h>
#include <stdio.h>
//************************************** Générateur de machines
 
int main()
{
 
long cc;
long i=100000;
 
 cc=3*i;
 printf("val de cc est %d",cc);
return(0);
}

Aide SVP

**oodini** · 03/11/2011, 16h32

Il faut aller dans le forum C.

Et accessoirement mettre le code entre balises #...

**Xtrem_Voyageur** · 03/11/2011, 16h34

Salut, tu me fais rire à parler en finissant tes phrases par un ';'
Tu n'es plus en mode programmation instructions quand tu t'adresses sur le forum

Ensuite, j'ai raconté un peu n'importe quoi. Voir message d'Emmanuel Deloget en dessous.
Sinon, pour ton petit programme, ne parles pas de constante tu n'en utilises pas, tu as simplement déclaré une variable nommée cc de type long qui sera donc codée sur un nombre d'octets supérieur ou égal à une variable de type int. Cela dépend des machines sur lesquelles tu exécutes ton programme.
Généralement, un int est codé sur 4 octets et est signé et ses valeurs s'étendent donc de -32768 à 32767.

Pour ta part tu as choisi de placer la valeur 100000 (qui ne tient pas dans un int) dans un long, très bien.
Maintenant, à l'affichage, c'est autre chose.
tu fois indiquer le format de l'argument, ici tu as choisi %d, tu demandes donc à printf de t'afficher ta variable cc comme un int.
Malheureusement, 100000 ne tient pas dans un int. Il faut donc que tu utilises un autre format pour afficher un long par exemple : %ld

**Emmanuel Deloget** · 03/11/2011, 16h53

Envoyé par Xtrem_Voyageur

Salut, tu me fais rire à parler en finissant tes phrases par un ';'
Tu n'es plus en mode programmation instructions quand tu t'adresses sur le forum

Sinon, pour ton petit programme, ne parles pas de constante tu n'en utilises pas, tu as simplement déclaré une variable nommée cc de type long qui sera donc codée sur un nombre d'octets supérieur ou égal à une variable de type int. Cela dépend des machines sur lesquelles tu exécutes ton programme.
Généralement, un int est codé sur 4 octets et est signé et ses valeurs s'étendent donc de -32768 à 32767.

Pour ta part tu as choisi de placer la valeur 100000 (qui ne tient pas dans un int) dans un long, très bien.
Maintenant, à l'affichage, c'est autre chose.
tu fois indiquer le format de l'argument, ici tu as choisi %d, tu demandes donc à printf de t'afficher ta variable cc comme un int.
Malheureusement, 100000 ne tient pas dans un int. Il faut donc que tu utilises un autre format pour afficher un long par exemple : %ld

Popopo.

4 octets permettent de stocker plus de 4 milliard de valeurs différentes. Donc un int de 32 bits va sans problème permettre le stockage d'une valeur égale à 100000.

De plus, rien dans le message originel ne permet de définir l'architecture sur laquelle est compilée le programme (si c'est un micro-controleur 8 bits ou 16 bits, il est plus que probable que le long ne fasse pas 32 bits). On ne sait pas non plus quelle ligne est concernée par l'erreur, ni quel fichier. Avoir la sortie exacte du compilateur est certainement plus sûr si un diagnostique est requis.

**Xtrem_Voyageur** · 03/11/2011, 17h25

J'ai jamais raconté autant n'importe quoi dans un post.
Merci de m'avoir repris Emmanuel

.
C'est sûr que 4 octets c'est beaucoup, mais sur le coup, ça répondait bien à son problème alors je ne m'en suis même pas aperçu (ce n'est pas faute d'avoir codé des milliers de boucles avec des int de plus d'un million d'itérations

)
Reste à savoir si sa machine code les int sur 2 octets, il nous faut une sortie comme tu le dis si bien.
Encore merci d'avoir rectifier cette absurdité

(veux se cacher)

**ben_tiba_asma** · 04/11/2011, 01h10

En fait, voila le code entier::

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
#include <stdio.h>
#include <stdlib.h>
 
// Générateur de taches
 
int main()
{
 
int nb_ligne;
int const nb=100;
const int max=100000;
int const min=1;
int deb[nb],fin[nb];
 
int i,j,prov,test;
 
long**init;
long*somme;
//somme=(int**)malloc(max*sizeof(int*));
init=(long**)malloc(nb*sizeof(long*));
 
if (init==NULL)
printf("Echec d'allocation memoire!!!!!!!!");
 
for (i=0;i<nb;i++)
{init[i]=(long*)malloc(max*sizeof(long));
if (init[i]==NULL)
{
for(j=0;j<i;j++)
{//free(init[j]);
printf("Echec d'allocation memoire!!!!!!!!");
}
}
}
 
somme=(long*)malloc(max*sizeof(long));
 
// tester si le système a alloué de la mémoire
 
if (somme!=NULL){
}
else
printf("pas bonne");
 
// fin du test d'allocation
 
 
//long init[nb][max] ;
//long somme[max];
 
FILE* f_m = NULL;
 
f_m = fopen("machine1.txt", "w");
test=0;
 
do{
for (i=0;i<nb;i++)
{for (j=0;j<max;j++)
{init[i][j]=1;
/*fprintf(f_m,"%d  ",init[i][j]);}
fprintf(f_m,"\n");*/}}
 
 
 
for (nb_ligne = 0; nb_ligne < nb; ++nb_ligne)
{
 
		  deb[nb_ligne]=rand() % (max-2) + min;
	//	  fin[nb_ligne]=rand() %(max-deb[nb_ligne]-1) + 1  ;
  //		  printf ("%d   %d\n",deb[nb_ligne],deb[nb_ligne]+fin[nb_ligne]);
 
}
 
		  for (i=0;i<nb_ligne;i++)
		  {for (j=i+1;j<nb_ligne;j++)
		  {if (deb[j]<deb[i])
		  {prov=deb[i];
		  deb[i]=deb[j];
		  deb[j]=prov;}
		  }
		  }
 
		  for (nb_ligne = 0; nb_ligne < nb; ++nb_ligne)
{
 
	//	  deb[nb_ligne]=rand() % (max-2) + min;
		  fin[nb_ligne]=rand() %(max-deb[nb_ligne]-1) + 1  ;
  //		  printf ("%d   %d\n",deb[nb_ligne],deb[nb_ligne]+fin[nb_ligne]);
 
}
 
for (i=0;i<nb;i++)
{for (j=deb[i];j<deb[i]+fin[i];j++)
{init[i][j]=0;}
}
 
/*for (i=0;i<nb;i++)
{for (j=0;j<max;j++)
{printf("%d  ",init[i][j]);}
printf("\n");} */
 
for (i=0;i<max;i++)
{somme[i]=0;
for (j=0;j<nb;j++)
{somme [i]=somme[i]+init[j][i];}
 
if (somme[i]==0)
{test=0;
break;}
else
test=1;
//printf("%d_%d   ",somme[i],test);}
}  }
while (test==0);
	for (nb_ligne = 0; nb_ligne < nb; ++nb_ligne)
	fprintf(f_m,"\n%d %d\n",0,deb[nb_ligne]);
	for (nb_ligne = 0; nb_ligne < nb; ++nb_ligne)
	fprintf(f_m,"\n%d  %d\n",deb[nb_ligne]+fin[nb_ligne],max);
free (init);
free (somme);
return(0);
}//fin main

**ben_tiba_asma** · 04/11/2011, 01h13

Si je compile, voila les message:

warning mach.cpp 11: constant is long in function main()
warning mach.cpp 11: conversion may lose significant digits in function main

aide svp,

**ram-0000** · 04/11/2011, 09h05

En mettant les balises de code autour de ton code, cela aide à la présentation (et puis, cela montre immédiatement le numéro de ligne, pas besoin de compter comme j'ai fait).

La ligne qui pose problème est :

Code :

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

const int max=100000;

Envoyé par Error

warning mach.cpp 11: constant is long in function main()
warning mach.cpp 11: conversion may lose significant digits in function main

.

J'ai l'impression que cela provient du nombre 100000 qui est considéré par le compilateur comme une constante mais qui du coup est une constante longue (plus grande que 65536) et que tu n'as pas spécifiée comme "longue".

Probablement que le simple fait de rajouter "L" après 100000 va régler ce problème.

D'autre part, le 2eme message d'erreur indique que la taille de ton int ne permet pas de stocker un nombre comme 100000. Tu as probablement une architecture dans laquelle un int fait 2 octets. Cela demande confirmation en affichant la taille d'un int :

Code :

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

printf("Taille in=%d\n", sizeof(int));

Donc je te propose de corriger ton code en mettant

Code :

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

const long max=100000L;

**ben_tiba_asma** · 04/11/2011, 09h31

bonjour en fait, après toute rectifications faites , je n'ai plus d'erreurs mais par contre ça entre en boucle infinie quand je fais

Code :

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

[mayoura@mayoura final]$ ./generateur_machine 26 1461 machine  perf

revoilà le code rectifié

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
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
#include <stdio.h> 
 
#include <stdlib.h> 
 
#include <time.h> 
 
//************************************** Générateur de machines 
 
 
 
int main(int argc, char*argv[]) 
 
{ 
 
	long nb_ligne; 
 
	long  const nb=atol(argv[1]); 
 
	long const  max=100000;
 
	long  const copt=atol(argv[2]); 
 
	long deb[nb];
 
	long fin[nb]; 
 
	long i,j,prov,test;
 
	long **init;
 
	long **somme;
 
	init=(long**)malloc( nb * sizeof( long * ));
 
 
 
	if (init==NULL)
 
		printf("Echec d'allocation memoire!!!!!!!!");
 
	for (i=0;i<nb;i++)
 
		{init[i]=(long*)calloc(max,sizeof(long));
 
				if (init[i]==NULL)
 
			{
 
			for(j=0;j<i;j++)
 
			{
 
			printf("Echec d'allocation memoire!!!!!!!!");
 
			}
 
			}
 
		}
 
 
 
	somme=(long **)malloc(max*sizeof(long *));
 
// tester si le système a alloué de la mémoire
 
	if (somme!=NULL){
 
		//printf ("allocation reussie \n");
 
 }
 
else
 
printf("echec");
 
 
 
	FILE* f_m = NULL , *fd=NULL, *fm=NULL; 
 
	f_m = fopen("machine1.txt", "w"); 
 
	test=0; 
 
 
 
	do{ 
 
		for (i=0;i<nb;i++) 
 
			{for (j=0;j<max;j++) 
 
				{init[i][j]=1; 
 
				/*fprintf(f_m,"%d  ",init[i][j]);} 
 
				fprintf(f_m,"\n");*/}} 
 
 
 
		for (nb_ligne = 0; nb_ligne < nb; ++nb_ligne) 
 
		{ 
 
		    srand ( time(NULL) );          
 
		      deb[nb_ligne]=(long)(rand() % ((copt/2)+1) +( copt/2)) + 1;  
 
 		} 
 
          for (i=0;i<nb_ligne;i++) 
 
       		   {for (j=i+1;j<nb_ligne;j++) 
 
          		{if (deb[j]>deb[i]) 
 
          			{prov=deb[i]; 
 
          			deb[i]=deb[j]; 
 
          			deb[j]=prov;} 
 
         		 } 
 
         	 } 
 
         for (nb_ligne = 0; nb_ligne < nb; ++nb_ligne) 
 
		{     srand ( time(NULL) ); 
 
        	fin[nb_ligne]=(long)(rand() % ((copt/2)+1) + copt)+1; 
 
		} 
 
 	for (i=0;i<nb;i++) 
 
		{         for (j=deb[i];j<fin[i];j++) 
 
		            {
                                 init[i][j]=0;
                               } 
 
		}    
 
 
 
	for (i=0;i<max;i++) 
 
	                  {
                           somme[i]=0; 
 
	                     for (j=0;j<nb;j++) 
 
                         	{ 
                                    somme [i]=somme[i]+init[j][i];
                                } 
 
 	                     if (somme[i]==0) 
 
		              {test=0; 
 
		               break;} 
 
	                      else 
 
	                       test=1; 
 
 	}  } 
 
while (test==0); 
 
/****************affichage de machine1.txt*******************/ 
 
 	   for (nb_ligne = 0; nb_ligne < nb; ++nb_ligne) 
 
 		   fprintf(f_m,"\n%d  %ld\n",0,deb[nb_ligne]); 
 
 	   for (nb_ligne = 0; nb_ligne < nb; ++nb_ligne) 
 
 		   fprintf(f_m,"\n%ld  %ld\n",fin[nb_ligne],max); 
 
/****************affichage de machine*******************/ 
 
	fm = fopen(argv[3], "w"); 
 
		for (i=0; i<nb; i=i+1) 
 
		{ 
 
			fprintf(fm,"%ld\t0\t%ld\n%ld\t%ld\t%ld\n%ld\t100002\t100003\n",i+1,deb[i],i+1,fin[i]+1,max,i+1); 
 
		} 
 
/********************affichage de perf********************/ 
 
	fd = fopen(argv[4], "w"); 
 
		for (nb_ligne = 0; nb_ligne < nb; ++nb_ligne) 
 
		{ 
 
    			fprintf(fd, "%ld\t  1",nb_ligne+1); 
 
			fprintf(fd, "\n"); 
 
		}
 
free(init);
 
free(somme);
 
 			return(0); 
 
}//fin main()

merci d'avance

**Bousk** · 04/11/2011, 10h16

Bonjour,

ton code ressemble énormément à un patchwork de Google...
Comprends-tu au moins ce qui est écrit ? parce que ça part dans tous les sens

Dans l'ordre d'apparition:
- la lisibilité laisse à désirer
- la déclaration de deb et fin est illégale
- utilisation de malloc, puis calloc, aucun free
- une boucle inutile pour réaliser des printf d'erreur
- un if sans instruction pour un printf dans le else
- post-incrémentation, pré-incrémentation, i+1
- la seed du rand n'a besoin d'être initialisée qu'une seule fois
- les fichiers ne sont pas fermés à la fin

Ton code refuse de compiler chez moi (VS2010) dès la déclaration de deb et fin.
A quel endroit ton programme semble faire une boucle infinie ? (utilise le debuger, ou debug au printf à défaut) A priori ce serait la dernière boucle qui devrait poser problème, mais puisque ça compile pas :/ (le do..while, où test a, imo, peu de chance de passer à 1)

**ben_tiba_asma** · 04/11/2011, 11h11

bonjour
comment ça un patchwork de google?!!! bien sur que je comprends très bien ce qui est écrit puisque c'est moi qui l'ai fait

je comprends pas franchement ce propos !!!!! si on demande de l'aide sur le forum c'est parce qu'on est vraiment bloqué quelque part , j'ai pas demandé de programmer à ma place

pour la lisibilité je crois que l'indentation est à merveille !!!
pour la déclaration de deb et fin je ne vois franchement pas comment faire , j’avoue que ça m’échappe , ça serait gentil de m'indiquer comment faire ;-)
pour les "free", y'en a deux à la fin du code

Code :

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

1
2
3
free(init);
 
free(somme);

pour les fichiers c'est vrai, parce qe j'ai plusieurs versions d'essais , j'ai oublié de les ajouter

pour le compilateur, je suis sous linux (Fedora), j'utilise directement le gedit et je compile par gcc et ça me donne meme pas de warnings !!! c'est pour ça que je comprends pas

et voilà je viens de faire un petit tour de ménage pour les boucles inutiles et les fichiers et tout mais ça passe toujours pas lors de l'excécution

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
#include <stdio.h> 
 
#include <stdlib.h> 
 
#include <time.h> 
 
//************************************** Générateur de machines 
 
 
 
int main(int argc, char*argv[]) 
 
{ 
 
	long nb_ligne; 
 
	long  const nb=atol(argv[1]); 
 
	long const  max=100000;
 
	long  const copt=atol(argv[2]); 
 
	long deb[nb];
 
	long fin[nb]; 
 
	long i,j,prov,test;
 
	long **init;
 
	long **somme;
 
	init=(long**)malloc( nb * sizeof( long * ));
 
		for (i=0;i<nb;i++)
 
		{
			init[i]=(long*)calloc(max,sizeof(long));
 
		}
 
	somme=(long **)malloc(max*sizeof(long *));
 
 
 
	FILE* f_m = NULL , *fd=NULL, *fm=NULL; 
 
	f_m = fopen("machine1.txt", "w"); 
 
	test=0; 
 
 
 
	do{ 
 
		for (i=0;i<nb;i++) 
 
			{for (j=0;j<max;j++) 
 
				{init[i][j]=1; 
 
				}
                         } 
 
		for (nb_ligne = 0; nb_ligne < nb; ++nb_ligne) 
 
		{ 
 
		    srand ( time(NULL) );          
 
		      deb[nb_ligne]=(long)(rand() % ((copt/2)+1) +( copt/2)) + 1;  
 
 		} 
 
          for (i=0;i<nb_ligne;i++) 
 
       		   {
                        for (j=i+1;j<nb_ligne;j++) 
 
          		  {
                                if (deb[j]>deb[i]) 
 
          			 {
                                  prov=deb[i]; 
 
          			  deb[i]=deb[j]; 
 
          			  deb[j]=prov;
                                  } 
 
         		 } 
 
         	 } 
 
         for (nb_ligne = 0; nb_ligne < nb; ++nb_ligne) 
 
		{     
 
        	fin[nb_ligne]=(long)(rand() % ((copt/2)+1) + copt)+1; 
 
		} 
 
 	for (i=0;i<nb;i++) 
 
	       {
		for (j=deb[i];j<fin[i];j++) 
 
			{
			init[i][j]=0;
	                } 
 
		} 
 
 
 
	for (i=0;i<max;i++) 
 
	  {
            somme[i]=0; 
 
	       for (j=0;j<nb;j++) 
 
	           {
                       somme [i]=somme[i]+init[j][i];
                   } 
 
 	        if (somme[i]==0) 
 
		{
                       test=0; 
 
		       break;
                } 
 
        	else 
 
	            test=1; 
 
 	}  
} 
 
while (test==0); 
 
/****************affichage de machine1.txt*******************/ 
 
 	   for (nb_ligne = 0; nb_ligne < nb; ++nb_ligne) 
 
 		   fprintf(f_m,"\n%d  %ld\n",0,deb[nb_ligne]); 
 
 
 	   for (nb_ligne = 0; nb_ligne < nb; ++nb_ligne) 
 
 		   fprintf(f_m,"\n%ld  %ld\n",fin[nb_ligne],max); 
 
	fclose(f_m);
 
/****************affichage de machine*******************/ 
 
	fm = fopen(argv[3], "w"); 
 
		for (i=0; i<nb; i=i+1) 
 
		{ 
 
			fprintf(fm,"%ld\t0\t%ld\n%ld\t%ld\t%ld\n%ld\t100002\t100003\n",i+1,deb[i],i+1,fin[i]+1,max,i+1); 
 
		} 
	fclose(fm);
 
/********************affichage de perf********************/ 
 
	fd = fopen(argv[4], "w"); 
 
		for (nb_ligne = 0; nb_ligne < nb; ++nb_ligne) 
 
		{ 
 
    			fprintf(fd, "%ld\t  1",nb_ligne+1); 
 
			fprintf(fd, "\n"); 
 
		}
fclose(fd);
 
free(init);
 
free(somme);
 
 			return(0); 
 
}//fin main()

**Bousk** · 04/11/2011, 11h34

Désolé que tu le prennes mal, ce n'est pas le but. Juste un ressenti à la lecture.
Par patchwork, je veux dire qu'on voit tout mélangé dans les écritures, en particulier les incrémentations écrites de 3 manières différentes.
Et si l'indentation est correcte (peut-être mal affichée sur le forum), écrire du code directement derrière une accolade l'est moins. Ca fait aussi partie de la lisibilité, aérer son code, sans tomber dans l'excès.

Pour la déclaration de deb et fin, je te refournis ce lien vers le cours, que j'ai indiqué dans l'autre thread. Ou encore cette page de FAQ.

Les fclose manquants ne sont pas "trop génant" dans le sens où les fichiers sont de toutes façons fermées à la fin du programme.
Les free, il en manque énormément.

Je remarque d'ailleurs que le type de somme est incorrect.

**ben_tiba_asma** · 04/11/2011, 11h38

c'est pas grave

pour les incrémentations c'est parce que le code a été réécrit plusieurs fois sur plusieurs parties

pour les free ils sont pas suffisants ceux à la fin?
je vais essayer de voir comment rectifier pour la déclaratio de deb et fin , dois-je leurs allouer de l'espace dynamiquement aussi ? et voir ce qui ne va pas avec celle de somme :-)
sinon d'autres remarques ?!! surtout pour la boucle infinie je comprends pas

**Bousk** · 04/11/2011, 12h03

deb et fin, tout comme init et somme, sont des tableaux dynamiques : on ne connait pas leur taille à la compilation
Donc oui l'allocation dynamique est obligatoire.

Le type de somme est incorrect : qu'est-ce qui est stocké dans somme ? des long; il s'agit d'un tableau de long
Le type de somme est long**, soit un tableau de long*
Tu vois bien que ça ne match pas. (mais par chance ça peut fonctionner, ou en tous cas ne pas crasher vue l'utilisation qui en est faîte)

Les free, cf les liens que j'ai fournit :

A chaque malloc ou calloc doit correspondre un et un seul free.

En particulier cette partie du cours qui traite de la libération de tableau bidimensionel à la fin.

Ton code doit comporter autant de free qu'il y a de malloc/calloc, et les boucles peuvent s'avérer vicieuses au début.

Concrêtement:

Code :

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

init=(long**)malloc( nb * sizeof( long * ));

1 malloc

Code :

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

1
2
3
4
5
6
for (i=0;i<nb;i++)
 
		{
			init[i]=(long*)calloc(max,sizeof(long));
 
		}

nb malloc

Code :

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

somme=(long **)malloc(max*sizeof(long *));

1 malloc (avec le mauvais type)

On a donc nb+2 malloc pour... 2 free !
Il en manque un morceau

Code :

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

1
2
 
free(somme);

sera correct puisque somme est un tableau à 1 dimension

Code :

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

free(init);

ça casse.

**ben_tiba_asma** · 04/11/2011, 12h15

merci pour toutes ces précisions, je vais essayer de faire vite et revenir j'espère que tu seras toujours là

**Sve@r** · 04/11/2011, 12h17

Envoyé par Bousk

Concrêtement:

Code :

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

init=(long**)malloc( nb * sizeof( long * ));

1 malloc

Code :

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

1
2
3
4
5
6
for (i=0;i<nb;i++)
 
		{
			init[i]=(long*)calloc(max,sizeof(long));
 
		}

nb malloc

Code :

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

somme=(long **)malloc(max*sizeof(long *));

Code :

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

1
2
 
free(somme);

sera correct puisque somme est un tableau à 1 dimension

Code :

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

free(init);

ça casse.

Bonjour

Ca casse oui mais pas parce que c'est un tableau 2D. Ou, plus précisément, ce n'est pas parce que somme est un tableau 1D que le free(somme) est correct.
Rien n'interdit ceci

Code :

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

1
2
init=(long**)malloc( nb * sizeof( long * ));
free(init);

Ce qui fait casser, c'est que les pointeurs individuels init[x] ont eux-aussi reçu une zone allouée par calloc() sans avoir été libérés ensuite...

**ben_tiba_asma** · 04/11/2011, 12h27

donc voilà après toutes les rectifications faites c'est toujours pareil pour la boucle infinie

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
#include <stdio.h> 
 
#include <stdlib.h> 
 
#include <time.h> 
 
//************************************** Générateur de machines 
 
 
 
int main(int argc, char*argv[]) 
 
{ 
 
	long nb_ligne; 
 
	long  const nb=atol(argv[1]); 
 
	long const  max=100000;
 
	long  const copt=atol(argv[2]); 
 
	long *deb;
 
	long *fin; 
 
	long i,j,prov,test;
 
	long **init;
 
	long *somme;
 
	init=(long**)malloc( nb * sizeof (  long * ));
 
		for (i=0;i<nb;i++)
 
		{
			init[i]=(long*)calloc(max,sizeof(long));
 
		}
 
 
	somme=(long*)malloc(max*sizeof(long *));
	deb=(long*)malloc(nb*sizeof(long *));
	fin=(long*)malloc(nb*sizeof(long *));
 
 
 
	FILE* f_m = NULL , *fd=NULL, *fm=NULL; 
 
	f_m = fopen("machine1.txt", "w"); 
 
	test=0; 
 
 
 
	do{ 
 
		for (i=0;i<nb;i++) 
 
			{for (j=0;j<max;j++) 
 
				{init[i][j]=1; 
 
				}
                         } 
 
		for (nb_ligne = 0; nb_ligne < nb; ++nb_ligne) 
 
		{ 
 
		    srand ( time(NULL) );          
 
		      deb[nb_ligne]=(long)(rand() % ((copt/2)+1) +( copt/2)) + 1;  
 
 		} 
 
          for (i=0;i<nb_ligne;i++) 
 
       		   {for (j=i+1;j<nb_ligne;j++) 
 
          		{if (deb[j]>deb[i]) 
 
          			{prov=deb[i]; 
 
          			deb[i]=deb[j]; 
 
          			deb[j]=prov;} 
 
         		 } 
 
         	 } 
 
         for (nb_ligne = 0; nb_ligne < nb; ++nb_ligne) 
 
		{     
 
        	fin[nb_ligne]=(long)(rand() % ((copt/2)+1) + copt)+1; 
 
		} 
 
 	for (i=0;i<nb;i++) 
 
	       {
		for (j=deb[i];j<fin[i];j++) 
 
			{
			init[i][j]=0;
	                } 
 
		} 
 
 
 
	for (i=0;i<max;i++) 
 
	{somme[i]=0; 
 
	for (j=0;j<nb;j++) 
 
	{somme [i]=somme[i]+init[j][i];} 
 
 	if (somme[i]==0) 
 
		{test=0; 
 
		break;} 
 
	else 
 
	test=1; 
 
 	}  } 
 
while (test==0); 
 
/****************affichage de machine1.txt*******************/ 
 
 	   for (nb_ligne = 0; nb_ligne < nb; ++nb_ligne) 
 
 		   fprintf(f_m,"\n%d  %ld\n",0,deb[nb_ligne]); 
 
 	   for (nb_ligne = 0; nb_ligne < nb; ++nb_ligne) 
 
 		   fprintf(f_m,"\n%ld  %ld\n",fin[nb_ligne],max); 
	fclose(f_m);
 
/****************affichage de machine*******************/ 
 
	fm = fopen(argv[3], "w"); 
 
		for (i=0; i<nb; i=i+1) 
 
		{ 
 
			fprintf(fm,"%ld\t0\t%ld\n%ld\t%ld\t%ld\n%ld\t100002\t100003\n",i+1,deb[i],i+1,fin[i]+1,max,i+1); 
 
		} 
	fclose(fm);
 
/********************affichage de perf********************/ 
 
	fd = fopen(argv[4], "w"); 
 
		for (nb_ligne = 0; nb_ligne < nb; ++nb_ligne) 
 
		{ 
 
    			fprintf(fd, "%ld\t  1",nb_ligne+1); 
 
			fprintf(fd, "\n"); 
 
		}
fclose(fd);
 
for (i=0;i<nb;i++)
 
		{
			free(init[i]);
 
		}
free(init);
 
free(somme);
free(deb);
free(fin);
 
 			return(0); 
 
}//fin main()

j'ai bien libéré les espaces alloués aux init [i]

Code :

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

1
2
3
4
5
6
for (i=0;i<nb;i++)
 
		{
			free(init[i]);
 
		}

c'est toujours pareil!!

**Sve@r** · 04/11/2011, 13h20

Envoyé par ben_tiba_asma

donc voilà après toutes les rectifications faites c'est toujours pareil pour la boucle infinie

Ben tu sais, l'histoire des free n'avait pas pour but de régler le pb de la boucle infinie mais de régler un problème bien plus important à savoir libérer la mémoire allouée. Pb important car indécelable au fonctionnement. En effet, visuellement cela ne change rien que tu libères ou pas. Mais ensuite ça peut provoquer de gros plantages d'autant plus difficiles à trouver que le pb est profond.
Et paradoxalement, ton pb de boucle infinie est relativement mineur parce que 1) il est est visible donc on le remarque et on peut s'y consacrer et 2) il peut se trouver (relativement) facilement...

Essaye un peu, dans ta boucle infinie, d'afficher les valeurs des variables et tu y verras certainement un peu plus clair...

**ben_tiba_asma** · 04/11/2011, 13h30

et bin justement je ne vois pas où c'est la boucle infinie

donc où est ce que je dois mettre les affichages pour l'identifier

aurais-tu une idée stp, j'arrive même plus à me concentrer tellement ça traîne depuis un beau bout de temps ce code à chaque fois que je corrige quelque chose y 'en a plus grave qui surgi

**Sve@r** · 04/11/2011, 14h31

Envoyé par ben_tiba_asma

et bin justement je ne vois pas où c'est la boucle infinie

donc où est ce que je dois mettre les affichages pour l'identifier

aurais-tu une idée stp

A vue de nez, je penserai que le pb se situe dans le do {...} while (test == 0) où peut-être que test reste à 0 (surtout que la seule façon où il passe à 1 se passe après un break donc statistiquement difficile à atteindre). Donc te concentrer sur cette partie de ton algo serait un bon point de départ...

Envoyé par ben_tiba_asma

à chaque fois que je corrige quelque chose y 'en a plus grave qui surgi

C'est la caractéristique de ce genre de souci...