CodeS-SourceS est hébergé par Frontier.fr

Ce site au démarrage

begin process at 2012 05 27 13:33:16

Accueil Codes Tutoriels Forum Livres Emploi Services Connexion

Trouver un code source :

dans

[ Dernières recherches ]

Accueil >

ANALYSEUR DE TEXTE (MAJ V2)

Information sur la source

Note :
Aucune note

Catégorie :Fichiers / Disque Classé sous :analyseur, fichier, texte, grammaire, syntaxe Niveau :Débutant Date de création :23/09/2010 Date de mise à jour :27/09/2010 14:56:36 Vu / téléchargé :3 214 / 117

Auteur : sholvaC

Ecrire un message privé

Commentaire sur cette source (18)

Ajouter un commentaire et/ou une note

Description

Bonjour,

Suite aux commentaires, j'ai donc modifié la source en suivant vos conseils, enfin je crois. Grande constatation, le temps d'exécution est en effet réduit. J'ai pris un fichier de 40Mo pour le test. Avec la version 1, il a fallu 199s contre 30s pour la version 2. Soit environ un temps d'exécution 6.6 fois plus rapide !

La fonction prend en paramètres le chemin du fichier à analyser ainsi que le chemin du fichier où sera enregistré le résultat de l'analyse. Si quelqu'un veut pouvoir récupérer les tableaux pour effectuer d'autres traitements qu'enregistrer le résultat dans un fichier, il faudra qu'il aille voir directement le contenu de la fonction.

J'ai mis du code dans le .h bien que je sache que cela ne soit pas la norme. J'aurais fais autrement si je savais comment lié un .c à .h pour que lorsque l'on appelle le .h il n'y ait pas d'erreur. Sans ça, si je ne mets que les prototypes de fonctions, à l'appel du .h, ça ne marche évidement pas.

J'ai également modifié la forme du fichier de résultat qui se présente désormais ainsi ( résultat pour le fichier de 40Mo en question ) qui est mal représenté dans cet éditeur. Sous notepad par exemple, le résultat est correctement indenté.

+---------------------+------------+--- ---------+------------+
| ASCIIE DECIMAL CODE | OCCURENCES | PERCENTAGE | CHARACTER  |
+---------------------+------------+------------ +------------+
|          35         |        651 |       0.00 | #          |
+---------------------+------------+------------ +------------+
|          70         |        651 |       0.00 | F          |
+---------------------+------------+------------ +------------+
|          73         |        651 |       0.00 | I          |
+---------------------+------------+------------ +------------+
|          78         |        651 |       0.00 | N          |
+---------------------+------------+------------ +------------+
|          10         |     382535 |       0.80 | LF         |
+---------------------+------------+------------ +------------+
|         104         |     382535 |       0.80 | h          |
+---------------------+------------+------------ +------------+
|          47         |     382536 |       0.80 | /          |
+---------------------+------------+------------ +------------+
|          84         |     382536 |       0.80 | T          |
+---------------------+------------+------------ +------------+
|         106         |     382536 |       0.80 | j          |
+---------------------+------------+------------ +------------+
|         112         |     382536 |       0.80 | p          |
+---------------------+------------+------------ +------------+
|          55         |     444445 |       0.93 | 7          |
+---------------------+------------+------------ +------------+
|          56         |     453353 |       0.95 | 8          |
+---------------------+------------+------------ +------------+
|          54         |     469414 |       0.98 | 6          |
+---------------------+------------+------------ +------------+
|          52         |     601385 |       1.26 | 4          |
+---------------------+------------+------------ +------------+
|          51         |     601697 |       1.26 | 3          |
+---------------------+------------+------------ +------------+
|          57         |     647652 |       1.35 | 9          |
+---------------------+------------+------------ +------------+
|          50         |     647687 |       1.35 | 2          |
+---------------------+------------+------------ +------------+
|         100         |     765071 |       1.60 | d          |
+---------------------+------------+------------ +------------+
|         105         |     765071 |       1.60 | i          |
+---------------------+------------+------------ +------------+
|         111         |     765071 |       1.60 | o          |
+---------------------+------------+------------ +------------+
|          58         |     765072 |       1.60 | :          |
+---------------------+------------+------------ +------------+
|          97         |     765072 |       1.60 | a          |
+---------------------+------------+------------ +------------+
|         108         |     765072 |       1.60 | l          |
+---------------------+------------+------------ +------------+
|          53         |     847655 |       1.77 | 5          |
+---------------------+------------+------------ +------------+
|         110         |    1147606 |       2.40 | n          |
+---------------------+------------+------------ +------------+
|          99         |    1147607 |       2.40 | c          |
+---------------------+------------+------------ +------------+
|         109         |    1147607 |       2.40 | m          |
+---------------------+------------+------------ +------------+
|         114         |    1147607 |       2.40 | r          |
+---------------------+------------+------------ +------------+
|         124         |    1147607 |       2.40 | |          |
+---------------------+------------+------------ +------------+
|         117         |    1530142 |       3.20 | u          |
+---------------------+------------+------------ +------------+
|         116         |    1530143 |       3.20 | t          |
+---------------------+------------+------------ +------------+
|          49         |    1826066 |       3.82 | 1          |
+---------------------+------------+------------ +------------+
|          46         |    1912677 |       4.00 | .          |
+---------------------+------------+------------ +------------+
|         115         |    3060284 |       6.40 | s          |
+---------------------+------------+------------ +------------+
|         101         |    3442819 |       7.20 | e          |
+---------------------+------------+------------ +------------+
|          32         |    6885641 |      14.40 | SPACE      |
+---------------------+------------+------------ +------------+
|          48         |   10294027 |      21.53 | 0          |
+---------------------+------------+------------ +------------+

Source

