Bonjour,

Je souhaite réaliser une simple analyse de fréquence sur un fichier quelquonque.
Pour cela je suppose qu'un élément sera interprété en tant qu'un unsigned int soit 4 octets dans mon environnement (windows 7).
Partant de là, j'ai donc 2^32 possibilités de valeurs. Par conséquent, je crée un fichier de 2^32*4 octets = 16Go pour stocker la fréquence d'apparition des mots binaire. La limite étant qu'un mot binaire ne devrait pas apparaître plus de 2^32-1 fois dans un fichier donnée.

Je parcours donc le fichier à analyser 4 octets par 4 octets, chaque 4 octets est alors interprété comme un unsigned int. Je me déplace dans le fichier de stockage à l'offset correspondant à la valeur récupérée et j'incrémente de 1 la fréquence.

Sauf que dans mon code, la taille du fichier augmente et dépasse les 16Go, ce qui revéle que je vais écrire plus loins que la limite "autorisée".

Ceci est la ligne qui positionne le curseur dans le fichier avant écriture
Code : Sélectionner tout - Visualiser dans une fenêtre à part
fseek(f_dst, buffer_src*sizeof(unsigned int), SEEK_SET);
J'en déduis donc qu'au moins cette ligne est incorrecte conformément à ce que je souhaite faire.
Je n'arrive pas à analyser mon erreur, est ce qu'un oeil expert pourrait m'aiguiller ?

Merci d'avance pour votre aide.

Voici le code de la fonction.

Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
FILE *binary_analyse( const char *path )
{
    FILE *f_dst = NULL;
    if (path)
    {
        FILE *f_dst = NULL;
        FILE *f_src = NULL;
        if ( (f_dst = file_open("D:\\table", "wb")) )
        {
            /* On travaille avec des unsigned int (4 octets soit 4294967296 valeurs différentes définissant une plage allant de 0 à 4294967295 */
            /* Cette boucle génére un fichier de 4294967296 "cases" de 4 octets chacunes */
            /* Ce fichier a pour but de stocker la fréquence d'apparition d'une valeur de cette plage à l'offset équivalent */
 
            /* On génère le fichier de 16 Go en l'initialisant avec des 0 */
            t_uint64 i=0;
            unsigned int j = 0;
            for ( i=0 ; i < 4294967296 ; i++)
                fwrite(&j, sizeof(unsigned int), 1, f_dst);
 
            file_close(f_dst);
        }
        else printf("\n%s", strerror(errno));
 
        if ( (f_src = file_open(path, "rb")) && (f_dst = file_open("D:\\table", "ab")) )
        {
            t_uint64 read_byte, written_byte, total_written_byte=0;
            unsigned int buffer_src = 0;
            unsigned int buffer_dst = 0;
            unsigned int x = 0;
 
            /* Parcourir le fichier à analyser 4 octets par 4 octets, on récupère la valeur décimale équivalente de type unsigned int dans buffer_src */
            while (0<(read_byte=fread(&buffer_src, sizeof(unsigned int), 1, f_src)))
            {
 
                /* Se Positionner dans le fichier de 16Go à l'offset de la valeur récupérée dans buffer_src */
                fseek(f_dst, buffer_src*sizeof(unsigned int), SEEK_SET);
                /* Lire cette valeur à l'offset trouvé*/
                fread(&buffer_dst, sizeof(unsigned int), 1, f_dst);
                /* Incrémenter de 1 la fréquence d'apparition de cette valeur */
                x=buffer_dst+1;
                /* Modifier cette valeur dans le fichier de 16 Go  */
                fwrite(&x, sizeof(unsigned int), 1, f_dst);
 
                total_written_byte+=read_byte*sizeof(unsigned int);
            }
            total_written_byte+=read_byte*sizeof(unsigned int);
            file_close(f_src);
            file_close(f_dst);
 
            t_uint64 f_src_size = file_length(path);
 
            if ( total_written_byte != f_src_size )
                printf("\n Erreur taille fichier : %I64u %I64u", f_src_size, total_written_byte );
        }
    }
    return f_dst;
}