probleme d' allocation

**kamouminator** · 26/11/2006, 02h56

il faut utiliser la fonction itoa()
mais je crois qu'elle decompose en caracteres,donc il faudra soustraire '0' a ces caracteres pour les convertir en chiffres

127

donnera var[0]='1' ce qui signifie code ascii de 1
var[1]='2'
var[2]='7'

pour les convertir en chiffre, il faudra soustraire '0':

'1'-'0'=1
'2'-'0'=2
...

il y a peut etre un autre moyen, mais je ne le connais pas...

et c'est quoi ces operation dont tu parle ??
c'est pas evident de faire des operation sur un nombre tres grand !

**granquet** · 26/11/2006, 03h04

Envoyé par kamouminator

il faut utiliser la fonction itoa()

c'est pas standard !

**mhackgyver** · 26/11/2006, 03h05

--

**kamouminator** · 26/11/2006, 03h06

Envoyé par Dark_Ebola

c'est pas standard !

oui dsl lol...je sais, mais je n'en connais pas d'autre qui fasse le meme travail !

**kamouminator** · 26/11/2006, 03h08

Envoyé par mhackgyver

itoa() ca fait l'inverse, d'un int en string

ca convertie un int en une chaine de caractere oui !
ca fais (en partie) le travail que tu demande,
MAIS comme l'a fais remarqué dark ebola, c'est pas standard...

**mhackgyver** · 26/11/2006, 03h18

Citation:
mhackgyver a écrit :
itoa() ca fait l'inverse, d'un int en string

ca convertie un int en une chaine de caractere oui !
ca fais (en partie) le travail que tu demande,
MAIS comme l'a fais remarqué dark ebola, c'est pas standard...

oui j'ai compris apres

bon je vais faire des operations par bloc de int, ca sera plus facile.

---------------

nouveau probleme: toujours d'allocation

j'ai la compression d'huffman a faire, ca marche sur les petit texte, mais sur les gros non:

quand j'affiche la liste des carateres et leur occurences avant la fonction creer_dico, c'est bon, mais quand j'affiche apres, la valeur des occurence des caractere plus grand que 128 en ascii. j'ai mon arbre qui a completement changer les caracteres on des code -xx les occcurences sont vers 400254554,

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
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
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <string.h>
 
unsigned char code[100];
 
struct NOEUD
{
	int poids;
	char c;
	struct NOEUD *fg,*fd;
};
 
struct NOEUD *creernoeud(int poids,char c,struct NOEUD *fg,struct NOEUD *fd)
{
	struct NOEUD *noeud;
	noeud=(struct NOEUD*)malloc(sizeof(struct NOEUD));
	noeud->poids=poids;
	noeud->c=c;
	noeud->fg=fg;
	noeud->fd=fd;
	return noeud;
}
 
struct NOEUD *fusionner(struct NOEUD *fg,struct NOEUD *fd)
{
	return creernoeud(fg->poids+fd->poids,0,fg,fd);
}
 
unsigned char conv(char *txt,int ibit)
      {
        unsigned char c=0;      // l'octet qui sera renvoyé
        unsigned char bit=0x1;  // bit de poids le plus faible ; par la suite, 'bit' contiendra le bit de poids courant
        int i;
        for( i=ibit+7 ; i>=ibit ; --i )
         {
           if( txt[i]=='1')   // on suppose que txt ne contient que des '0' ou des '1'
            c |= bit;           // on ajoute le bit courant
           bit = bit<<1;       // on décale d'un cran
//affichage du calcul:
           //printf("txt[i]=%c i=%d  bit=%d c=%d\n",txt[i],i,bit,c);
           //system("pause");
//
         }
         //printf("\nc defin=%d",c);
       return c;
      }
 
void analyser(char fichier[],int Occ[])
{
	FILE *f;
	int i,c;
	for(i=0;i<256;i++)	Occ[i]=0;
	f=fopen(fichier,"rb");
	while(1)
	{
		c=fgetc(f);
		if (c==EOF)	break;
		Occ[c]++;
		//if(c==128) printf("c=%d\tocc=%d",c,Occ[c]);
	}
	fclose(f);
}
 