MAIN
#include "analyseurDeFichiers v2.h"
int main()
{
getFileAnalysis( "document.txt", "results.txt" );
}
HEADER
#include <stdio.h>
#include <stdlib.h>
#include <limits.h>
#include <math.h>
/* Fonctions d'allocations */
int *allocateIntPtr ( int wordSize )
{
int *ptr = (int*)malloc(wordSize*sizeof(int));
if ( ptr != NULL )
{
return ptr;
}
else perror("\n ERROR in allocateIntPtr ");
}
char *allocateCharPtr ( int wordSize )
{
char *ptr = (char*)malloc(wordSize*sizeof(char));
if ( ptr != NULL )
{
return ptr;
}
else perror("\n ERROR in allocateCharPtr ");
}
float *allocateFloatPtr ( int wordSize )
{
float *ptr = (float*)malloc(wordSize*sizeof(float));
if ( ptr != NULL )
{
return ptr;
}
else perror("\n ERROR in allocateFloatPtr ");
}
/* Opérations sur les tableaux */
void initializeIntTable ( int *table, int tableLength, int constant )
{
if ( table != NULL )
{
int i;
for ( i=0 ; i<tableLength ; i++ )
{
table[i] = constant;
}
}
else perror("\n ERROR in initializeIntTable ");
}
void displayString ( char *table, int *tableLength )
{
if ( table != NULL && tableLength != NULL )
{
int i;
for ( i=0 ; i< *tableLength ; i++ )
{
printf("%c", table[i]);
}
}
else perror("\n ERROR in displayTable ");
}
void displayIntTable ( int *table, int *tableLength )
{
if ( table != NULL && tableLength != NULL )
{
int i;
for ( i=0 ; i< *tableLength ; i++ )
{
printf("\ntable[%03i] = %d", i, table[i]);
}
}
else perror("\n ERROR in displayIntTable ");
}
/* Opérations sur les fichiers */
int getCharFilesNumbers ( char *filePath )
{
FILE *file = fopen( filePath,"r");
if( file != NULL )
{
int counter = 0;
char c;
while( fscanf( file,"%c",&c ) != EOF )
{
if ( counter < INT_MAX )
{
counter++;
}
else perror("\n ERROR in getCharFilesNumber 2 ");
}
return counter;
}
else perror("\n ERROR in getCharFilesNumber 1 ");
fclose(file);
}
char *fileToString ( char *filePath, int *bufferLength )
{
FILE *file = fopen( filePath,"r" );
if( file != NULL && bufferLength != NULL)
{
*bufferLength = getCharFilesNumbers( filePath );
//printf("\n\n--length %d\n\n", *bufferLength);
char *buffer = allocateCharPtr( *bufferLength );
char c;
int offset = 0;
while( fscanf( file,"%c",&c ) != EOF )
{
buffer[offset] = c;
offset++;
}
return buffer;
}
else perror("\n ERROR in fileToString ");
fclose(file);
}
/* Fonctions pour l'analyses */
void triBulle ( int *table , int tableLength , char *ASCIIE_String )
{
if ( table != NULL )
{
int i,j,temp;
char tempC;
for( i=tableLength-1 ; i>0 ; i-- )
{
for( j=1 ; j<=i ; j++ )
{
if( table[j-1]>table[j] )
{
temp = table[j-1];
table[j-1] = table[j];
table[j] = temp;
tempC = ASCIIE_String[j-1];
ASCIIE_String[j-1] = ASCIIE_String[j];
ASCIIE_String[j] = tempC;
}
}
}
}
else perror("\n ERROR in tribulle ");
}
void displayIntResults ( int *table )
{
if ( table != NULL )
{
char ASCIIE_String[256]={'\0','\1','\2','\3','\4','\5','\6','\7','\10','\11','\12','\13','\14','\15','\16','\17','\20','\21','\22','\23','\24','\25','\26','\27','\30','\31','\32','\33','\34','\35','\36','\37','\40','\41','\42','\43','\44','\45','\46','\47','\50','\51','\52','\53','\54','\55','\56','\57','\60','\61','\62','\63','\64','\65','\66','\67','\70','\71','\72','\73','\74','\75','\76','\77','\100','\101','\102','\103','\104','\105','\106','\107','\110','\111','\112','\113','\114','\115','\116','\117','\120','\121','\122','\123','\124','\125','\126','\127','\130','\131','\132','\133','\134','\135','\136','\137','\140','\141','\142','\143','\144','\145','\146','\147','\150','\151','\152','\153','\154','\155','\156','\157','\160','\161','\162','\163','\164','\165','\166','\167','\170','\171','\172','\173','\174','\175','\176','\177','\200','\201','\202','\203','\204','\205','\206','\207','\210','\211','\212','\213','\214','\215','\216','\217','\220','\221','\222','\223','\224','\225','\226','\227','\230','\231','\232','\233','\234','\235','\236','\237','\240','\241','\242','\243','\244','\245','\246','\247','\250','\251','\252','\253','\254','\255','\256','\257','\260','\261','\262','\263','\264','\265','\266','\267','\270','\271','\272','\273','\274','\275','\276','\277','\300','\301','\302','\303','\304','\305','\306','\307','\310','\311','\312','\313','\314','\315','\316','\317','\320','\321','\322','\323','\324','\325','\326','\327','\330','\331','\332','\333','\334','\335','\336','\337','\340','\341','\342','\343','\344','\345','\346','\347','\350','\351','\352','\353','\354','\355','\356','\357','\360','\361','\362','\363','\364','\365','\366','\367','\370','\371','\372','\373','\374','\375','\376','\377'};
int i=0;
for ( i=0 ; i<256 ; i++ )
{
if ( table[i]>0 )
{
printf("\n %c : %09i occurences", ASCIIE_String[i], table[i]);
}
}
}
else perror("\n displayResults ");
}
void displayFloatResults( float *table )
{
if ( table != NULL )
{
char ASCIIE_String[256]={'\0','\1','\2','\3','\4','\5','\6','\7','\10','\11','\12','\13','\14','\15','\16','\17','\20','\21','\22','\23','\24','\25','\26','\27','\30','\31','\32','\33','\34','\35','\36','\37','\40','\41','\42','\43','\44','\45','\46','\47','\50','\51','\52','\53','\54','\55','\56','\57','\60','\61','\62','\63','\64','\65','\66','\67','\70','\71','\72','\73','\74','\75','\76','\77','\100','\101','\102','\103','\104','\105','\106','\107','\110','\111','\112','\113','\114','\115','\116','\117','\120','\121','\122','\123','\124','\125','\126','\127','\130','\131','\132','\133','\134','\135','\136','\137','\140','\141','\142','\143','\144','\145','\146','\147','\150','\151','\152','\153','\154','\155','\156','\157','\160','\161','\162','\163','\164','\165','\166','\167','\170','\171','\172','\173','\174','\175','\176','\177','\200','\201','\202','\203','\204','\205','\206','\207','\210','\211','\212','\213','\214','\215','\216','\217','\220','\221','\222','\223','\224','\225','\226','\227','\230','\231','\232','\233','\234','\235','\236','\237','\240','\241','\242','\243','\244','\245','\246','\247','\250','\251','\252','\253','\254','\255','\256','\257','\260','\261','\262','\263','\264','\265','\266','\267','\270','\271','\272','\273','\274','\275','\276','\277','\300','\301','\302','\303','\304','\305','\306','\307','\310','\311','\312','\313','\314','\315','\316','\317','\320','\321','\322','\323','\324','\325','\326','\327','\330','\331','\332','\333','\334','\335','\336','\337','\340','\341','\342','\343','\344','\345','\346','\347','\350','\351','\352','\353','\354','\355','\356','\357','\360','\361','\362','\363','\364','\365','\366','\367','\370','\371','\372','\373','\374','\375','\376','\377'};
int i=0;
for ( i=0 ; i<256 ; i++ )
{
if ( table[i]>0 )
{
printf("\n %c : %.01f %%", ASCIIE_String[i], table[i]);
}
}
}
else perror("\n displayResults ");
}
float *toPercentage ( int *intTable, int intTableLenght, int numberOfElements )
{
if ( intTable != NULL )
{
float *floatTable = allocateFloatPtr(intTableLenght);
int i;
for ( i=0 ; i<intTableLenght ; i++ )
{
floatTable[i]=(float)(100.*intTable[i]/numberOfElements);
}
return floatTable;
}
else perror("\n ERROR in toPercentage ");
}
int *analyseFile ( char *filePath )
{
if ( filePath != NULL )
{
int *fileToAnalizeLength = allocateIntPtr(1);
char *fileToAnalize = fileToString( filePath, fileToAnalizeLength );
//displayString( fileToAnalize, *fileToAnalizeLength );
int *index = allocateIntPtr(256);
initializeIntTable( index, 256, 0 );
int currentChar;
int i;
for ( i=0 ; i<*fileToAnalizeLength ; i++ )
{
int asciiCode = (int)(fileToAnalize[i]);
if ( asciiCode < 0 )
{
*(index + asciiCode +256 ) = *(index + asciiCode) + 1;
}
else *(index + asciiCode) = *(index + asciiCode) + 1;
}
free(fileToAnalizeLength);
return index;
}
else perror("\n analyseFile ");
}
void saveResults ( char *filePath, float *floatTable , int *intTable , char *ASCIIE_String )
{
FILE *file=fopen(filePath,"w");
if( file != NULL && filePath != NULL && floatTable != NULL && intTable != NULL )
{
fprintf(file, "\n+---------------------+------------+------------+------------+");
fprintf(file, "\n| ASCIIE DECIMAL CODE | OCCURENCES | PERCENTAGE | CHARACTER |");
fprintf(file, "\n+---------------------+------------+------------+------------+");
int i=0;
for ( i=0 ; i<256 ; i++ )
{
if ( intTable[i] > 0 )
{
if ( 32 < (int)ASCIIE_String[i] && (int)ASCIIE_String[i] <= 127 )
{
fprintf(file, "\n| %3i | %10i | %10.2f | %c |", (int)ASCIIE_String[i], intTable[i], floatTable[i], ASCIIE_String[i]);
fprintf(file, "\n+---------------------+------------+------------+------------+");
}
else if ( -128 <= (int)ASCIIE_String[i] && (int)ASCIIE_String[i] <= -1 )
{
fprintf(file, "\n| %3i | %10i | %10.2f | %c |", (int)ASCIIE_String[i]+256, intTable[i], floatTable[i], ASCIIE_String[i]);
fprintf(file, "\n+---------------------+------------+------------+------------+");
}
else
{
switch( (int)ASCIIE_String[i] )
{
case 0 : {
fprintf(file, "\n| %3i | %10i | %10.2f | NUL |", (int)ASCIIE_String[i], intTable[i], floatTable[i]);
fprintf(file, "\n+---------------------+------------+------------+------------+");
break;
}
case 1 : {
fprintf(file, "\n| %3i | %10i | %10.2f | SOH |", (int)ASCIIE_String[i], intTable[i], floatTable[i]);
fprintf(file, "\n+---------------------+------------+------------+------------+");
break;
}
case 2 : {
fprintf(file, "\n| %3i | %10i | %10.2f | STX |", (int)ASCIIE_String[i], intTable[i], floatTable[i]);
fprintf(file, "\n+---------------------+------------+------------+------------+");
break;
}
case 3 : {
fprintf(file, "\n| %3i | %10i | %10.2f | ETX |", (int)ASCIIE_String[i], intTable[i], floatTable[i]);
fprintf(file, "\n+---------------------+------------+------------+------------+");
break;
}
case 4 : {
fprintf(file, "\n| %3i | %10i | %10.2f | EOT |", (int)ASCIIE_String[i], intTable[i], floatTable[i]);
fprintf(file, "\n+---------------------+------------+------------+------------+");
break;
}
case 5 : {
fprintf(file, "\n| %3i | %10i | %10.2f | ENQ |", (int)ASCIIE_String[i], intTable[i], floatTable[i]);
fprintf(file, "\n+---------------------+------------+------------+------------+");
break;
}
case 6 : {
fprintf(file, "\n| %3i | %10i | %10.2f | ACK |", (int)ASCIIE_String[i], intTable[i], floatTable[i]);
fprintf(file, "\n+---------------------+------------+------------+------------+");
break;
}
case 7 : {
fprintf(file, "\n| %3i | %10i | %10.2f | BEL |", (int)ASCIIE_String[i], intTable[i], floatTable[i]);
fprintf(file, "\n+---------------------+------------+------------+------------+");
break;
}
case 8 : {
fprintf(file, "\n| %3i | %10i | %10.2f | BS |", (int)ASCIIE_String[i], intTable[i], floatTable[i]);
fprintf(file, "\n+---------------------+------------+------------+------------+");
break;
}
case 9 : {
fprintf(file, "\n| %3i | %10i | %10.2f | HT |", (int)ASCIIE_String[i], intTable[i], floatTable[i]);
fprintf(file, "\n+---------------------+------------+------------+------------+");
break;
}
case 10 : {
fprintf(file, "\n| %3i | %10i | %10.2f | LF |", (int)ASCIIE_String[i], intTable[i], floatTable[i]);
fprintf(file, "\n+---------------------+------------+------------+------------+");
break;
}
case 11 : {
fprintf(file, "\n| %3i | %10i | %10.2f | VT |", (int)ASCIIE_String[i], intTable[i], floatTable[i]);
fprintf(file, "\n+---------------------+------------+------------+------------+");
break;
}
case 12 : {
fprintf(file, "\n| %3i | %10i | %10.2f | FF |", (int)ASCIIE_String[i], intTable[i], floatTable[i]);
fprintf(file, "\n+---------------------+------------+------------+------------+");
break;
}
case 13 : {
fprintf(file, "\n| %3i | %10i | %10.2f | CR |", (int)ASCIIE_String[i], intTable[i], floatTable[i]);
fprintf(file, "\n+---------------------+------------+------------+------------+");
break;
}
case 14 : {
fprintf(file, "\n| %3i | %10i | %10.2f | SO |", (int)ASCIIE_String[i], intTable[i], floatTable[i]);
fprintf(file, "\n+---------------------+------------+------------+------------+");
break;
}
case 15 : {
fprintf(file, "\n| %3i | %10i | %10.2f | SI |", (int)ASCIIE_String[i], intTable[i], floatTable[i]);
fprintf(file, "\n+---------------------+------------+------------+------------+");
break;
}
case 16 : {
fprintf(file, "\n| %3i | %10i | %10.2f | DLE |", (int)ASCIIE_String[i], intTable[i], floatTable[i]);
fprintf(file, "\n+---------------------+------------+------------+------------+");
break;
}
case 17 : {
fprintf(file, "\n| %3i | %10i | %10.2f | DC1 |", (int)ASCIIE_String[i], intTable[i], floatTable[i]);
fprintf(file, "\n+---------------------+------------+------------+------------+");
break;
}
case 18 : {
fprintf(file, "\n| %3i | %10i | %10.2f | DC2 |", (int)ASCIIE_String[i], intTable[i], floatTable[i]);
fprintf(file, "\n+---------------------+------------+------------+------------+");
break;
}
case 19 : {
fprintf(file, "\n| %3i | %10i | %10.2f | DC3 |", (int)ASCIIE_String[i], intTable[i], floatTable[i]);
fprintf(file, "\n+---------------------+------------+------------+------------+");
break;
}
case 20 : {
fprintf(file, "\n| %3i | %10i | %10.2f | DC4 |", (int)ASCIIE_String[i], intTable[i], floatTable[i]);
fprintf(file, "\n+---------------------+------------+------------+------------+");
break;
}
case 21 : {
fprintf(file, "\n| %3i | %10i | %10.2f | NAK |", (int)ASCIIE_String[i], intTable[i], floatTable[i]);
fprintf(file, "\n+---------------------+------------+------------+------------+");
break;
}
case 22 : {
fprintf(file, "\n| %3i | %10i | %10.2f | SYN |", (int)ASCIIE_String[i], intTable[i], floatTable[i]);
fprintf(file, "\n+---------------------+------------+------------+------------+");
break;
}
case 23 : {
fprintf(file, "\n| %3i | %10i | %10.2f | ETB |", (int)ASCIIE_String[i], intTable[i], floatTable[i]);
fprintf(file, "\n+---------------------+------------+------------+------------+");
break;
}
case 24 : {
fprintf(file, "\n| %3i | %10i | %10.2f | CAN |", (int)ASCIIE_String[i], intTable[i], floatTable[i]);
fprintf(file, "\n+---------------------+------------+------------+------------+");
break;
}
case 26 : {
fprintf(file, "\n| %3i | %10i | %10.2f | EM |", (int)ASCIIE_String[i], intTable[i], floatTable[i]);
fprintf(file, "\n+---------------------+------------+------------+------------+");
break;
}
case 27 : {
fprintf(file, "\n| %3i | %10i | %10.2f | SUB |", (int)ASCIIE_String[i], intTable[i], floatTable[i]);
fprintf(file, "\n+---------------------+------------+------------+------------+");
break;
}
case 28 : {
fprintf(file, "\n| %3i | %10i | %10.2f | ESC |", (int)ASCIIE_String[i], intTable[i], floatTable[i]);
fprintf(file, "\n+---------------------+------------+------------+------------+");
break;
}
case 29 : {
fprintf(file, "\n| %3i | %10i | %10.2f | FS |", (int)ASCIIE_String[i], intTable[i], floatTable[i]);
fprintf(file, "\n+---------------------+------------+------------+------------+");
break;
}
case 30 : {
fprintf(file, "\n| %3i | %10i | %10.2f | GS |", (int)ASCIIE_String[i], intTable[i], floatTable[i]);
fprintf(file, "\n+---------------------+------------+------------+------------+");
break;
}
case 31 : {
fprintf(file, "\n| %3i | %10i | %10.2f | RS |", (int)ASCIIE_String[i], intTable[i], floatTable[i]);
fprintf(file, "\n+---------------------+------------+------------+------------+");
break;
}
case 32 : {
fprintf(file, "\n| %3i | %10i | %10.2f | SPACE |", (int)ASCIIE_String[i], intTable[i], floatTable[i]);
fprintf(file, "\n+---------------------+------------+------------+------------+");
break;
}
}
}
}
}
}
fclose(file);
//system("notepad results.txt");
}
void getFileAnalysis ( char *input , char *output )
{
int *fileAnalized = analyseFile(input);
char ASCIIE_String[256]={'\0','\1','\2','\3','\4','\5','\6','\7','\10','\11','\12','\13','\14','\15','\16','\17','\20','\21','\22','\23','\24','\25','\26','\27','\30','\31','\32','\33','\34','\35','\36','\37','\40','\41','\42','\43','\44','\45','\46','\47','\50','\51','\52','\53','\54','\55','\56','\57','\60','\61','\62','\63','\64','\65','\66','\67','\70','\71','\72','\73','\74','\75','\76','\77','\100','\101','\102','\103','\104','\105','\106','\107','\110','\111','\112','\113','\114','\115','\116','\117','\120','\121','\122','\123','\124','\125','\126','\127','\130','\131','\132','\133','\134','\135','\136','\137','\140','\141','\142','\143','\144','\145','\146','\147','\150','\151','\152','\153','\154','\155','\156','\157','\160','\161','\162','\163','\164','\165','\166','\167','\170','\171','\172','\173','\174','\175','\176','\177','\200','\201','\202','\203','\204','\205','\206','\207','\210','\211','\212','\213','\214','\215','\216','\217','\220','\221','\222','\223','\224','\225','\226','\227','\230','\231','\232','\233','\234','\235','\236','\237','\240','\241','\242','\243','\244','\245','\246','\247','\250','\251','\252','\253','\254','\255','\256','\257','\260','\261','\262','\263','\264','\265','\266','\267','\270','\271','\272','\273','\274','\275','\276','\277','\300','\301','\302','\303','\304','\305','\306','\307','\310','\311','\312','\313','\314','\315','\316','\317','\320','\321','\322','\323','\324','\325','\326','\327','\330','\331','\332','\333','\334','\335','\336','\337','\340','\341','\342','\343','\344','\345','\346','\347','\350','\351','\352','\353','\354','\355','\356','\357','\360','\361','\362','\363','\364','\365','\366','\367','\370','\371','\372','\373','\374','\375','\376','\377'};
triBulle( fileAnalized, 256, ASCIIE_String );
float *fileAnalizedInPercentage = toPercentage( fileAnalized, 256, getCharFilesNumbers(input) );
saveResults( output, fileAnalizedInPercentage, fileAnalized, ASCIIE_String );
free(fileAnalized);
free(fileAnalizedInPercentage);
return 0;
}

