Il s'agit d'un programme qui permet de chercher et de supprimer les redondances des fichiers d'un pc quels qu'ils soient.Il suffit d'entrer le chemin du répertoire ou se fera la recherche et le programme se lance automatiquement dans la recherche.Le chemin peut aussi être le nom d'un lecteur mais il faut remarquer que plus le nombre de fichiers à tester est élevé et plus la recherche met du temps.Le programme génère un rapport qui détaille les opérations qui ont eu lieu, un fichier qui contient la liste et le nombre des fichiers supprimés ainsi que la durée totale des opérations.A la fin de son exécution, le programme émet un signal sonore et ouvre automatiquement le rapport et le fichier contenant la liste des fichiers supprimés.
Source / Exemple :
#include <stdio.h>
#include <stdlib.h>
#include <dirent.h>
#include <conio.h>
#include <string.h>
#include <windows.h>
#include <ctype.h>
#include <io.h>
#include <fcntl.h>
#include <time.h>
#define taillebloc 1024
void son(void) //Fonction de génération d'un signal.
{
for (int a=10,b=5;a<=3000,b<=100;a+=2000,b+=80)
{
Beep(a,b);
}
Beep(1000,100);
}
typedef struct duree //Structure permettant de contenir le nombre de jours, d'heures, de minutes et de secondes après conversion d'une durée en seconde.
{
long nbre_jour,nbre_heure,nbre_minute,nbre_seconde;
}duree;
duree conv_jr_hr_min_sec(long duree_a_conv) //Fonction de conversion d'une durée (prise en seconde) en nombre de jours, d'heures, de minutes et de secondes.
{
duree struct_duree;
struct_duree.nbre_jour=0;
struct_duree.nbre_heure=0;
struct_duree.nbre_minute=0;
struct_duree.nbre_seconde=0;
struct_duree.nbre_jour=duree_a_conv/86400;
struct_duree.nbre_heure=(duree_a_conv%86400)/3600;
struct_duree.nbre_minute=((duree_a_conv%86400)%3600)/60;
struct_duree.nbre_seconde=((duree_a_conv%86400)%3600)%60;
return struct_duree;
}
typedef struct fichier //Structure permettant de gérer les information relatives aux fichiers destinés à contenir les chemins des fichiers après décomposition d'arborescences.
{
FILE *ptr_fichier;
long nbre_elmts;
char filename[10];
double duree_decomposition;
}fichier;
fichier decomposer(char chemin[],char **argv) //Fonction permettant de décomposer une arborescence de fichiers en tous les chemins de fichiers qu'elle contient.
{
DIR *rep0=NULL;
FILE *fichier0=NULL;
struct dirent *fichierlu=NULL;
char string0[1000]={0},string1[1000]={0},string2[1000]={0},string_test0[1000]={0},string_test1[1000]={0},nom_fichier1[10]="Liste";
int cpt0=0,cpt1=0;
fichier struct_fichier;
time_t t_debut,t_fin;
strcpy(struct_fichier.filename,"Liste"); //Copie de la chaîne "Liste" dans le champ filename de la structure fichier, celle ci étant chargée de contenir le nom du fichier sur lequel la fonction decomposer travaille.
chemin[0]=toupper(chemin[0]); //Conversion du 1er caractère du paramètre chemin en majuscule pour cause d'uniformisation.
if(strchr(chemin,':')==NULL) //Si le paramètre chemin ne contient pas les 2 points, alors on le complète.
{
chemin[1]=':';
if(strlen(chemin)==2) //S'il n'y a que 2 caractères dans la chaine, alors elle contient certainement le nom d'un lecteur.On la complète donc avec le caractère '\0'.
{
chemin[2]='\0';
}
}
if((rep0=opendir(chemin))==NULL) //Si l'ouverture du lecteur a échoué, on affiche un message.
{
system("cls");
printf("chemin invalide ...");
Sleep(5000);
exit(0);
}
else //Sinon
{
if((argv[0][0]==chemin[0])&&(argv[0][1]==chemin[1])&&(strlen(chemin)==2)) //On vérifie si chemin est la racine du répertoire qui contient ce programme et si la chaine chemin contient effectivement le nom d'un lecteur.
{
strcat(chemin,"\\.."); //On complète la chaine chemin pour indiquer à la fonction opendir qu'elle doit ouvrir le lecteur à sa racine.
rep0=opendir(chemin);
}
if((fichier0=fopen("Liste0","w+"))==NULL) //Ouverture du fichier Liste0 qui contiendra les éléments contenus à la racine du lecteur.
{
printf("Erreur d\'ouverture du fichier Liste0.\n");
Sleep(5000);
exit(0);
}
else
{
time(&t_debut); //On mémorise l'état de l'horloge au début de la décomposition.
if(strlen(chemin)!=2) //Si la chaine chemin contient plus de 2 caractères
{
if(strlen(chemin)==5) //Si ce nombre de caractères est égal à 5
{
if((chemin[strlen(chemin)-1]!='.')&&(chemin[strlen(chemin)-2]!='.')&&(chemin[strlen(chemin)-3]!='\\')) //On s'assure que la chaine ne contient pas le nom de la racine du dossier qui contient l'exécutable de ce programme.
{
fichierlu=readdir(rep0); //On lit sans afficher les 2 premiers éléments car ceux ci correspondent à . et ..
fichierlu=readdir(rep0);
}
}
else //Si le nombre ce caractères de la chaine chemin est différent de 5, on lit sans afficher les 2 premiers éléments.
{
fichierlu=readdir(rep0);
fichierlu=readdir(rep0);
}
}
while((fichierlu=readdir(rep0))!=NULL) //Tant qu'on n'a pas atteint la fin du répertoire courant
{
memset(string0,'\0',strlen(string0));
memset(string_test0,'\0',strlen(string_test0)); //On initialise les 3 chaines de caractères utilisées pour établir les conditions de restriction d'affichage des chemins après décomposition de l'arborescence.
memset(string_test1,'\0',strlen(string_test1));
if((argv[0][0]==chemin[0])&&(argv[0][1]==chemin[1])&&(strlen(chemin)==5)&&(chemin[strlen(chemin)-1]=='.')&&(chemin[strlen(chemin)-2]=='.')&&(chemin[strlen(chemin)-3]=='\\')) //Si la chaine chemin contient le nom de la racine du dossier contenant l'exécutable de ce programme
{
chemin[2]='\0'; //On remplace le 3eme caractère de la chaine par le caractère de fin de chaine.
strcpy(string0,chemin);
strcpy(string_test0,chemin); //On copie la chaine chemin dans chacune des chaines initialisées ci dessus.
strcpy(string_test1,chemin);
}
else //Sinon on copie directement la chaine chemin dans chacune des 3 chaines initialisées ci dessus.
{
strcpy(string0,chemin);
strcpy(string_test0,chemin);
strcpy(string_test1,chemin);
}
strcat(string0,"\\"); //Concaténation du caractère '\' à la chaine string0.
strcat(string0,fichierlu->d_name); //Concaténation du nom de l'élément courant à la chaine string0.
if((strstr(string0,"\\$RECYCLE.BIN")==NULL)&&(strstr(string0,strcat(string_test0,"\\WINDOWS"))==NULL)&&(strstr(string0,strcat(string_test1,"\\Program Files"))==NULL)) //On écrit dans le ficher que les chemins ne contenant ni "\WINDOWS", ni "\$RECYCLE.BIN", ni "\Program Files" en leur sein.
{
fprintf(fichier0,"%s\n",string0); //Ecriture dans le fichier de la chaine string0.
}
}
}
}
closedir(rep0); //Fermeture du répertoire.
fclose(fichier0); //Fermeture du fichier.
/*
La partie suivante est la plus importante de la fonction decomposer. Le principe de la décomposition est le suivant:
1-Création d'un fichier nommé Liste0 qui contiendra les chemins obtenus après la première phase de décomposition.
La première phase de décomposition consiste à essayer d'ouvrir directement le chemin entré par l'utilisateur à
l'aide de la fonction opendir. La liste de chemins obtenue est directement stockée dans le fichier Liste0.
2-Ouverture du 1er fichier créé en mode lecture pour pouvoir accéder à chacun des chemins stockés à l'intérieur.
3-création d'un autre fichier en mode lecture/écriture portant le nom Liste1.
4-Copie des éléments de Liste0 dans Liste1 tant que ceux ci correspondent à des chemins de fichier.Lorsqu'on tombe
sur un chemin de dossier reconnaissable au fait qu'il est décomposable par action de la fonction opendir, on le
décompose et on stocke chacun des éléments obtenus dans l'ordre dans le fichier Liste1 après les avoir concatenés
au chemin dont ils sont issus, c'est à dire celui dont la décomposition leur a donné naissance.
5-On répète cette opération un nombre fini de fois en vérifiant à chaque fois s'il reste toujours des chemins décomposables
et en faisant évolué le nom des fichiers ainsi obtenus de 1, ie Liste1,Liste2,.........Listen.
sprintf(string2,"%d",cpt0); //Copie de la vateur de cpt0 dans la chaine string2.cpt0 est un compteur incrémenté à chaque tour de boucle qui sert à numéroter les fichiers.
strcat(nom_fichier1,string2); //Concaténation de "Liste" et de la valeur de cpt0 en vue d'obtenir un nom de fichier numéroté.
sprintf(string2,"%d",cpt0+1); //Copie de la valeur de compteur augmentée de 1 dans la chaine string2.
strcat(struct_fichier.filename,string2); //Concaténation du champ de la structure fichier destiné à contenir le nom du fichier courant initialisé auparavant à "Liste" et de la valeur de cpt0 en vue d'obtenir un nom de fichier numéroté.
struct_fichier.nbre_elmts=0; //Initialisation de la variable servant à compter le nombre d'élements contenus dans un fichier.
while(1) //Boucle infinie contenant une condition de sortie ou de rupture.
{
if(((fichier0=fopen(nom_fichier1,"r"))==NULL)||((struct_fichier.ptr_fichier=fopen(struct_fichier.filename,"w+"))==NULL)) //Controle du bon déroulement de l'ouverture du premier fichier et de la création du second fichier. Ces fichiers sont chargés de contenir les chemins au cours de la décomposition de l'arborescence.
{
printf("Erreur d\'ouverture du fichier %s ou du fichier %s.\n",nom_fichier1,struct_fichier.filename);
Sleep(5000);
exit(0);
}
else
{
while(fgets(string1,1000,fichier0)!=NULL) //Lecture du premier fichier.
{
for(int i=0;i<strlen(string1);++i) //Suppression du caractère '\n' pour éviter que la fonction opendir ne retourne une erreur.
{
if(string1[i]=='\n')
{
string1[i]='\0';
}
}
if((rep0=opendir(string1))==NULL) //Si le chemin lu correspond a celui d'un fichier
{
fprintf(struct_fichier.ptr_fichier,"%s\n",string1); //On le recopie comme tel dans le second fichier.
++struct_fichier.nbre_elmts; //Et on incrémente la variable chargée de contenir le nombre d'éléments contenus dans le fichier.
}
else //Si le chemin correspond à celui d'un dossier
{
cpt1=1; //On incrémente cpt1 qui n'est autre que la variable indiquant s'il reste des chemin de dossier dans le fichier. C'est à dire que si cpt1 est à 1 on reboucle et on décompose les chemins de dossier tout en conservant les chemins de fichiers non décomposables.
fichierlu=readdir(rep0);
fichierlu=readdir(rep0);
while((fichierlu=readdir(rep0))!=NULL)
{
memset(string0,'\0',strlen(string0));
strcpy(string0,string1);
strcat(string0,"\\");
strcat(string0,fichierlu->d_name);
fprintf(struct_fichier.ptr_fichier,"%s\n",string0); //Copie du chemin des éléments contenus dans le dossier.
++struct_fichier.nbre_elmts; //Incrémentation de la variable servant à compter le nombre d'éléments dans le fichier.
}
}
}
}
if(cpt1==0) //S'il n'y a que des chemins de fichiers dans le fichier
{
closedir(rep0); //On interrompt les opérations de lecture dans le fichier et dans les répertoires dont les chemins sont contenus dans le fichier.
fclose(fichier0);
rewind(struct_fichier.ptr_fichier); //On ramène le pointeur ptr_fichier au début du fichier pour que l'utilisateur de ce pointeur n'ait pas à le faire. Ainsi, on pourra lire directement le fichier du haut vers le bas sans opération préalabre.
unlink(nom_fichier1); //Destruction de l'avant dernier fichier créé pour conserver le dernier contenant tous les chemins obtenus après décomposition.
time(&t_fin); //On mémorise l'état de l'horloge a la fin de la décomposition.
struct_fichier.duree_decomposition=difftime(t_fin,t_debut); //On mémorise la durée de la décomposition dans le champ duree_decomposition de la structure fichier.
return struct_fichier; //On retourne la structure qui contient toutes les informations relatives au fichier contenant les chemins après décomposition.
}
closedir(rep0);
fclose(fichier0); //Fermeture des descripteurs ouverts afin de reboucler.
fclose(struct_fichier.ptr_fichier);
unlink(nom_fichier1); //Dectruction du premier fichier.
++cpt0; //Incrémentation de cpt0 pour la numérotation du fichier suivant.
cpt1=0; //Réinitialisation de cpt1.
struct_fichier.nbre_elmts=0; //Réinitialisation de la variable chargée de contenir le nombre d'éléments contenus dans le fichier afin qu'il puisse compter le nombre d'éléments du fichier qui sera prochainement créé.
strcpy(nom_fichier1,"Liste");
sprintf(string2,"%d",cpt0); //Réinitialisation de la chaine nom_fichier1.
strcat(nom_fichier1,string2);
strcpy(struct_fichier.filename,"Liste");
sprintf(string2,"%d",cpt0+1); //Réinitialisation du champ de la structure fichier chargée de contenir le nom du fichier courant.
strcat(struct_fichier.filename,string2);
}
}
int main(int argc,char *argv[])
{
FILE *fichier0=NULL,*fichier1=NULL;
char chemin[1000]={0},string0[1000]={0},string1[1000]={0},string2[1000]={0},string3[1000]={0};
int i=0,j=0,handle0=0,handle1=0,handle2=0,nbre_lus0=0,nbre_lus1=0,var_test=0;
long num_fichier_courant=0,cpt0=0,cpt1=0,nbre_fichiers_suppr=0;
unsigned char buffer0[taillebloc]={0},buffer1[taillebloc]={0};
fichier struct_fichier0;
time_t t_debut,t_fin;
duree struct_duree0;
system("color 16"); //Réglage de la couleur de la console.
system("cls");
printf("Entrez le chemin: ");
fgets(chemin,1000,stdin); //Saisie du chemin par l'utilisateur.
for(i=0;i<strlen(chemin);++i) //Controle du chemin entré par l'utilisateur afin de vérifier qu'il ne contient pas de caractère '\n'.
{
if(chemin[i]=='\n')
{
chemin[i]='\0';
}
}
system("cls");
struct_fichier0=decomposer(chemin,argv); //Appel de la fonction decomposer avec comme arguments, le chemin entré par l'utilisateur et le paramètre de la fonction main contenant le chemin du programme.
printf("\n\n\nTraitement en cours .");
Sleep(1000);
system("cls");
printf("\n\n\nTraitement en cours ..");
Sleep(1000);
system("cls");
printf("\n\n\nTraitement en cours ...");
Sleep(1000);
system("cls");
if((fichier0=fopen("Rapport.txt","w"))==NULL) //Ouverture du fichier Rapport.txt chargé de décrire de facon détaillée toutes les opérations ayant eu lieu jusque à la fin.
{
printf("\n\n\nErreur d\'ouverture du fichier \"Rapport.txt\"");
Sleep(5000);
exit(0);
}
if((handle2=open("Rapport.txt",O_RDONLY|O_BINARY))<0) //Ouverture d'un descripteur sur le fichier Rapport.txt permettant de connaitre la taille de ce fichier à tout moment.
{
printf("\n\nErreur d\'ouverture du fichier Rapport.txt");
Sleep(5000);
exit(0);
}
if((fichier1=fopen("Liste_fichiers_supprimes.txt","w+"))==NULL) //Ouverture du fichier chargé de contenir la liste des fichiers supprimés après analyse.
{
printf("\n\n\nErreur d\'ouverture du fichier \"Liste_fichiers_supprimes.txt\"");
Sleep(5000);
exit(0);
}
/*
Le procédé de détection des doublons passe par les étapes que voici:
1-La récupération de chacun des chemins contenus dans le fichier contenant la liste des chemins après décomposition.
2-L'ouverture de chacun des fichiers en mode binaire.
3-Lorsqu'on est sur un chemin donné de la liste, on compare l'extension du fichier auquel il correspond à l'extension de
chacun des fichiers correspondants aux autres chemins situés après lui dans la liste et ce jusqu'au dernier chemin.
4-Lorsque deux fichiers ont la même extension, on compare leur taille.Sinon, on passe au chemin de fichier suivant.
5-Lorsque deux fichiers ont la même taille, on compare leur contenu binaire.
6-Si les deux fichiers ont le même contenu binaire, on supprime le second fichier parce qu'il est un doublon du premier.
Dans le cas contraire, on passe au chemin de fichier suivant.
7-On réitère l'opération en descendant dans le fichier contenant la liste des chemins, le nombre de comparaisons
diminuant de 1 à chaque itération.On arrète finalement lorsqu'il ne reste qu'un seul fichier dans la liste car ce dernier
ne peut être comparé à lui même.
printf("\n**** DEBUT DU TRAITEMENT ****"); //Affichage au début du traitement.
fprintf(fichier0,"\n**** DEBUT DU TRAITEMENT ****"); //Ecrtiture de "DEBUT DU TRAITEMENT" dans le fichier Rapport.txt
fflush(fichier0);
time(&t_debut); //Mémorisation de l'état de l'horloge au début du traitement.
while(fgets(string0,1000,struct_fichier0.ptr_fichier)!=NULL) //Lecture des éléments contenus dans le fichier contenant les chemins après décomposition.
{
if(cpt1<cpt0) //Si le chemin sur lequel on est a déja été lu une fois alors on passe au suivant.
{
++cpt1;
continue;
}
++num_fichier_courant; //On incrémente la variable indiquant le nombre de chemins lus par le 1er pointeur dans le fichier contenant les chemins.
if((cpt1>=cpt0)&&(cpt0<struct_fichier0.nbre_elmts-1)) //Lorsqu'on est sur un élément non encore lu dans le fichier contenant les chemins et qu'on n'a pas encore atteint l'avant dernier élément du fichier
{
printf("\n\n\n\n°°°° Fichier %d sur %d ... °°°°\n",num_fichier_courant,struct_fichier0.nbre_elmts-1); //On affiche le numéro du fichier en train d'être comparé.
fprintf(fichier0,"\n\n\n\n°°°° Fichier %d sur %d ... °°°°\n",num_fichier_courant,struct_fichier0.nbre_elmts-1); //Et on l'écrit aussi dans le rapport.
fflush(fichier0);
}
while(fgets(string2,1000,struct_fichier0.ptr_fichier)!=NULL) //On commence par lire chacun des chemins situés après le chemin sur lequel le premier pointeur pointe.
{
memset(string3,'\0',1000); //Initialisation des chaines chargées de contenir les extensions des fichiers.
memset(string1,'\0',1000);
for(i=0;i<strlen(string0);++i)
{
if(string0[i]=='\n')
{
string0[i]='\0';
}
}
for(i=0;i<strlen(string2);++i) //On débarrasse les deux chemins du caractère '\n' avant ouverture des fichiers coorespondants avec la fonction opendir.
{
if(string2[i]=='\n')
{
string2[i]='\0';
}
}
if((handle0=open(string0,O_RDONLY|O_BINARY))<0) //Si la tentative d'ouverture du second chemin échoue, cela veut dire que le fichier correspondant a déjà été supprimé au cours d'un passage antérieur.
{
printf("\n%d %% effectu\202s ... (Comparaison de %s et de %s ... Action : Le fichier %s a d\202j\205 \202t\202 supprim\202 ...)",(num_fichier_courant*100/(struct_fichier0.nbre_elmts-1)),string0,string2,string0);
fprintf(fichier0,"\n%d %% effectués ... (Comparaison de %s et de %s ... Action : Le fichier %s a déjà été supprimé ...)",(num_fichier_courant*100/(struct_fichier0.nbre_elmts-1)),string0,string2,string0);
fflush(fichier0);
continue;
}
else
{
j=0;
for(i=strlen(string0)-1;i>=0;--i)
{
if(string0[i]!='.')
{
string1[j++]=string0[i]; //Récupération de l'extension du fichier correspondant au premier chemin dans la chaine string1.
}
else
{
string1[j]='\0';
break;
}
}
j=0;
for(i=strlen(string2)-1;i>=0;--i)
{
if(string2[i]!='.')
{
string3[j++]=string2[i]; //Récupération de l'extension du fichier correspondant au second chemin dans la chaine string3.
}
else
{
string3[j]='\0';
break;
}
}
if(strcmp(string3,string1)!=0) //Si les deux extensions sont différentes
{
printf("\n%d %% effectu\202s ... (Comparaison de %s et de %s ... Action : N\202ant ...)",(num_fichier_courant*100/(struct_fichier0.nbre_elmts-1)),string0,string2); //On affiche néant.
fprintf(fichier0,"\n%d %% effectués ... (Comparaison de %s et de %s ... Action : Néant ...)",(num_fichier_courant*100/(struct_fichier0.nbre_elmts-1)),string0,string2);
if((handle0>0)&&(close(handle0)==-1)) //on ferme le descripteur ouvert sur le premier fichier.
{
printf("\nErreur de fermeture du fichier %s ...",string0);
fprintf(fichier0,"\nErreur de fermeture du fichier %s ...",string0);
}
fflush(fichier0);
continue; //On reboucle pour récupérer le chemin suivant dans le fichier contenant les chemins après décomposition.
}
else //Si les deux fichiers ont la même extension
{
if((handle1=open(string2,O_RDONLY|O_BINARY))<0) //On ouvre un descripteur sur le second fichier.
{
printf("\n%d %% effectu\202s ... (Comparaison de %s et de %s ... Action : Le fichier %s a d\202j\205 \202t\202 supprim\202 ...)",(num_fichier_courant*100/(struct_fichier0.nbre_elmts-1)),string0,string2,string2);
fprintf(fichier0,"\n%d %% effectués ... (Comparaison de %s et de %s ... Action : Le fichier %s a déjà été supprimé ...)",(num_fichier_courant*100/(struct_fichier0.nbre_elmts-1)),string0,string2,string2);
if((handle0>0)&&(close(handle0)==-1))
{
printf("\nErreur de fermeture du fichier %s ...",string0);
fprintf(fichier0,"\nErreur de fermeture du fichier %s ...",string0);
}
fflush(fichier0);
continue; //Si l'ouverture échoue, on le notifie et on reboucle pour récupérer le chemin suivant dans le fichier contenant les chemins après décomposition.
}
else //Si l'ouverture du descripteur réussie, on compare la taille des deux fichiers.
{
if(filelength(handle0)!=filelength(handle1)) //Si les deux fichiers sont de taille différente
{
printf("\n%d %% effectu\202s ... (Comparaison de %s et de %s ... Action : N\202ant ...)",(num_fichier_courant*100/(struct_fichier0.nbre_elmts-1)),string0,string2);
fprintf(fichier0,"\n%d %% effectués ... (Comparaison de %s et de %s ... Action : Néant ...)",(num_fichier_courant*100/(struct_fichier0.nbre_elmts-1)),string0,string2);
if((handle0>0)&&(close(handle0)==-1))
{
printf("\nErreur de fermeture du fichier %s ...",string0);
fprintf(fichier0,"\nErreur de fermeture du fichier %s ...",string0); //On ferme les descripteurs ouverts sur chacun des deux fichiers après l'avoir notifié dans un message.
}
if((handle1>0)&&(close(handle1)==-1))
{
printf("\nErreur de fermeture du fichier %s ...",string2);
fprintf(fichier0,"\nErreur de fermeture du fichier %s ...",string2);
}
fflush(fichier0);
continue; //On reboucle pour passer au fichier suivant.
}
else //Si les deux fichiers sont de même taille
{
var_test=0; //On initialise une variable à 0. Cette variable est égale à 0 si les deux fichiers sont identiques et égale à 1 dans le cas contraire.
if(filelength(handle0)==0) //Si les deux fichiers sont vides, on commande la suppression de l'un d'eux en mettant la variable var_test à 0.
{
var_test=0;
}
else //Si les deux fichiers ne sont pas vide
{
do
{
nbre_lus0=read(handle0,(unsigned char*)buffer0,taillebloc); //On récupère un bloc du premier fichier
nbre_lus1=read(handle1,(unsigned char*)buffer1,taillebloc); //Et un bloc du second dans un tableau de 1024 cases, chaque case occupant un octet.
if(nbre_lus0!=nbre_lus1) //Si les nombres récupérés sont différents, dans le cas ou l'un ou les deux fichiers auraient une taille inférieure à 1024 octets
{
var_test=1; //On met la variable var_test à 1 pour signifier que les deux fichiers sont différents.
break; //On sort de la boucle.
}
for(i=0;i<taillebloc;++i) //Si les nombres récupérés sont identiques, on parcoure chacune des cases des deux tableaux.
{
if(buffer0[i]==buffer1[i]) //Si deux cases correspondantes contiennent la même valeur
{
continue; //On continue la comparaison.
}
else
{
var_test=1; //Si deux cases correspondantes contiennent des valeurs différentes, on met la variable var_test à 1 et on sort de la boucle.
break;
}
}
}
while((nbre_lus0==taillebloc)&&(nbre_lus1==taillebloc)&&(var_test!=1)); //La boucle ne se rompt que si var_test est égal à 1 ou si on a atteint la fin de l'un des deux fichiers.
}
if(var_test==0) //Si les deux fichiers sont identiques
{
if((handle0>0)&&(close(handle0)==-1))
{
printf("\nErreur de fermeture du fichier %s ...",string0);
fprintf(fichier0,"\nErreur de fermeture du fichier %s ...",string0);
fflush(fichier0);
}
if((handle1>0)&&(close(handle1)==-1)) //On ferme tous les descripteurs de fichiers ouverts.
{
printf("\nErreur de fermeture du fichier %s ...",string2);
fprintf(fichier0,"\nErreur de fermeture du fichier %s ...",string2);
fflush(fichier0);
}
printf("\n%d %% effectu\202s ... (Comparaison de %s et de %s ... Action : Suppression du doublon %s ...)",(num_fichier_courant*100/(struct_fichier0.nbre_elmts-1)),string0,string2,string2);
fprintf(fichier0,"\n%d %% effectués ... (Comparaison de %s et de %s ... Action : Suppression du doublon %s ...)",(num_fichier_courant*100/(struct_fichier0.nbre_elmts-1)),string0,string2,string2);
fflush(fichier0);
unlink(string2); //On supprime l'un des fichiers, en l'occurence le second.
++nbre_fichiers_suppr; //On incrémente la variable chargée de contenir le nombre de fichiers supprimés.
fprintf(fichier1,"%d - %s ----> %s \n",nbre_fichiers_suppr,string2,string0); //On indique que le fichier a été supprimé et le fichier dont il est le doublon.
fflush(fichier1);
}
else //Si var_test est égal à 1
{
printf("\n%d %% effectu\202s ... (Comparaison de %s et de %s ... Action : N\202ant ...)",(num_fichier_courant*100/(struct_fichier0.nbre_elmts-1)),string0,string2);
fprintf(fichier0,"\n%d %% effectués ... (Comparaison de %s et de %s ... Action : Néant ...)",(num_fichier_courant*100/(struct_fichier0.nbre_elmts-1)),string0,string2);
fflush(fichier0);
if((handle0>0)&&(close(handle0)==-1))
{
printf("\nErreur de fermeture du fichier %s ...",string0);
fprintf(fichier0,"\nErreur de fermeture du fichier %s ...",string0);
fflush(fichier0);
} //On ferme tous les descripteurs ouverts sur chacun des fichiers.
if((handle1>0)&&(close(handle1)==-1))
{
printf("\nErreur de fermeture du fichier %s ...",string2);
fprintf(fichier0,"\nErreur de fermeture du fichier %s ...",string2);
fflush(fichier0);
}
}
}
}
}
}
}
rewind(struct_fichier0.ptr_fichier); //On ramène le curseur au début du fichier contenant les chemins de fichiers après décomposition.
cpt1=0; //Réinitialisation de cpt1.
++cpt0; //Incrémentation de cpt0 qui indique le nombre de fichiers déja traités.
if(filelength(handle2)>600*1024*1024) //Si la taille du rapport dépasse 600 Mo
{
fclose(fichier0); //On ferme tous les descripteurs ouverts sur lui.
close(handle2);
fichier0=NULL; //On réinitialise le pointeur qui pointe sur lui.
unlink("Rapport.txt"); //On le détruit.
}
}
fclose(struct_fichier0.ptr_fichier); //On ferme le fichier qui contient les chemins après décomposition.
unlink(struct_fichier0.filename); //Après on le supprime.
printf("\n\n\n\n**** FIN DU TRAITEMENT ****");
if(fichier0!=NULL)
{
fprintf(fichier0,"\n\n\n\n**** FIN DU TRAITEMENT ****"); //On indique la fin du traitement.
fflush(fichier0);
}
printf("\n\n\n°°°° %d fichier(s) supprim\202(s) sur %d test(s) effectu\202(s). °°°°",nbre_fichiers_suppr,(struct_fichier0.nbre_elmts*(struct_fichier0.nbre_elmts-1))/2);
if(fichier0!=NULL)
{ //On indique le nombre de fichiers supprimés sur le nombre de tests effectués si le rapport n'a pas été supprimé..
fprintf(fichier0,"\n\n\n°°°° %d fichier(s) supprimé(s) sur %d test(s) effectué(s). °°°°",nbre_fichiers_suppr,(struct_fichier0.nbre_elmts*(struct_fichier0.nbre_elmts-1))/2);
fflush(fichier0);
}
else //Si le rapport a déjà été supprimé, on indique le nombre de fichiers supprimés dans le fichier contenant la liste des fichiers supprimés.
{
fprintf(fichier1,"\n\n\n°°°° %d fichier(s) supprimé(s) sur %d test(s) effectué(s). °°°°",nbre_fichiers_suppr,(struct_fichier0.nbre_elmts*(struct_fichier0.nbre_elmts-1))/2);
fflush(fichier1);
}
time(&t_fin); //On mémorise l'état de l'horloge à la fin du traitement.
struct_duree0=conv_jr_hr_min_sec((long)(difftime(t_fin,t_debut))+(long)struct_fichier0.duree_decomposition); //Conversion de la durée d'exécution du traitement avec la fonction conv_jr_hr_min_sec.
printf("\n\n\n##### Dur\202e du traitement: %d jour(s) - %d heure(s) - %d minute(s) - %d seconde(s) #####\n\n",struct_duree0.nbre_jour,struct_duree0.nbre_heure,struct_duree0.nbre_minute,struct_duree0.nbre_seconde);
if(fichier0!=NULL)
{
fprintf(fichier0,"\n\n\n##### Durée du traitement: %d jour(s) - %d heure(s) - %d minute(s) - %d seconde(s) #####\n\n",struct_duree0.nbre_jour,struct_duree0.nbre_heure,struct_duree0.nbre_minute,struct_duree0.nbre_seconde);
fflush(fichier0);
fclose(fichier0);
}
else
{
fprintf(fichier1,"\n\n\n##### Durée du traitement: %d jour(s) - %d heure(s) - %d minute(s) - %d seconde(s) #####\n\n",struct_duree0.nbre_jour,struct_duree0.nbre_heure,struct_duree0.nbre_minute,struct_duree0.nbre_seconde);
fflush(fichier1);
}
fclose(fichier1);
son(); //Déclenchement du signal indiquant la fin du traitement.
if(fichier0!=NULL)
{
system("Rapport.txt"); //Ouverture du rapport s'il n'a pas été supprimé.
}
if(nbre_fichiers_suppr>0)
{
system("Liste_fichiers_supprimes.txt");
}
else
{
unlink("Liste_fichiers_supprimes.txt"); //Ouverture du fichier contenant la liste des fichiers supprimés.
}
exit(0); //Fermeture du programme.
getch();
return 0;
}
Conclusion :
Ce programme sera d'une grande utilité pour ceux qui ne n'ont pas le temps de rechercher et de supprimer manuellement les redondances de fichiers.Ceci n'est d'ailleurs pas chose facile.
Vous n'êtes pas encore membre ?
inscrivez-vous, c'est gratuit et ça prend moins d'une minute !
Les membres obtiennent plus de réponses que les utilisateurs anonymes.
Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.
Le fait d'être membre vous permet d'avoir des options supplémentaires.