struct NOEUD *extrairemin(struct NOEUD *T[],int n)
{
	int k,i;
	struct NOEUD *tmp;
	k=-1;
	for(i=0;i<n;i++)
		if (T[i]!=NULL)
		{
			if (k==-1) k=i;
			if (T[i]->poids<T[k]->poids) k=i;
		}
	if (k==-1)	return NULL;
	tmp=T[k];
	T[k]=T[n-1];
	return tmp;
}
 
// fabrication du code binaire
struct NOEUD *codage(int Occ[])
{
	int n,i,j;
	struct NOEUD *tmp1,*tmp2,*T[256];
	j=0;
	for(i=0;i<256;i++)
		if (Occ[i]!=0)
		{
			T[j]=creernoeud(Occ[i],i,NULL,NULL);
			j++;
		}
	n=j;
	for(i=0;i<n-1;i++)
	{
		tmp1=extrairemin(T,n-i);
		tmp2=extrairemin(T,n-i-1);
		T[n-i-2]=fusionner(tmp1,tmp2);
	}
	return T[0];
}
 
void afficher(struct NOEUD *arbre,int n)
{
	int i;
	for(i=0;i<n;i++) printf("-");
	if (arbre->fg==NULL && arbre->fd==NULL)
	{
		code[n]='\0';
		printf("> \'%d\' (poids=%d) (code=%s)\n",arbre->c,arbre->poids,code);
	} else
	{
		printf("> pere (poids=%d)\n",arbre->poids);
		code[n]='0';
		afficher(arbre->fg,n+1);
		code[n]='1';
		afficher(arbre->fd,n+1);
	}
}
 
int creerdico(struct NOEUD *arbre,char *dico[256],int n)
{
	if (arbre->fg==NULL && arbre->fd==NULL)
	{
		code[n]='\0';
		dico[arbre->c]=malloc(3000);
		strcpy(dico[arbre->c],code);
		printf("c=%d code=%s\n",arbre->c,dico[arbre->c]);
	} else
	{
		code[n]='0';
		creerdico(arbre->fg,dico,n+1);
		code[n]='1';
		creerdico(arbre->fd,dico,n+1);
	}
}
 
void creerfilebin(char *dico[256],char filein[],char fileout[],int Occ[],int taille)
{
	FILE *fin,*fout;
	int i,j,c_out,aux;
	char t[50];
	j=0;
	char c;
    fin=fopen(filein,"rb");
	fout=fopen(fileout,"wb");
	while(1)
	{
        c=fgetc(fin);
        if (c==EOF && taille!=0) break;
        if (c==EOF && taille>0)
        {
                for(i=8;i>8-taille;i--) t[i]=0;
                j=8;
                taille=0;
        }
        if(j<8)
        {
            for(i=0;i<strlen(dico[c]);i++)
            {
                t[j]=dico[c][i];
//code inseré dans la tableau:
//printf("%c",dico[c][i]);
                j++;
            }
        }
        else
        {
            c_out=conv(t,0);
            printf("%d",c_out);
            //system("pause");
            fprintf(fout,"%c",c_out);
            for(i=0;i<j-8;i++) t[i]=t[i]+8;
            j=j-8;
        }
    }
    fclose(fin);
	fclose(fout);
}
 
int taillef(const char *file)
{
	int taille;
	FILE *f = fopen(file,"rb");
	if(!f) return(-1);
	fseek(f, 0, 2);
	taille = (int)ftell(f);
	fclose(f);
	return(taille);
}
 
int main()
{
	char filein[200],fileout[200],*dico[256];
	unsigned int Occ[256],t,taille_out_bin,taille_out_bin_add,i;
	struct NOEUD *arbre;
	taille_out_bin=0;
	printf("Fichier a compresser :");
	scanf("%s",filein);
	printf("Compresser dans :");
	scanf("%s",fileout);
	t=time(0);
	analyser(filein,Occ);
	arbre=codage(Occ);
		for(i=0;i<256;i++)
	{
	    if(Occ[i]!=0)
	    {
            printf("%d\t%d\t\n",i,Occ[i]);
        }
	}
        system("pause");
    creerdico(arbre,dico,0);
        printf("%c\t%d\tn",128,Occ[128]);
        		for(i=0;i<256;i++)
	{
	    if(Occ[i]!=0)
	    {
            printf("%d\t%d\t\n",i,Occ[i]);
        }
	}
        system("pause");
        system("cls");
	afficher(arbre,0);
    printf("carac\toccur\tcode bin\n");
 
//affichage des caractere + occurrences et
//calcule la taille du fichier de sortie sans arrondie a l'octet suivant(en bit)
	for(i=0;i<256;i++)
	{
	    if(Occ[i]!=0)
	    {
            printf("%d\t%d\t%s\n",i,Occ[i],dico[i]);
            taille_out_bin+=Occ[i]*strlen(dico[i]);
        }
	}
 
//bit a ajouter aux fichier pour faire un arrondi a l'octet
	taille_out_bin_add=8-(taille_out_bin%8);
 
//cree le fichier binaire compressé
    creerfilebin(dico,filein,fileout,Occ,taille_out_bin_add);
 
	printf("\n Duree : %ds\n",time(0)-t);
 
 
	return 0;
}