MAIN

#include "analyseurDeFichiers v2.h"

int main()
{
    getFileAnalysis( "document.txt", "results.txt" );
}


HEADER 

#include <stdio.h>
#include <stdlib.h>
#include <limits.h>
#include <math.h>

/* Fonctions d'allocations */

int   *allocateIntPtr   ( int wordSize )
{
    int *ptr = (int*)malloc(wordSize*sizeof(int));

    if ( ptr != NULL )
    {
        return ptr;
    }

    else perror("\n ERROR in allocateIntPtr ");
}

char  *allocateCharPtr  ( int wordSize )
{
    char *ptr = (char*)malloc(wordSize*sizeof(char));

    if ( ptr != NULL )
    {
        return ptr;
    }

    else perror("\n ERROR in allocateCharPtr ");
}

float *allocateFloatPtr ( int wordSize )
{
    float *ptr = (float*)malloc(wordSize*sizeof(float));

    if ( ptr != NULL )
    {
        return ptr;
    }

    else perror("\n ERROR in allocateFloatPtr ");
}


/* Opérations sur les tableaux */

void initializeIntTable ( int  *table, int  tableLength, int constant )
{
    if ( table != NULL )
    {
        int i;
        for ( i=0 ; i<tableLength ; i++ )
        {
            table[i] = constant;
        }
    }

    else perror("\n ERROR in initializeIntTable ");
}

