Discussion :

[ben_tiba_asma]

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]

Il faut aller dans le forum C.

Et accessoirement mettre le code entre balises #...

[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

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]

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]

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]

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]

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,

[Bousk]

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]

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]

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]

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

[Sve@r]

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]

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!!