**kamouminator** · 26/11/2006, 03h41

tu pourrais faire l'effort de commenter ton code...

toute facon, je peux plus reflechir (et je connais po ce huffman) ! je vais me pieuter moi...
bon courage a toi...

mais y'a un truc qui me turlupine...y'a quelques messages tu savais meme pas te servir d'un ponteur...et là...tu me pond un arbre...
c'est la camera cachée ?

**koala01** · 26/11/2006, 05h02

Salut,

Comprend que toute valeur est codée en binaire dans l'ordinateur... Quil s'agisse d'un caractere, d'un entier ou de n'importe quoi d'autre...

Si on part du principe qu'un caractère fait 8 bits, tu peux "visualiser" les valeurs sous forme de
1111 1111 ce qui, comme par hasard (c'est pas le hasard, c'est pour cela que l'hexadécimal a été créé

) peut aussi etre affiché sous la forme de
F F

Si l'on considère que le 1 le plus à gauche est le bit de poids fort (celui qui correspond à la valeur la plus élevée), il faut savoir qu'il peut avoir deux significations:

Soit il signifie simplement que c'est (ici pour 8 bits) "une valeur correspondant à 128" (2^7), mais il ne vaudra effectivement 12 que pour les caracteres (selon l'exemple) déclarés en "non signés" (unsigned )

une valeur de 1001 0101 correspondra alors à 128+16+4+1=153

Soit, dans tous les cas des types "signés", qui arrivent par défaut quand on ne précise pas "unsigned", un 0 indiquera que ce qui suit est une valeur positive alors qu'un 1 indiquera une valeur negative...

Cela signifie que l'on aura des valeurs positives entre 0000 0000 (0x00) et 0111 1111(0x7F ou... 127) et des valeurs négatives entre 1000 000 (0x80) et 1111 1111 (0xFF)

Un des problèmes, mais, comme ca sort de ce que je veux expliquer, je ferai l'impasse sur les explications permettant de le contourner, c'est que 1000 0001 ne vaut pas ... -1... (si quelqu'un tient à ces explications, elles se feront par MP

)

Par contre, le problème qui se pose réellement à toi, c'est que tu ne veux pas des valeurs négatives...

La solution est donc toute simple: tu dois choisir de travailler en valeurs non signées (tu ne dois pas utiliser un char, mais un unsigned char...)

Les explications que j'ai données ici pour un octet restent tout à fait valables, évidemment, si tu décide de travailler avec un entier... à la différence que l'on travaillera (*peut etre*, mais pas forcément, et en considérant que c'est le cas

) avec des valeurs utilisant 4 octets (32 bits) et que les valeurs négatives s'étaleront à 0x80 00 00 00 et 0xFF FF FF FF (les espaces ici n'étant rajoutés que pour montrer que l'on a 4 octets

) si tu ne précise par qu'il s'agit d'un entier non signé (unsigned int)

**granquet** · 26/11/2006, 05h56

Envoyé par koala01

"une valeur correspondant à 124" (2^7)

t'as bu quoi ce soir?

**koala01** · 26/11/2006, 09h05

Envoyé par Dark_Ebola

t'as bu quoi ce soir?

Pas assez, on dirait...

Je modifies mon message

gl · 26/11/2006, 11h09

Envoyé par kamouminator

mais un entier ne peut pas depasser 4 octets !!!
un entier mesure 4 octets !

La norme dit qu'un int doit au minimum garantir la plage -32767 à 32767 (0 à 65535 pour un unsigned int). D'apres la norme, un int fait donc au minimum 2 octets et il n'y a pas de limite maximale.
Apres la taille des type dans les implementations dependent de l'implementation (il faut lire la doc correspondante) mais rien empeche d'avoir des int de 8 ou 16 octets (voir 18 ou 24 bits).