void displayString      ( char *table, int *tableLength               )
{
    if ( table != NULL && tableLength != NULL )
    {
        int i;
        for ( i=0 ; i< *tableLength ; i++ )
        {
            printf("%c", table[i]);
        }
    }

    else perror("\n ERROR in displayTable ");
}

void displayIntTable    ( int  *table, int *tableLength               )
{
    if ( table != NULL && tableLength != NULL )
    {
        int i;
        for ( i=0 ; i< *tableLength ; i++ )
        {
            printf("\ntable[%03i] = %d", i, table[i]);
        }
    }

    else perror("\n ERROR in displayIntTable ");
}


/* Opérations sur les fichiers */

int   getCharFilesNumbers ( char *filePath                    )
{
    FILE *file = fopen( filePath,"r");

    if( file != NULL )
      {
          int  counter = 0;
          char c;

          while( fscanf( file,"%c",&c ) != EOF )
          {
              if ( counter < INT_MAX )
              {
                 counter++;
              }

              else perror("\n ERROR in getCharFilesNumber 2 ");
          }

          return counter;
      }

    else perror("\n ERROR in getCharFilesNumber 1 ");

  fclose(file);
}

char *fileToString        ( char *filePath, int *bufferLength )
{

    FILE *file = fopen( filePath,"r" );

    if( file != NULL && bufferLength != NULL)
    {
             *bufferLength = getCharFilesNumbers( filePath );

        //printf("\n\n--length %d\n\n", *bufferLength);
        char *buffer = allocateCharPtr( *bufferLength );

        char  c;
        int   offset = 0;

        while( fscanf( file,"%c",&c ) != EOF )
        {
            buffer[offset] = c;
            offset++;
        }

        return buffer;
    }

    else perror("\n ERROR in fileToString ");

    fclose(file);
}


/* Fonctions pour l'analyses */

void   triBulle           ( int   *table   , int     tableLength  , char *ASCIIE_String                       )
{
    if ( table != NULL )
    {
        int i,j,temp;
        char tempC;

        for( i=tableLength-1 ; i>0 ; i-- )
        {
            for( j=1 ; j<=i ; j++ )
            {
                if( table[j-1]>table[j] )
                {
                    temp   = table[j-1];
                    table[j-1] = table[j];
                    table[j]   = temp;

                    tempC   = ASCIIE_String[j-1];
                    ASCIIE_String[j-1] = ASCIIE_String[j];
                    ASCIIE_String[j]   = tempC;
                }
            }
        }
    }

    else perror("\n ERROR in tribulle ");
}

void   displayIntResults  ( int   *table                                                                      )
{
    if ( table != NULL )
    {
        char ASCIIE_String[256]={'\0','\1','\2','\3','\4','\5','\6','\7','\10','\11','\12','\13','\14','\15','\16','\17','\20','\21','\22','\23','\24','\25','\26','\27','\30','\31','\32','\33','\34','\35','\36','\37','\40','\41','\42','\43','\44','\45','\46','\47','\50','\51','\52','\53','\54','\55','\56','\57','\60','\61','\62','\63','\64','\65','\66','\67','\70','\71','\72','\73','\74','\75','\76','\77','\100','\101','\102','\103','\104','\105','\106','\107','\110','\111','\112','\113','\114','\115','\116','\117','\120','\121','\122','\123','\124','\125','\126','\127','\130','\131','\132','\133','\134','\135','\136','\137','\140','\141','\142','\143','\144','\145','\146','\147','\150','\151','\152','\153','\154','\155','\156','\157','\160','\161','\162','\163','\164','\165','\166','\167','\170','\171','\172','\173','\174','\175','\176','\177','\200','\201','\202','\203','\204','\205','\206','\207','\210','\211','\212','\213','\214','\215','\216','\217','\220','\221','\222','\223','\224','\225','\226','\227','\230','\231','\232','\233','\234','\235','\236','\237','\240','\241','\242','\243','\244','\245','\246','\247','\250','\251','\252','\253','\254','\255','\256','\257','\260','\261','\262','\263','\264','\265','\266','\267','\270','\271','\272','\273','\274','\275','\276','\277','\300','\301','\302','\303','\304','\305','\306','\307','\310','\311','\312','\313','\314','\315','\316','\317','\320','\321','\322','\323','\324','\325','\326','\327','\330','\331','\332','\333','\334','\335','\336','\337','\340','\341','\342','\343','\344','\345','\346','\347','\350','\351','\352','\353','\354','\355','\356','\357','\360','\361','\362','\363','\364','\365','\366','\367','\370','\371','\372','\373','\374','\375','\376','\377'};

        int i=0;
        for ( i=0 ; i<256 ; i++ )
        {
            if ( table[i]>0 )
            {
                printf("\n %c : %09i occurences", ASCIIE_String[i], table[i]);
            }
        }
    }

    else perror("\n displayResults ");
}

void   displayFloatResults( float *table                                                                      )
{
    if ( table != NULL )
    {
        char ASCIIE_String[256]={'\0','\1','\2','\3','\4','\5','\6','\7','\10','\11','\12','\13','\14','\15','\16','\17','\20','\21','\22','\23','\24','\25','\26','\27','\30','\31','\32','\33','\34','\35','\36','\37','\40','\41','\42','\43','\44','\45','\46','\47','\50','\51','\52','\53','\54','\55','\56','\57','\60','\61','\62','\63','\64','\65','\66','\67','\70','\71','\72','\73','\74','\75','\76','\77','\100','\101','\102','\103','\104','\105','\106','\107','\110','\111','\112','\113','\114','\115','\116','\117','\120','\121','\122','\123','\124','\125','\126','\127','\130','\131','\132','\133','\134','\135','\136','\137','\140','\141','\142','\143','\144','\145','\146','\147','\150','\151','\152','\153','\154','\155','\156','\157','\160','\161','\162','\163','\164','\165','\166','\167','\170','\171','\172','\173','\174','\175','\176','\177','\200','\201','\202','\203','\204','\205','\206','\207','\210','\211','\212','\213','\214','\215','\216','\217','\220','\221','\222','\223','\224','\225','\226','\227','\230','\231','\232','\233','\234','\235','\236','\237','\240','\241','\242','\243','\244','\245','\246','\247','\250','\251','\252','\253','\254','\255','\256','\257','\260','\261','\262','\263','\264','\265','\266','\267','\270','\271','\272','\273','\274','\275','\276','\277','\300','\301','\302','\303','\304','\305','\306','\307','\310','\311','\312','\313','\314','\315','\316','\317','\320','\321','\322','\323','\324','\325','\326','\327','\330','\331','\332','\333','\334','\335','\336','\337','\340','\341','\342','\343','\344','\345','\346','\347','\350','\351','\352','\353','\354','\355','\356','\357','\360','\361','\362','\363','\364','\365','\366','\367','\370','\371','\372','\373','\374','\375','\376','\377'};

        int i=0;
        for ( i=0 ; i<256 ; i++ )
        {
            if ( table[i]>0 )
            {
                printf("\n %c : %.01f %%", ASCIIE_String[i], table[i]);
            }
        }
    }

    else perror("\n displayResults ");
}

