Analyseur de texte (maj v2)

Soyez le premier à donner votre avis sur cette source.

Vue 5 322 fois - Téléchargée 410 fois

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 / Exemple :


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.

Codes Sources

A voir également

Ajouter un commentaire

Commentaires

Messages postés
173
Date d'inscription
jeudi 20 décembre 2001
Statut
Membre
Dernière intervention
22 août 2008

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 ;)
Messages postés
12
Date d'inscription
mercredi 29 avril 2009
Statut
Membre
Dernière intervention
30 avril 2009

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.
Messages postés
239
Date d'inscription
vendredi 20 octobre 2006
Statut
Membre
Dernière intervention
20 avril 2009

> 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
Messages postés
12
Date d'inscription
mercredi 29 avril 2009
Statut
Membre
Dernière intervention
30 avril 2009

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...
Messages postés
239
Date d'inscription
vendredi 20 octobre 2006
Statut
Membre
Dernière intervention
20 avril 2009

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
Afficher les 18 commentaires

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.