Envoyé par kamouminator

oui dsl lol...je sais, mais je n'en connais pas d'autre qui fasse le meme travail !

sprintf (ou snprintf en C99).

**mhackgyver** · 26/11/2006, 12h42

merci, pour le unsigned je l'avais mis au variable ou je pensais que ca fesait ce probleme, mais apparement c'etait pas elles, donc j'ai mis des unsigned partout (sauf 2 negative), et ca marche
maintenant c'est la compression qui marche plus, je vais voir le probleme

**kamouminator** · 26/11/2006, 12h57

Envoyé par gl

La norme dit qu'un int doit au minimum garantir la plage -32767 à 32767 (0 à 65535 pour un unsigned int).

autant pour mo, j'ai confondu avec les float...
mais j'ai pas compris... tu parle de int de 8 ou 16 octets...tu voulais dire bits ?

gl · 26/11/2006, 13h08

Envoyé par Emmanuel Delahaye

snprintf() ...

Oups!!! Corrige

gl · 26/11/2006, 13h15

Envoyé par kamouminator

autant pour mo, j'ai confondu avec les float...

Non, de meme que pour les int, une implementation est libre de faire mieux que le minimum requis.

Envoyé par kamouminator

mais j'ai pas compris... tu parle de int de 8 ou 16 octets...tu voulais dire bits ?

Non, je parlais bien d'octet : d'ailleurs un int de 8bits ne serait pas conforme car pas suffisant pour contenir la plage minimale garantie.
16 bits par contre est suffisant et une inplementation avec des int de 16bits est conforme (et d'ailleurs existe).

**kamouminator** · 26/11/2006, 13h33

mais je comprend pas là...quand je defini une variable a de type unsigned int, et que je lui attribue un nombre de 8 octet, et quand je fais printf("%d",a)
je n'ai pas du tout le nombre attendu...
il faudrait utiliser autre chose que int alors ? pour moi entier = int !

**Emmanuel Delahaye** · 26/11/2006, 14h13

Envoyé par kamouminator

mais je comprend pas là...quand je defini une variable a de type unsigned int, et que je lui attribue un nombre de 8 octet, et quand je fais printf("%d",a)
je n'ai pas du tout le nombre attendu...

Montre le code.

Au fait en C, les entiers peuvent avoir plusieurs types :

char
signed char
unsigned char
short
unsigned
int
unsigned int
long
unsigned long

et en C99 on a en plus

long long
unsigned long long

On choisi le bon type en fonction des besoins réels ou supposés.
(langue de bois detected)

**kamouminator** · 26/11/2006, 14h35

Envoyé par Emmanuel Delahaye

On choisi le bon type en fonction des besoins réels ou supposés.

bah un si j'ai bien compris(en fait je ne pense pas avoir compris du tout...), il voulais convertir tout un fichier de 5mo en un entier de 5mo...

sinon, pour un code exemple:

Code :

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

1
2
3
4
5
6
7
8
9
#include<stdio.h>
 
int main(void)
{
    unsigned int a = 18446744073709551615; /* equivaut a (2^64)-1 (8 octets remplies de 1)*/
 
    printf("%d",a);
    return 0;
}

ca n'affiche pas le nombre attendu ! donc il y a une limite...non ?

**Emmanuel Delahaye** · 26/11/2006, 14h44

Envoyé par kamouminator

ca n'affiche pas le nombre attendu ! donc il y a une limite...non ?

Ben oui (ici, "%d" donc int : INT_MAX) et elle est indiquée dans le fichier <limits.h> de ton implémentation :

Code :

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

1
2
3
4
5
6
7
8
9
 
#include <stdio.h>
#include <limits.h>
 
int main (void)
{
   printf ("INT_MAX = %d\n", INT_MAX);
   return 0;
}

Code :

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

1
2
3
4
 
INT_MAX = 2147483647
 
Press ENTER to continue.

Pour être portable, il faut utiliser les valeurs minimales garanties par le langage C :
http://emmanuel-delahaye.developpez.com/init_c.htm#type

J'ai dit.

**kamouminator** · 26/11/2006, 14h59

ah ok, je ne savais pas qu'il était possible de changer cette limite !

probleme d' allocation

C

Discussions similaires

Partager

Partager