float *toPercentage       ( int   *intTable, int    intTableLenght, int numberOfElements                      )
{
    if ( intTable != NULL )
    {
        float *floatTable = allocateFloatPtr(intTableLenght);

        int i;
        for ( i=0 ; i<intTableLenght ; i++ )
        {
            floatTable[i]=(float)(100.*intTable[i]/numberOfElements);
        }

        return floatTable;
    }

    else perror("\n ERROR in toPercentage ");
}

int   *analyseFile        ( char  *filePath                                                                   )
{
    if ( filePath != NULL )
    {
        int  *fileToAnalizeLength = allocateIntPtr(1);

        char *fileToAnalize = fileToString( filePath, fileToAnalizeLength );

        //displayString( fileToAnalize, *fileToAnalizeLength );

        int  *index = allocateIntPtr(256);

        initializeIntTable( index, 256, 0 );

        int currentChar;
        int i;
        for ( i=0 ; i<*fileToAnalizeLength ; i++ )
        {
            int asciiCode = (int)(fileToAnalize[i]);
            if ( asciiCode < 0 )
            {
                *(index + asciiCode +256 ) = *(index + asciiCode) + 1;
            }

            else *(index + asciiCode) = *(index + asciiCode) + 1;
        }

        free(fileToAnalizeLength);

        return index;
    }

    else perror("\n analyseFile ");
}

void   saveResults        ( char  *filePath, float *floatTable    , int *intTable       , char *ASCIIE_String )
{
   FILE *file=fopen(filePath,"w");

   if( file != NULL && filePath != NULL && floatTable != NULL && intTable != NULL )
   {
       fprintf(file, "\n+---------------------+------------+------------+------------+");
       fprintf(file, "\n| ASCIIE DECIMAL CODE | OCCURENCES | PERCENTAGE | CHARACTER  |");
       fprintf(file, "\n+---------------------+------------+------------+------------+");

       int i=0;
       for ( i=0 ; i<256 ; i++ )
       {
           if ( intTable[i] > 0 )
           {
               if ( 32 < (int)ASCIIE_String[i] && (int)ASCIIE_String[i] <= 127 )
               {
                   fprintf(file, "\n|         %3i         | %10i | %10.2f | %c          |", (int)ASCIIE_String[i], intTable[i], floatTable[i], ASCIIE_String[i]);
                   fprintf(file, "\n+---------------------+------------+------------+------------+");
               }

               else if ( -128 <= (int)ASCIIE_String[i] && (int)ASCIIE_String[i] <= -1 )
               {
                   fprintf(file, "\n|         %3i         | %10i | %10.2f | %c          |", (int)ASCIIE_String[i]+256, intTable[i], floatTable[i], ASCIIE_String[i]);
                   fprintf(file, "\n+---------------------+------------+------------+------------+");
               }

               else
               {
                   switch( (int)ASCIIE_String[i] )
                   {
                       case  0 : {
                                    fprintf(file, "\n|         %3i         | %10i | %10.2f | NUL        |", (int)ASCIIE_String[i], intTable[i], floatTable[i]);
                                    fprintf(file, "\n+---------------------+------------+------------+------------+");
                                    break;
                                 }

                       case  1 : {
                                    fprintf(file, "\n|         %3i         | %10i | %10.2f | SOH        |", (int)ASCIIE_String[i], intTable[i], floatTable[i]);
                                    fprintf(file, "\n+---------------------+------------+------------+------------+");
                                    break;
                                 }

                       case  2 : {
                                    fprintf(file, "\n|         %3i         | %10i | %10.2f | STX        |", (int)ASCIIE_String[i], intTable[i], floatTable[i]);
                                    fprintf(file, "\n+---------------------+------------+------------+------------+");
                                    break;
                                 }

                       case  3 : {
                                    fprintf(file, "\n|         %3i         | %10i | %10.2f | ETX        |", (int)ASCIIE_String[i], intTable[i], floatTable[i]);
                                    fprintf(file, "\n+---------------------+------------+------------+------------+");
                                    break;
                                 }

                       case  4 : {
                                    fprintf(file, "\n|         %3i         | %10i | %10.2f | EOT        |", (int)ASCIIE_String[i], intTable[i], floatTable[i]);
                                    fprintf(file, "\n+---------------------+------------+------------+------------+");
                                    break;
                                 }

                       case  5 : {
                                    fprintf(file, "\n|         %3i         | %10i | %10.2f | ENQ        |", (int)ASCIIE_String[i], intTable[i], floatTable[i]);
                                    fprintf(file, "\n+---------------------+------------+------------+------------+");
                                    break;
                                 }

                       case  6 : {
                                    fprintf(file, "\n|         %3i         | %10i | %10.2f | ACK        |", (int)ASCIIE_String[i], intTable[i], floatTable[i]);
                                    fprintf(file, "\n+---------------------+------------+------------+------------+");
                                    break;
                                 }

                       case  7 : {
                                    fprintf(file, "\n|         %3i         | %10i | %10.2f | BEL        |", (int)ASCIIE_String[i], intTable[i], floatTable[i]);
                                    fprintf(file, "\n+---------------------+------------+------------+------------+");
                                    break;
                                 }

                       case  8 : {
                                    fprintf(file, "\n|         %3i         | %10i | %10.2f | BS         |", (int)ASCIIE_String[i], intTable[i], floatTable[i]);
                                    fprintf(file, "\n+---------------------+------------+------------+------------+");
                                    break;
                                 }

                       case  9 : {
                                    fprintf(file, "\n|         %3i         | %10i | %10.2f | HT         |", (int)ASCIIE_String[i], intTable[i], floatTable[i]);
                                    fprintf(file, "\n+---------------------+------------+------------+------------+");
                                    break;
                                 }

                       case 10 : {
                                    fprintf(file, "\n|         %3i         | %10i | %10.2f | LF         |", (int)ASCIIE_String[i], intTable[i], floatTable[i]);
                                    fprintf(file, "\n+---------------------+------------+------------+------------+");
                                    break;
                                 }

                       case 11 : {
                                    fprintf(file, "\n|         %3i         | %10i | %10.2f | VT         |", (int)ASCIIE_String[i], intTable[i], floatTable[i]);
                                    fprintf(file, "\n+---------------------+------------+------------+------------+");
                                    break;
                                 }

                       case 12 : {
                                    fprintf(file, "\n|         %3i         | %10i | %10.2f | FF         |", (int)ASCIIE_String[i], intTable[i], floatTable[i]);
                                    fprintf(file, "\n+---------------------+------------+------------+------------+");
                                    break;
                                 }

                       case 13 : {
                                    fprintf(file, "\n|         %3i         | %10i | %10.2f | CR         |", (int)ASCIIE_String[i], intTable[i], floatTable[i]);
                                    fprintf(file, "\n+---------------------+------------+------------+------------+");
                                    break;
                                 }

                       case 14 : {
                                    fprintf(file, "\n|         %3i         | %10i | %10.2f | SO         |", (int)ASCIIE_String[i], intTable[i], floatTable[i]);
                                    fprintf(file, "\n+---------------------+------------+------------+------------+");
                                    break;
                                 }

                       case 15 : {
                                    fprintf(file, "\n|         %3i         | %10i | %10.2f | SI         |", (int)ASCIIE_String[i], intTable[i], floatTable[i]);
                                    fprintf(file, "\n+---------------------+------------+------------+------------+");
                                    break;
                                 }

                       case 16 : {
                                    fprintf(file, "\n|         %3i         | %10i | %10.2f | DLE        |", (int)ASCIIE_String[i], intTable[i], floatTable[i]);
                                    fprintf(file, "\n+---------------------+------------+------------+------------+");
                                    break;
                                 }

                       case 17 : {
                                    fprintf(file, "\n|         %3i         | %10i | %10.2f | DC1        |", (int)ASCIIE_String[i], intTable[i], floatTable[i]);
                                    fprintf(file, "\n+---------------------+------------+------------+------------+");
                                    break;
                                 }

                       case 18 : {
                                    fprintf(file, "\n|         %3i         | %10i | %10.2f | DC2        |", (int)ASCIIE_String[i], intTable[i], floatTable[i]);
                                    fprintf(file, "\n+---------------------+------------+------------+------------+");
                                    break;
                                 }

                       case 19 : {
                                    fprintf(file, "\n|         %3i         | %10i | %10.2f | DC3        |", (int)ASCIIE_String[i], intTable[i], floatTable[i]);
                                    fprintf(file, "\n+---------------------+------------+------------+------------+");
                                    break;
                                 }

                       case 20 : {
                                    fprintf(file, "\n|         %3i         | %10i | %10.2f | DC4        |", (int)ASCIIE_String[i], intTable[i], floatTable[i]);
                                    fprintf(file, "\n+---------------------+------------+------------+------------+");
                                    break;
                                 }

                       case 21 : {
                                    fprintf(file, "\n|         %3i         | %10i | %10.2f | NAK        |", (int)ASCIIE_String[i], intTable[i], floatTable[i]);
                                    fprintf(file, "\n+---------------------+------------+------------+------------+");
                                    break;
                                 }

                       case 22 : {
                                    fprintf(file, "\n|         %3i         | %10i | %10.2f | SYN        |", (int)ASCIIE_String[i], intTable[i], floatTable[i]);
                                    fprintf(file, "\n+---------------------+------------+------------+------------+");
                                    break;
                                 }

                       case 23 : {
                                    fprintf(file, "\n|         %3i         | %10i | %10.2f | ETB        |", (int)ASCIIE_String[i], intTable[i], floatTable[i]);
                                    fprintf(file, "\n+---------------------+------------+------------+------------+");
                                    break;
                                 }

                       case 24 : {
                                    fprintf(file, "\n|         %3i         | %10i | %10.2f | CAN        |", (int)ASCIIE_String[i], intTable[i], floatTable[i]);
                                    fprintf(file, "\n+---------------------+------------+------------+------------+");
                                    break;
                                 }

                       case 26 : {
                                    fprintf(file, "\n|         %3i         | %10i | %10.2f | EM         |", (int)ASCIIE_String[i], intTable[i], floatTable[i]);
                                    fprintf(file, "\n+---------------------+------------+------------+------------+");
                                    break;
                                 }

                       case 27 : {
                                    fprintf(file, "\n|         %3i         | %10i | %10.2f | SUB        |", (int)ASCIIE_String[i], intTable[i], floatTable[i]);
                                    fprintf(file, "\n+---------------------+------------+------------+------------+");
                                    break;
                                 }

                       case 28 : {
                                    fprintf(file, "\n|         %3i         | %10i | %10.2f | ESC        |", (int)ASCIIE_String[i], intTable[i], floatTable[i]);
                                    fprintf(file, "\n+---------------------+------------+------------+------------+");
                                    break;
                                 }

                       case 29 : {
                                    fprintf(file, "\n|         %3i         | %10i | %10.2f | FS         |", (int)ASCIIE_String[i], intTable[i], floatTable[i]);
                                    fprintf(file, "\n+---------------------+------------+------------+------------+");
                                    break;
                                 }

                       case 30 : {
                                    fprintf(file, "\n|         %3i         | %10i | %10.2f | GS         |", (int)ASCIIE_String[i], intTable[i], floatTable[i]);
                                    fprintf(file, "\n+---------------------+------------+------------+------------+");
                                    break;
                                 }

                       case 31 : {
                                    fprintf(file, "\n|         %3i         | %10i | %10.2f | RS         |", (int)ASCIIE_String[i], intTable[i], floatTable[i]);
                                    fprintf(file, "\n+---------------------+------------+------------+------------+");
                                    break;
                                 }

                       case 32 : {
                                    fprintf(file, "\n|         %3i         | %10i | %10.2f | SPACE      |", (int)ASCIIE_String[i], intTable[i], floatTable[i]);
                                    fprintf(file, "\n+---------------------+------------+------------+------------+");
                                    break;
                                 }

                   }
               }
           }
       }
   }

   fclose(file);

   //system("notepad results.txt");
}

