fredguyso
Messages postés1Date d'inscriptionvendredi 5 juillet 2013StatutMembreDernière intervention 9 août 2013
-
9 août 2013 à 22:04
cs_louis14
Messages postés793Date d'inscriptionmardi 8 juillet 2003StatutMembreDernière intervention10 février 2021
-
13 août 2013 à 08:40
bonjour s'il vous plait j'ai besoin d'aide mon code de compression/décompression plante lors de la décompression et par ailleurs ne me restitue pas les données initialement compressées (0 octet) mais la compression se fait bien. merci pour votre attention et voici le code même et merci de tenir compte des données volumineux dans le test s'il vous plait
///////////////////////////////////////////////////////////
//// ////
/// BE d'info: COMPRESSION / DECOMPRESSION ///
/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ///
//// ////
///////////////////////////////////////////////////////////
#include <malloc.h> /* Allocation mémoire: initialisation des pointeurs */
#include <string.h> /* Permet l'ajout de l'extension TWG à un nom de fichier */
#include <stdio.h> /* Entrée-Sortie standard (clavier-ecran) */
#include <conio.h> /* Entrée-Sortie pour la console (gestion clavier-ecran) */
#include <math.h> /* Conversion binaire>decimale puissance de 2 */
#include <io.h> /* Entrée-Sortie de flux */
/* (donnée allant sur memoire de masse) */
/*************
* Structures ****************************************************************************
*************/
typedef struct lettre {
char let; /* Lettre image du code ASCII */
int ascii; /* Code ASCII de la racine/noeud/feuille */
int nbr; /* Frequence de repetition des caracteres */
int lblg; /* Indicateur gauche */
int lbld; /* Indicateur droit */
lettre *ptg; /* Sous-structure gauche d'un noeud/racine */
lettre *ptd; /* Sous-structure droite d'un noeud/racine */
} LETTRE; /* Le tout forme l'arbre */
typedef struct caract{
char let; /* Lettre retenue de l'arbre */
int nbr_bit; /* Nombre de bit sur lequel sera interprete le code */
unsigned long int code; /* Code décimale qui sera codé en binaire */
} CARACT;
/*************
* Procédures ****************************************************************************
*************/
int size_file(FILE *ptf,char name[128]); /* Calcul la taille d'un fichier */
void initialise(void); /* Initialise le tableau de l'arbre */
void visionner(char fichier[128]); /* Visualisation d'un fichier */
void occurence(); /* Calcul la fréquence d'apparition d'un caractère */
void init_tab(); /* Initialisation du tableau des occurences (feuilles) */
void init_table(); /* Initialise la table de compression (code binaire) */
void tri_freq(int stop); /* Tri selon les frequence des feuilles */
void tri_ascii(int stop); /* Tri selon les code ASCII des feuilles */
void creer_arbre(); /* Creer des structures memorisant les donnes */
void tab_sans_zero(); /* Supprime les caracteres inexistant */
void lire_arbre(); /* Lit l'arbre pour connaitre le nouveau code binaire */
/* de chaque caracteres */
void entete_fichier(); /* Ecriture du tableau en entete du fichier pour la */
/* lecture de l'arbre qui permettra la decompression */
void lire_entete(); /* Lire l'arbre ecrit en entete du fichier. */
void decompression(); /* Ecrit le fichier decompressé */
void compresser(); /* Ecrit le fichier compressé */
void crypter(char nom[128]); /* Crypte un fichier */
void decrypter(char nom_dcr[128]); /* Décrypte un fichier */
int test_file(char name_test[128]); /* Teste si un fichier existe */
/*********************
* Variables globales ********************************************************************
*********************/
LETTRE t[256]; /* Variable de l'arbre */
CARACT table[256]; /* Structure de conversion */
FILE *stream; /* Flux du fichier */
FILE *point; /* Flux du fichier à compresser */
FILE *strime; /* Flux du fichier à décompresser */
char nom[128],nom_cmp[128]; /* Nom des fichiers */
char decomp[128]; /* Nom du fichier decompressé */
int test=1,tay=0,taille_tab=0; /* Test sur le flux */
int fin=256; /* Il y a 256 codes ASCII */
int nbin[264]; /* Tableau du code binaire (256+8) */
int pos=0; /* Position dans l'entete */
int taille_o=0; /* Taille du fichier source */
int taille_f=0; /* Taille du fichier décompressé */
int taille_c=0; /* Taille du fichier compressé */
int i=0; /* Variable de l'itération par défaut */
/***********************
* Programme principal ******************************************************************
***********************/
int main(char choix)
{
int i,j=0;
int choice,m=0;
char name[128];
initialise();
printf("%c%c%c%c Operation sur le fichier: %c [1] Compresser\n"
" ßßßßßßßßßßßßßßßßßßßßßßßßßßß %c [2] Decompresser\n"
" %c [3] Crypter\n"
" %c [4] Decrypter\n"
" %c [5] Visionner\n"
,176,177,178,219,175,175,175,175,175);
choice=getch(); /* GETCH renvoie le code ASCII de la touche frappée */
choix=char(choice); /* Transformation de ce code en caractère */
switch(choix)
{
case '1':
{ /* majuscule au cas où CAPS LOCK serait enfoncé */
printf("\n%c Compression\n" /* malencontreusement */
"Nom du fichier: ",16);
gets(nom);
fflush(stdin); /* FFLUSH(STDIN) élimine les parasites en enrée */
stream=fopen(nom,"rb");
if(stream==NULL)
{
printf("Le fichier %s est inexistant\n",nom);
getch();
return 0; /* Quitte l'éxécution sans rien retourner */
}
else
{
fclose(stream);
printf("Nom du fichier de destination: ");
for(i=0;i<128;i++) /* On lit le nom pour connaître le */
{ /* nombre de caractère qu'il contient */
if(&nom[i]!=NULL)
{
m++;
}
}
for(i=0;i<(m-4);i++) /* puis on réécrit le nom sans l'extension */
{ /* dans le nom du fichier cible */
nom_cmp[i]=nom[i];
}
strcat(nom_cmp,".twg"); /* et on lui ajoute une extension */
printf("%s\n",nom_cmp);
fflush(stdin);
printf("\nLecture du fichier........");
occurence();
printf("...OK\n");
fclose(stream); /* Procédures qui vont compresser */
init_tab(); /* Initialise le tableau */
tri_freq(fin); /* Tri selon les féquences des caractères */
tri_ascii(fin); /* Tri selon les codes ASCII si deux fréquences sont égales */
tab_sans_zero(); /* Enlève les caractère inexistant dans le fichier */
creer_arbre(); /* On crée l'arbre */
init_table();
lire_arbre();
}
entete_fichier(); /* On écrit l'arbre d'Huffman en entête du fichier */
compresser(); /* On compresse en écrivant le nouveau code binaire de */
break; /* chaque caractère lu */
}
case '2':
{
printf("\n%c Decompression\n"
"Nom du fichier compresse: ",16);
gets(nom_cmp);
if(test_file(nom_cmp))
{
fflush(stdin); /* Procédures qui vont décompresser */
lire_entete(); /* Lecture de l'arbre écrit en entête du fichier */
decompression(); /* Compare les codes lu dans l'arbre aux codes écrits */
}
break;
}
case '5':
{
printf("\n\n%c Visionner\n"
"Nom du fichier: ",16);
gets(name);
if(test_file(name))
visionner(name);
break;
}
case '3':
{
printf("\n\n%c Crypter\n"
"Nom du fichier: ",16);
gets(name);
if(test_file(name))
crypter(name);
break;
}
case '4':
{
printf("\n\n%c Decrypter\n"
"Nom du fichier: ",16);
gets(name);
if(test_file(name))
decrypter(name);
break;
}
default:
{
printf("\n\nErreur de saisie : '%c' n'est pas une option valide\n",choix);
getch();
return 0;
}
}
return 0;
}
/***************************
* Tri selon les occurences **************************************************************
***************************/
void tri_freq(int stop)
{
char inv='I';
int i=0;
LETTRE per;
while(inv=='I')
{
inv='R';
for(i=0;i<stop;i++)
{
if(t[i].nbr<t[i+1].nbr)
{
per=t[i];
t[i]=t[i+1];
t[i+1]=per;
inv='I';
}
}
}
}
/****************************
* Tri selon les codes ASCII *************************************************************
****************************/
void tri_ascii(int stop)
{
char inv='I';
int i=0;
LETTRE per;
while(inv=='I')
{
inv='R';
for(i=0;i<stop;i++)
{
if((t[i].nbr==t[i+1].nbr)&&(t[i].ascii>t[i+1].ascii))
{
per=t[i];
t[i]=t[i+1];
t[i+1]=per;
inv='I';
}
}
}
}
/**************************
* Construction de l'arbre ***************************************************************
***************************
*
* ***************************************************************************
**** On fusionne deux éléments comme dans la méthode de Huffman. Le résultat *
* est transformé en une structure pointée *
**************************************************************************/
void creer_arbre()
{
LETTRE *ptl;
LETTRE *ptr;
int end=fin;
printf("Construction du fichier...");
while(end>0)
{
ptr=(struct lettre *) malloc(sizeof(LETTRE));
*ptr=t[end];
ptl=(struct lettre *) malloc(sizeof(LETTRE));
*ptl=t[end-1];
if(t[end-1].ascii>t[end].ascii)
{
t[end-1].ascii=t[end].ascii;
t[end-1].let=t[end].let;
}
t[end-1].nbr=t[end].nbr+t[end-1].nbr;
t[end-1].ptd=ptr;
t[end-1].ptg=ptl;
t[end-1].lblg=0;
t[end-1].lbld=0;
end--;
tri_freq(end);
tri_ascii(end);
}
printf("...OK\n");
}
void init_tab()
{
int k;
for(k=0;k<fin;k++)
{
t[k].ptg=NULL;
t[k].ptd=NULL;
}
}
/********************************
* Supprime les zeros du tableau *********************************************************
*********************************
*
* ***********************************************************************
**** Si l'élément en cours est zero, alors on décale à gauche le contenu *
* du tableau *
**********************************************************************/
void tab_sans_zero()
{
while(t[fin-1].nbr==0)
{
fin--;
}
if(fin!=0)
{
fin--;
}
}
/*********************
* Lecture de l'arbre ********************************************************************
**********************
*
* ****************************************************************************
* * L'idée est de faire autant de tests qu'une fonction récursives. *
**** C'est la boucle de remplissage du tableau qui permet a cette *
* procédures de ce repeter elle et ses tests. *
* Le pointeur qui va avancer dans l'arbre et c'est principalement grâce *
* à lui qu'on va savoir si on est sur une feuille ou sur un noeud. *
* LBLG et LBLD vont déterminer avec TAILLE notre avancement dans l'arbre *
* C'est quand cherche sera la tete qu'on aura fini la descente de l'arbre. *
***************************************************************************/
void lire_arbre()
{
LETTRE *cherche; /* Pointeur qui va parcourir l'arbre */
int taille=0; /* Taille de la table */
cherche=&t[0];
if( ( cherche->ptg==NULL) ) /* Si la racine est une feuille */
{ /* c'est qu'il n'y a qu'un seul code ASCII */
test=0; /* Indicateur d'erreur valide */
return; /* On sort de la procédure */
}
else
{
printf("Lecture de la structure...");
while(taille<=fin)
{
if( ((cherche->ptg)->ptg==NULL) && (cherche->lblg==0) )
{ /* Si l'élément suivant est une feuille */
(*cherche).lblg = 1; /* Alors le promeneur se met sur l'élément courant */
table[taille].nbr_bit++; /* On a trouvé un premier bit */
table[taille].code = table[taille].code * 2; /* Le code en base10 est pair */
table[taille].let = (cherche->ptg->let); /* On retient le caractere */
taille++; /* La table a une case de + */
cherche=&t[0]; /* On revient à la racine */
}
else
{
if( (cherche->ptd->ptg==NULL) && ((cherche->lbld==0)) ) /* Si le */
{ /* suivant est une feuille alors */
cherche->lbld =1; /* 'cherche' repart à la racine. */
table[taille].nbr_bit++; /* Le nombre de bit du caractère */
table[taille].code = table[taille].code * 2 + 1;/* est donc incrementé */
table[taille].let = cherche->ptd->let; /* Le code en base 10 */
taille++; /* est impair */
cherche=&t[0]; /* car on est sur une branche droite */
}
else
{ /* Là on va sur la branche gauche */
if( (cherche->ptg->lblg==0) || (cherche->ptg->lbld==0) ) /* Si */
{ /* les deux indicateurs sont à zéro */
cherche=cherche->ptg; /* c'est qu'on est sur un noeud, on peut */
table[taille].code=table[taille].code * 2; /* incrémenter le code */
table[taille].nbr_bit++; /* et le transcrire. */
}
else
{ /* Là on va sur la branche droite */
if( (cherche->ptd->lblg==0) || (cherche->ptd->lbld==0) )
{
cherche=(*cherche).ptd;
table[taille].code=table[taille].code * 2+1;
table[taille].nbr_bit++;
}
else
{
if(cherche==&t[0])
{
break; /* Si on est à la racine c'est */
} /* qu'on a fini de lire l'arbre */
else
{
(*cherche).lblg=1; /* Là on est sur une feuille */
(*cherche).lbld=1;
table[taille].code=0;
table[taille].nbr_bit=0;
table[taille].let='\0';
cherche=&t[0]; /* et on revient à la racine */
}
}
}
}
}
}
}
table[fin].nbr_bit++;
table[fin].code=table[fin].code*2;
fin++;
table[fin].nbr_bit=table[fin-1].nbr_bit;
table[fin].code=table[fin-1].code+1;
printf("...OK\n");
}
/*******************************************
* Ecriture de l'arbre en entête du fichier **********************************************
********************************************
*
* ******************************************************************************
**** On écrit une structure qui sera lue grâce à la fonction FREAD définie dans *
* IO.H *
*****************************************************************************/
void entete_fichier()
{
int k;
strime = fopen(nom_cmp,"wb");
fwrite(&fin,sizeof(int),1,strime);
for(i=0;i<=fin;i++)
{
fwrite(&table[i],sizeof(CARACT),1,strime);
}
for(k=0;k<128;k++)
{
if(&nom_cmp[k]!=NULL)
{
tay++;
}
}
fflush(stdin);
}
/***********************
* Compresse le fichier ******************************************************************
************************
*
* ******************************************************************************
**** On lit la structure de l'arbre et on la compare avec chaque caractere lu. *
* Chaque caractere sera identifié à la chaine de bit lu dans l'entete. *
*****************************************************************************/
void compresser()
{
FILE *restrime;
int zerep=4,quot=0,dec=0,q=0,j=0,power=0;
int v,w,m,f,i,h,k,z,quotp;
int nbin[263];
char comp;
printf("Ecriture dans le ficher...");
for(h=0;h<=262;h++)
{
nbin[h]=0;
}
restrime = fopen(nom,"rb");
while(zerep!=EOF)
{
zerep=fgetc(restrime);
for(z=0;z<fin;z++)
{
if(table[z].let==char(zerep))
{
break;
}
}
if(table[z].code==0)
{
for(m=0;m<table[z].nbr_bit;m++)
{
nbin[j+m] = 0;
}
j=j+m;
}
else
{
if(table[z].code==1)
{
for(m=0;m<table[z].nbr_bit-1;m++)
{
nbin[j+m] = 0;
}
nbin[j-1+table[z].nbr_bit]=1;
j=j+m+1;
}
else
{
quotp = table[z].code;
q = table[z].nbr_bit + j-1;
while(quotp>=1)
{
quot = quotp/2;
nbin[q] = quotp - (quot*2);
quotp = quot;
q--;
}
j=j+table[z].nbr_bit;
if(q<table[z].nbr_bit)
{
for(v=(table[z].nbr_bit-j);v>0;v--)
{
nbin[v] = nbin[v-1];
}
for(w=0;w<(table[z].nbr_bit-j);w++)
{
nbin[w]=0;
}
}
}
}
if(j>7)
{
for(k=0;k<=7;k++)
{
if(nbin[k]==0)
{
dec=dec*2;
}
if(nbin[k]==1)
{
dec=dec*2 +1;
}
}
comp = char(dec);
fwrite(&comp,sizeof(char),1,strime);
for(f=8;f<263;f++)
{
nbin[f-8]=nbin[f];
nbin[f]=0;
}
j=j-8;
dec=0;
}
}
if(j>0)
{
for(i=j;i<8;i++)
{
nbin[i]=0;
}
for(k=0;k<=7;k++)
{
if(nbin[k]==0)
{
dec=dec*2;
}
if(nbin[k]==1)
{
dec=dec*2 +1;
}
}
comp = char(dec);
fwrite(&comp,sizeof(char),1,strime);
}
fclose(strime);
printf("...OK\n");
stream=fopen(nom,"rb");
taille_o=size_file(stream,nom);
stream=fopen(nom,"rb");
taille_c=size_file(stream,nom_cmp);
printf( "\n\nÉÍ Fichier d'origine: ÍÍÍÍÍÍ"
"ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ»\n"
"º %-54s º\n"
"º taille: %-54d º\n"
"ÌÍ Fichier compresse: ÍÍÍÍÍÍÍÍÍÍ"
"ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ͹\n"
"º %-54s º\n"
"º taille: %-54d º\n"
"ÈÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ"
"ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍͼ\n"
,nom,taille_o,nom_cmp,taille_c);
getch();
}
/******************************************
* Lecture de l'arbre en entete du fichier ***********************************************
*******************************************
*
* *************************************************************
**** On lit la structure de l'arbre et on la stock en mémoire. *
************************************************************/
void lire_entete()
{
CARACT per;
int j,k,l;
int z=0;
char inv='I';
for(l=0;l<fin;l++)
{
table[l].nbr_bit=0;
table[l].let='\0';
table[l].code=0;
}
point=fopen(nom_cmp,"rb");
if(point==NULL)
{
printf("%s n'existe pas.",nom_cmp);
getch();
return;
}
printf("Nom du fichier de destination: ");
scanf("%[^'\n']",decomp);
fread(&taille_tab,sizeof(int),1,point);
fread(&table[0],(taille_tab + 1) * sizeof(CARACT),1,point);
printf("\nLecture du tableau.........");
while(inv=='I')
{
inv='R';
for(z=0;z<taille_tab;z++)
{
if(table[z].nbr_bit>table[z+1].nbr_bit)
{
per=table[z];
table[z]=table[z+1];
table[z+1]=per;
inv='I';
}
}
}
for(j=0;j<=taille_tab;j++)
{
if(table[j].nbr_bit==0)
{
for(k=j;k<=taille_tab;k++)
{
table[k]=table[k+1];
}
j--;
taille_tab--;
}
}
printf("...OK\n");
}
/****************
* Decompression *************************************************************************
*****************
*
* ******************************************************************************
**** On écrit tous les caracteres identifiés qui sont en mémoire pour les *
* écrire dans le fichier décompressé. *
*****************************************************************************/
void decompression()
{
FILE *pointor;
int ende,dec=0;
int quot=0;
int quotp=0;
int q=0,k,f,p;
int h=0,j=0;
int nbr_bit;
int compar=0;
union {
int rep; /* Une union est une structure qui prend une taille en mémoire */
char ze_rep[4]; /* définie par le champ qui occupe le plus grand nombre de bit */
} u_rep; /* Ici les deux champs prennent la même place : 8 * 4 = 32 */
/* char ze_rep[4] prend la même place e nmémoire que int rep */
printf("Ecriture dans le fichier...");
for(p=0;p<263;p++)
{
nbin[p]=0;
}
pointor=fopen(decomp,"wb");
nbr_bit = table[h].nbr_bit;
ende=1;
while(ende!=0)
{
u_rep.rep=0;
ende=fread(&u_rep.ze_rep[0],sizeof(char),1,point);
if(ende==0) /* Si FREAD renvoie '0' c'est qu'on est à la fin du fichier */
{
fclose(pointor);
fclose(point);
printf("...OK\n");
stream=fopen(nom_cmp,"rb");taille_o=size_file(stream,nom_cmp);
stream=fopen(decomp,"rb");taille_f=size_file(stream,decomp);
printf( "\n\nÉÍ Fichier d'origine: ÍÍÍÍÍÍ"
"ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ»\n"
"º %-54s º\n"
"º taille: %-54d º\n"
"ÌÍ Fichier decompresse: ÍÍÍÍÍÍÍÍ"
"ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ͹\n"
"º %-54s º\n"
"º taille: %-54d º\n"
"ÈÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ"
"ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍͼ\n"
,nom_cmp,taille_o,decomp,taille_f);
getch();
return;
}
quotp = u_rep.rep;
q = j+7;
while(quotp>=1)
{
quot =(unsigned) quotp/2;
nbin[q] = (unsigned)(quotp - (quot*2));
quotp = (unsigned)quot;
q--;
}
j = j+8;
while((j>0) && (nbr_bit<=table[h].nbr_bit))
{
if(nbr_bit>j)
{
break;
}
compar=0;
for(k=0;k<nbr_bit;k++)
{
if(nbin[k]==0)
{
dec=(unsigned)dec*2;
}
if(nbin[k]==1)
{
dec=(unsigned)dec*2 +1;
}
}
while(table[h].nbr_bit == nbr_bit)
{
if(dec == (signed)table[h].code)
{
fwrite(&table[h].let,sizeof(char),1,pointor);
for(f=nbr_bit;f<=263;f++)
{
nbin[f-nbr_bit]=nbin[f];
nbin[f]=0;
}
j=j-nbr_bit;
dec=0;
compar=nbr_bit;
h=0;
nbr_bit = table[0].nbr_bit;
break;
}
else
{
h++;
}
}
if(table[h].nbr_bit > compar)
{
nbr_bit=table[h].nbr_bit;
dec=0;
}
}
}
fclose(pointor);
fclose(point);
}
/**********************
* Taille d'un fichier *******************************************************************
***********************/
int size_file(FILE *ptf,char name[128])
{
int size=0;
ptf=fopen(name,"rb");
if(ptf!=NULL)
{
while(fgetc(ptf)!=EOF)
{
size++; /* Saisi le caractère et incrémente l'information 'taille du fichier' */
} /* qui est représenté par la variable SIZE */
fclose(ptf);
return size;
}
fclose(ptf);
return 0;
}
/*************************
* Occurence d'un fichier ****************************************************************
**************************/
void occurence()
{
int rep,l;
stream=fopen(nom,"rb");
while((rep=fgetc(stream)) != EOF)
{ /* Début de l'occurence */
for(l=0;l<fin;l++)
{
if(t[l].ascii==rep)
{
t[l].nbr++;
break;
}
}
}
fclose(stream);
}
/*************************************
* Initialise la table de compression ****************************************************
**************************************/
void init_table()
{
int k;
for(k=0;k<fin;k++)
{
table[k].nbr_bit=0;
table[k].let='\0';
table[k].code=0;
}
}
/***********************
* Visualise un fichier ******************************************************************
***********************/
void visionner(char fichier[128])
{
int car;
int nbr_saut=0;
double nbr_car=0;
stream=fopen(fichier,"rb");
printf("\nLecture de %s:\n\n",fichier);
if(stream!=NULL)
{
while( (car=fgetc(stream)) !=EOF)
{
nbr_car++;
if( char(car)=='\n' ) /* Si le caractère rencontré est un saut de ligne */
{
nbr_saut++; /* alors on incrémente le saut */
}
if( nbr_saut==20 ) /* Tous les vingt sauts il y a une attente */
{
nbr_saut=0;
getch();
}
printf("%c",car);
}
}
printf("\nÚÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ"
"ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ¿\n"
"³ Fin du fichier. Taille en octets : %-40g ³\n"
"ÀÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ"
"ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÙ\n",nbr_car);
getch();
}
/********************
* Crypte un fichier *********************************************************************
********************/
void crypter(char nom_cry[128])
{
char nom_dest[128];
for(i=0;i<128;i++)
nom_dest[i]='\0';
int rep;
int code=0;
FILE *stream;
FILE *ptf;
fflush(stdin);
if(strlen(nom_cry)>4)
{
for(i=0;i<int(strlen(nom_cry)-4);i++)
{
nom_dest[i]=nom_cry[i];
}
}
strcat(nom_dest,".clf");
printf("Nom du fichier de destination: %s\n",nom_dest);
printf("Code: ");
scanf("%d",&code);
fflush(stdin);
stream=fopen(nom_cry,"rb");
ptf=fopen(nom_dest,"wb");
if(stream!=NULL && ptf!=NULL)
{
fwrite(&code,sizeof(int),1,ptf);
while( (rep=fgetc(stream)) != EOF )
{
fputc( ((rep+code)%256) ,ptf);
}
fclose(ptf);
fclose(stream);
printf("\nÚÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ"
"ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ¿\n"
"³ Fichier crypte. "
" ³\n"
"ÀÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ"
"ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÙ\n");
getch();
}
}
/**********************
* Décrypte un fichier *******************************************************************
**********************/
void decrypter(char nom_dcr[128])
{
char nom_dest_2[128];
int rep;
int code=0,nb=0,kode=0;
FILE *stream;
FILE *ptf;
printf("Nom du fichier de destination: ");
gets(nom_dest_2);
stream=fopen(nom_dcr,"rb");
ptf=fopen(nom_dest_2,"wb");
if(stream==NULL)
printf("\n\n%s n'existe pas.\n",nom_dcr);
if(stream!=NULL)
{
code=getw(stream);
printf( "Code: ");
scanf(" %d",&kode);
fflush(stdin);
if(code==kode)
{
while( (rep=fgetc(stream)) != EOF )
{
fputc( ((rep-code)%256) ,ptf);
}
fclose(ptf);
fclose(stream);
printf("\nÚÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ"
"ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ¿\n"
"³ Fichier decrypte. "
" ³\n"
"ÀÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ"
"ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÙ\n");
getch();
}
else
{
printf("\nÚÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ"
"ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ¿\n"
"³ Decryptage echoue. "
" ³\n"
"ÀÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ"
"ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÙ\n");
getch();
}
}
}
/********************
* Initalise l'arbre *********************************************************************
********************/
void initialise(void)
{
for(i=0;i<fin;i++)
{
t[i].nbr=0; /* Initialisation du tableau des feuilles */
t[i].let=char(i); /* Enregistrement des 256 caractères ASCII */
t[i].ascii=i; /* Enregistrement des 256 codes ASCII */
t[i].lblg=1;
t[i].lbld=1;
}
}
/*******************************
* Verifie si le fichier existe *********************************************************************
*******************************/
int test_file(char name_test[128])
{
FILE *test;
test=fopen(name_test,"rb");
if(test==NULL)
{
printf("\n\n%s n'existe pas.\n",name_test);
return 0;
}
return 1;
}
BunoCS
Messages postés15476Date d'inscriptionlundi 11 juillet 2005StatutModérateurDernière intervention 3 mai 2024103 11 août 2013 à 22:22
Euh...oui, mais non quoi!
T'as vu la longueur de ton code!? Je n'ai pas envie de chercher la petite bête là-dedans...
Lance ton programme en pas-à-pas et regarde où est le problème
Quelques remarques vite fait!
- je n'aime pas les variables globales
- lignes 1013 à 1015: euh...pourquoi pas mettre if()...else?