void   getFileAnalysis    ( char  *input   , char  *output                                                    )
{
    int *fileAnalized = analyseFile(input);

    char ASCIIE_String[256]={'\0','\1','\2','\3','\4','\5','\6','\7','\10','\11','\12','\13','\14','\15','\16','\17','\20','\21','\22','\23','\24','\25','\26','\27','\30','\31','\32','\33','\34','\35','\36','\37','\40','\41','\42','\43','\44','\45','\46','\47','\50','\51','\52','\53','\54','\55','\56','\57','\60','\61','\62','\63','\64','\65','\66','\67','\70','\71','\72','\73','\74','\75','\76','\77','\100','\101','\102','\103','\104','\105','\106','\107','\110','\111','\112','\113','\114','\115','\116','\117','\120','\121','\122','\123','\124','\125','\126','\127','\130','\131','\132','\133','\134','\135','\136','\137','\140','\141','\142','\143','\144','\145','\146','\147','\150','\151','\152','\153','\154','\155','\156','\157','\160','\161','\162','\163','\164','\165','\166','\167','\170','\171','\172','\173','\174','\175','\176','\177','\200','\201','\202','\203','\204','\205','\206','\207','\210','\211','\212','\213','\214','\215','\216','\217','\220','\221','\222','\223','\224','\225','\226','\227','\230','\231','\232','\233','\234','\235','\236','\237','\240','\241','\242','\243','\244','\245','\246','\247','\250','\251','\252','\253','\254','\255','\256','\257','\260','\261','\262','\263','\264','\265','\266','\267','\270','\271','\272','\273','\274','\275','\276','\277','\300','\301','\302','\303','\304','\305','\306','\307','\310','\311','\312','\313','\314','\315','\316','\317','\320','\321','\322','\323','\324','\325','\326','\327','\330','\331','\332','\333','\334','\335','\336','\337','\340','\341','\342','\343','\344','\345','\346','\347','\350','\351','\352','\353','\354','\355','\356','\357','\360','\361','\362','\363','\364','\365','\366','\367','\370','\371','\372','\373','\374','\375','\376','\377'};

    triBulle( fileAnalized, 256, ASCIIE_String );

    float *fileAnalizedInPercentage = toPercentage( fileAnalized, 256, getCharFilesNumbers(input) );

    saveResults( output, fileAnalizedInPercentage, fileAnalized, ASCIIE_String );

    free(fileAnalized);
    free(fileAnalizedInPercentage);

    return 0;
}

Conclusion

En espérant que cela puisse servir à quelqu'un dans un autre code source dédiée à une tâche plus spécifique.

Fichier Zip

Les Membres Club peuvent télécharger directement un fichier contenu dans le zip sans télécharger le zip en entier !

analyseurDeFichiers v2.c 112 octets
analyseurDeFichiers v2.h 26 189 octets

Télécharger le zip

Historique

27 septembre 2010 14:48:50 :: Modification lié à la MAJ du code source.
27 septembre 2010 14:56:37 :: orthographe ^^

Sources du même auteur

MODIFIER RAPIDEMENT SON FICHIER HOST

Toutes les sources de sholvaC

Sources de la même categorie

COMPTER LE NOMBRE DE PAGES D'UN FICHIER PDF par Renfield

GENERE BMP par lajouad

GETIONNAIRE D'UNE BIBLIOTHÉQUE EN C par benzarabel

FONCTION D'ÉDITION DE FICHIER BIT À BIT [C-MULTIPLATEFORME] par lynxtyle

UN GESTIONNAIRE DU FICHIER par benzarabel

Toutes les sources de la catégorie Fichiers / Disque

Sources en rapport avec celle ci

GENERE BMP par lajouad

GETIONNAIRE D'UNE BIBLIOTHÉQUE EN C par benzarabel

COMPARATEUR D'IMAGES DE CONSOLE MONOCHROME DE BASE ET CRÉATI... par ATH|500|

DÉCOUPEUR DE FICHIERS OUTLOOK AVEC L'EXTENSION DBX par lann

[OPENGL - SDL] SYSTÈME DE MENUS A PARTIR D'UN FICHIER TEXTE par asmanur

Commentaires et avis

Commentaire de vicenzo le 24/09/2010 08:26:47

salut,

tu lis ton fichier caractère par caractère et à fois chaque tu réalloues ton buffer !!

Grosses perte de temps et de mémoire inutile !

Faut revoir tout ca...

Commentaire de sholvaC le 24/09/2010 08:54:42

Si je fais ça c'est pour allouer justement pile poil ce qu'il faut ! Je ne comprends pas en quoi c'est une perte de mémoire ?! Une perte de temps oui car on pourrait compter le nombre de caractères présents puis allouer. Certes ce serait plus rapide mais j'avais envi de mettre en ½uvre la fonction realloc. Mais je ne vois pas en quoi cela n'est pas correct de procéder ainsi !

Commentaire de vicenzo le 24/09/2010 09:27:38

primo, la taille exacte du fichier peut être obtenue par un ftell des l'ouverture du fichier, ce qu permet de ne faire qu'un seul malloc au total. Dans ton code, si ton fichier fait 1Mo, tu fais 1 million de realloc. Ca sert a rien et il n'y a rien de plus inefficace...
Enfin, tu n'a pas besoin d'allouer un buffer pour stocker le contenu du fichier.

Commentaire de sholvaC le 24/09/2010 09:43:56

Ok, on est d'accord que c'est lent mais ne dites pas que c'est faux s'il vous plait. Ce n'est pas la même chose.

Commentaire de sholvaC le 24/09/2010 09:44:52

Je vais modifier donc ce point et maj la source. Merci pour vos commentaires.

Commentaire de vicenzo le 24/09/2010 09:52:04

la seule chose que je dis c'est :
- un realloc par caractère lu d'un fichier ne sert à rien. Un seul malloc avec la taille du fichier suffit
- utiliser un buffer alloué dynamiquement ne sert à rien. La lecture directe du fichier avec mis à jour de la table des occurrences suffit.
Donc, pourquoi se compliquer la vie en utilisant un buffer, qui plus est, réalloué X fois inutilement ?

Commentaire de eomer212 le 24/09/2010 12:05:17

si j'ai bien compris, tu veux compter les occurences de caractéres de 0 à 255 stockés sous forme d'un octet dans un fichier.
alors, c'est l'une des plus mauvaises facons de procéder.
plusieurs raisons:
pour la premiere, je rejoint vincenzo, reallouer dynamiquement le caractere lu est une immense perte de temps, d'espace, et un risque potentiel accru inutilement.
une variable allouée aurait largement suffie.
ensuite, une chose qui m'a fait sauter de ma chaise, c'est que tu parcours 256 fois le fichier.. pour tester à chaque fois la presence du même caractére.
anodin dans le cas d'un petit fichier, mais essaie la meme chose avec par exemple un .avi ou divx de 700 MO.. la tu vas criser, c'est pas possible, trop long.
la 'bonne' solution, ou du moins celle qui est beaucoup plus optimisée et efficace pour ce cas, c'est de creer une table de stockage d'entiers avec un index, de lire chaque caractére du fichier à partir d'un buffer alloué une fois et recharger avec la portion de fichier à parcourir, et d'incrementer le contenu d'une table d'index (numero du caractere),
a la fin, tu comptes le total, et tu fais tes ratios..
donc en clair, pseudo code:

largeur=sizeof(unsigned long int);  // pour jouer avec les pointeurs, toujours vérifier la largeur de stockage d'une variable, sinon surprises potentielles..
unsigned long in *presents;     // table de stockage du comptage
presents=malloc(largeur*256);   // allocation de la table de stockage je le fais en pointeur, mais ca aurait pu tout aussi bien etre une variable unsigned long int presents[256]
unsigned char caractere;      // pour detailler, et stocker temporairement le caractere lu du buffer de lecture fichier
while (readfiletobuffer)
{
   suivant=0;
   for (i=0;i<longueur lue dans le buffer;i++)
   {
      caractere=*(buffer+i);   // recuperer le caractere à partir du buffer de lecture
      *(presents+i)++;   // incrementer la table à la position ascii correspondante
   }
}
la table presents contient pour chaque index de 0 à 255, le nombre d'itérations du caractére rencontré..
simple, rapide, efficace..
aprés, la, tu peux t'amuser et faire du tri à bulle, en passant complétement dépassé, mais suffisant pour trier 255 valeurs.
il serait bien, de sortir la table triée avec en premier le numero ascii reel justifié, et ensuite le caractére..

pour aller loin et vite, penser faineant..

Commentaire de sholvaC le 24/09/2010 13:21:07

Oui je suis conscient que le realloc est plus lent que la méthode que vous proposez, c'était juste pour m'entraîner à manier realloc même si je le concède, ce n'était pas le bon exemple.

Je n'ai pas vraiment compris ton algorithme d'indexage mais je vais me renseigner.

Oui et le tri à bulle, j'avoue sa complexité n'est pas la meilleure que l'on puisse trouver, mais j'avais déjà implémenté celui-ci. Je ne me suis donc pas cassé la tête.

Merci pour vos critiques, je vais voir ce que je peux faire.

Commentaire de sholvaC le 24/09/2010 13:28:36

Qu'appelez vous le numéro ascii reel justifé ? Sa valeur en base 10 ?

Commentaire de eomer212 le 24/09/2010 23:52:16

justifié, c'est faire en sorte que les chiffres soient alignés pour en faciliter la lecture.
voir printf("%03i",13); tous les chiffres auront 3 numéros.
pour l'algorithme, c'est le nombre d'operation minimaliste qui amene au resultat qui doit etre privilégié.
si tu dois parcourir un fichier, ne le parcours qu'une fois.
si tu dois le lire plusieurs fois, il y a un probleme..
une fois que tu as le contenu du fichier, acceder à une table est plus rapide que tout. tu incremente le compteur correspondant à la valeur que tu as lu.
de plus, si ta table reste limitée, tu n'auras pas de probleme de latence de memoire, optimiser à fond..:)

quand tu as parcouru tout le fichier, ta liste de compteurs contient le nombre de caracteres correspondant dans chaque compteur.
ha, un detail que j'ai oublié de mettre.
par defaut et pat precaution, il vaut mieux initialiser tous les compteurs à 0 pour etre sur, dés le départ.

Commentaire de sholvaC le 25/09/2010 10:43:53

Honnêtement, je ne suis toujours pas sûr d'avoir compris. Ce que j'ai compris est ça :

Parcourir le tableau contenant le fichier
          Recupérer le caractère courant char current
          int code = (int)current // On récupére sa valeur (decimale je crois en convertissant le char en int)
          *(table + code)++; // On incrémente directement le compteur du caractere dans la table
Fin du parcours.

Là oui je pense qu'en effet cela risque d'être beaucoup plus rapide ! C'est bien ce que vous expliquiez ?

Commentaire de eomer212 le 25/09/2010 11:54:46

bingo!
t'as compris.
la, ca va aller vite, le code sera plus court et plus sur.

Commentaire de sholvaC le 25/09/2010 16:57:26

Ok merci, je n'avais pas du tout pensé à cette astuce, je reprends le code et je poste la source modifiée. Merci pour votre aide et commentaires.

Commentaire de LeFauve42 le 27/09/2010 13:22:18

Bonjour,

Je suis d'accord avec tout le monde a propos de :
- L'utilisation de realloc qui fragmente la memoire et en plus ici est inutile (si vraiment tu dois t'en servir, essaie de reallouer par blocks d'au moins 8 ou 16 Ko supplementaires, ca reduira la casse, et en plus je crois me souvenir que windows arrondie ses blocks de memoirs aloues a 8 Ko (a verifier).
- Stocker le fichier est inutile : tu lis chaque caractere et tu incrementes son compteur (ce serait peut-etre juste plus lisible d'ecrire table[code]++ au lieu de *(table+code)++ mais c'est une question de gouts). Pense juste a lire plusieurs caracteres a la fois pour aller plus vite (4 ou 8 Ko au moins. Apres 64Ko, le gain de performences devient marginal).

Sinon :
- J'ai du mal a voir ce que tu essaie de faire avec ta fonction generateStringForASCIIEcode(). Est-ce que tu generes un ".c" ? Pour quoi faire ?
- Pour le bubble sort, si tu ne veux pas te casser la tete et vu que tu n'as que 256 valeurs a trier tu peux garder cet algo, mais pour le principe, tu peux ajouter un flag que tu mets lorsque tu permutes deux valeurs. Des ta premiere iteration sans aucune permutation, tu peux arreter le tri car ton tableau est trie (ca fera gagner environ 30% dans la plupart des tableaux). Ici tu ne veras sans doute aucune difference, mais comme tu reutilises ton code, autant avoir une version "plus performante".

Eric

Commentaire de sholvaC le 27/09/2010 14:52:13

generateStringForASCIIEcode() est une fonction qui me permet de générer comme son nom l'indique le code C pour déclarer la table ASCIIE dans un tableau de caractères. En effet, je n'avais nullement envie de la taper à la main...

Pour l'affichage du résultat dans la présentation de la source, c'est correctement indenté ce qui n'est pas le cas dans le post...

Commentaire de LeFauve42 le 27/09/2010 18:53:59

> generateStringForASCIIEcode() est une fonction qui me permet de générer comme son nom l'indique
> le code C pour déclarer la table ASCIIE dans un tableau de caractères. En effet, je n'avais
> nullement envie de la taper à la main...

Tu veux dire que ca genere ca :
char ASCIIE_String[256]={'\0','\1','\2','\3','\4','\5','\6','\7','\10','\11','\12','\13','\14','\15','\16','\17','\20','\21','\22','\23','\24','\25','\26','\27','\30','\31','\32','\33','\34','\35','\36','\37','\40','\41','\42','\43','\44','\45','\46','\47','\50','\51','\52','\53','\54','\55','\56','\57','\60','\61','\62','\63','\64','\65','\66','\67','\70','\71','\72','\73','\74','\75','\76','\77','\100','\101','\102','\103','\104','\105','\106','\107','\110','\111','\112','\113','\114','\115','\116','\117','\120','\121','\122','\123','\124','\125','\126','\127','\130','\131','\132','\133','\134','\135','\136','\137','\140','\141','\142','\143','\144','\145','\146','\147','\150','\151','\152','\153','\154','\155','\156','\157','\160','\161','\162','\163','\164','\165','\166','\167','\170','\171','\172','\173','\174','\175','\176','\177','\200','\201','\202','\203','\204','\205','\206','\207','\210','\211','\212','\213','\214','\215','\216','\217','\220','\221','\222','\223','\224','\225','\226','\227','\230','\231','\232','\233','\234','\235','\236','\237','\240','\241','\242','\243','\244','\245','\246','\247','\250','\251','\252','\253','\254','\255','\256','\257','\260','\261','\262','\263','\264','\265','\266','\267','\270','\271','\272','\273','\274','\275','\276','\277','\300','\301','\302','\303','\304','\305','\306','\307','\310','\311','\312','\313','\314','\315','\316','\317','\320','\321','\322','\323','\324','\325','\326','\327','\330','\331','\332','\333','\334','\335','\336','\337','\340','\341','\342','\343','\344','\345','\346','\347','\350','\351','\352','\353','\354','\355','\356','\357','\360','\361','\362','\363','\364','\365','\366','\367','\370','\371','\372','\373','\374','\375','\376','\377'};

Alors pour info (desole de l'avoir rate dans mon premier commentaire), cette variable ne sert a rien...
Si tu veux le caracteres "n", il te suffis de caster n en char. Exemple:
- Au lieu de ASCIIE_String[i] tu peux mettre ((char)i)
- Si c'est pour afficher ton char avec printf, tu n'as meme pas besoin de le caster : printf("%c",i) marche directement.

Encore une petite question : pourquoi utilises-tu des int* pour passer les longueurs dans tes fonction display*() ?

Eric

Commentaire de sholvaC le 28/09/2010 00:43:02

Ah oui en effet, maintenant que vous le dites, c'est plus court, je n'y avais absolument pas pensé. Merci pour cette remarque pertinente. Je tâcherai de m'en souvenir ultérieurement.

Pour les fonction type display, oui on pourrait ne pas mettre un pointeur. Comme les longueurs étaient stockés dans des int*, j'ai juste bêtement continuer ainsi. Y'a pas vraiment de raisons apparentent.

Commentaire de Cyberboy2054 le 30/09/2010 12:02:58

Yop
Maintenant que tu utilise une table, il est inutile de faire un tri à bulle.
Supprime donc la ligne 522 ( triBulle( fileAnalized, 256, ASCIIE_String ); ) dans getFileAnalysis, et regarde le temps d'exécution ;)

Ajouter un commentaire

Discussions en rapport avec ce code source dans le forum

Ecrire ds un fichier dans un fichier texte ce ki apparait ds une console dos [ par BennyB ] Es-ca possible ???J'ai essayé gets(string); fwrite( stdout, sizeof( char ), 250, OutFile ); fclose( OutFile );ms ca marche pas :( recuperation de donnees d un fichier texte. [ par coyotedef ] j'aimerai recuperer des donnees presente dans fichier texte et les classer dans un tableau. ces donnees sont toutes du meme format mais se trouve au m Compter les lignes d un fichier texte [ par DeepThroat ] Bonjour a tous !J'aimerai trouver une fontion simple qui retourne le nombre de lignes dans un fichier , ou bien qui affiche ce nombre de lignes.j'imag lire/ecrire fichier texte a plusieurs colonnes [ par denini ] voilà, j'aimerais ecrire et lire sur un fichier texteJe voudrais stocker une date, une valeur et un nbet ce pour N clients.Je voudrais que le fichier ecrire et lire un fichier texte [ par denini ] voilà, j'aimerais ecrire et lire sur un fichier texteJe voudrais stocker une date, une valeur et un nbet ce pour N clients.Je voudrais que le fichier Acquisition de Données a partir d'un fichier texte [ par madcow41 ] 'lutBon j'ai un fichier qui contient des lignes formées ainsi :123.145.569.188 - - [12/Apr/2001:00:08:49 +0200] "GET /pagehtml.htm HTTP/1.x" et le res gestion de fichier [ par franc015 ] salut !!!voila je débute et je dois faire un prog. je dispose d'un fichier texte ( en fait une liste de fichier avec des retours chariot entre chaque ouvrir un fichier texte [ par kawazaki ] Salut Je voudrais ouvrir un fihier texte et ecrire a l'interieur puis faire la sauvegarde sur le disque.comment je procéde?merci pour la réponse Ecriture de fichier texte & Séparateur !! [ par Misutsu ] bonjour :)C'est la première fois que j'ai à utiliser des fichiers en C++, et je vois que l'espace sert de séparateur.Dans mon cas, j'ai besoin d'enreg inserer texte en debut de fichier [ par MrKribou ] Ma question: ya t'il une methode qui permettrait d'ecrire en debut de fichier (mais sans ecrire par dessus) ou faut t'il forcement passer par une sort

Nos sponsors

Derniers Blogs

IMAGINE CUP 2012, MAKE A SIGN EN FINALE par junarnoalg

KINECT 1.5 IS OUT ! par Vko

LES ACTUALITéS DE LA SEMAINE SUR C2I.FR (14 MAI - 20 MAI) par richardc

REACTIVE EXTENSIONS : CONSOMMER DES SERVICES AVEC RX PARTIE 3, LES PIèGES à éVITER par Groc

SHAREPOINT BLOG SITE, PROBLèME D'ARCHIVES par junarnoalg

Forum

MATRICE TEMPLATE par hjr2610

SUPERVISION DE LA BATTERIE par romanticgirl

RE : OPENCV ET INTERFACE GRAPHIQUE VISUAL STUDIO par buno

RE : SAC A DOS par hadjkaddour

OPENCV ET INTERFACE GRAPHIQUE VISUAL STUDIO par ssaif

Côté IT

Offres d'emploi

Formations Video

Appels d'offres

Realisation d-une version 2 d-un site e-commerce existant sous prestashop-REPUBLICATION
Budget : 5 000€
Recherche Infogerance Serveur Debian Linux
Budget : 1 800€
Creation d-un site vitrine avec MagentO
Budget : 2 000€

Logiciels

sDEVIS-FACTURES vlPRO (8.1.0.3)
SDEVIS-FACTURES VLPRO (8.1.0.3)

sDEVIS-FACTURES vlPRO a été mis au point pour les particuliers, créateurs, entrepreneurs, artisa...

Cliquez pour télécharger sDEVIS-FACTURES vlPRO
974 Application Server (12.2.4.6)
974 APPLICATION SERVER (12.2.4.6)

Développez de puissantes applications dans un environnement de 'cloud computing', clusterisé, séc...

Cliquez pour télécharger 974 Application Server
vPicture (1.4.2.1)
VPICTURE (1.4.2.1)

Avec vPicture, hébergez vos images facilement et rapidement. vPicture est un utilitaire simple, ...

Cliquez pour télécharger vPicture
Easy-Planning (2.2.1.6)
EASY-PLANNING (2.2.1.6)

Easy-Planning permet de créer des plannings sous la représentation de diagrammes et est adapté au...

Cliquez pour télécharger Easy-Planning
COM-BACKUP (2.0)
COM-BACKUP (2.0)

COM-BACKUP est un logiciel de sauvegarde qui permet de planifier les sauvegardes de vos dossiers ...

Cliquez pour télécharger COM-BACKUP