Discussion :

[Darksnakes]

Bonsoir tout le monde.

Voilà, dans un projet j'ai besoin d'écrire des nombre dans un fichier texte successivement sur 9,10,11 ....... bits(je commence à 258). J'ai les fonctions qui permettent décrire successivement sur 9,10,11...... bits mais j'aimerai savoir sil il existe une fonction de c qui permette de savoir sur combien de chiffre on écrit un entier en binaire car je m'éviterait bien une boucle sachant que les nombres a écrire peuvent aller jusqu'à 16 bit voir plus, sinon je m'en contenterait. (le switch cas n'étant pas possible, car je n'est pas de borne supérieur)

MErci bcp


Yann

Ps: si je suis pas très claire, dites le moi, j'apporterais plus d'explication.

[Melem]

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
#include <math.h>
 
int n_digits_in_bin(int n)
{
    if (n >= 0)
        return 1 + (n == 0 ? 0 : log(n)/log(2));
    else
        return -1;
}

[Thierry Chappuis]

Je ne comprends pas l'intérêt d'écrire la représentation binaire de nombres dans un fichier de texte. Mais voici un exemple:

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
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
#include <stdio.h>
#include <stdlib.h>
#include <limits.h>
 
#define ARRAY_LEN(a) ( sizeof (a) / sizeof *(a) )
 
void int_write_as_bits(int nb, FILE *fp)
{
    if (fp != NULL)
    {
        unsigned int n = nb;
        char stack[(CHAR_BIT * sizeof n) + 1] = "";
        size_t top = 0;
 
        if (nb < 0)
        {
            /* On s'assure que n gere les representations negatives en complement
               a deux. */
            n = -1 * nb;
            n = -1 * n;
        }
 
        /* Ecriture bit a bit */
        do
        {
            int c = (n & 0x1) ? '1' : '0';
            stack[top++] = c;
            n = n >> 1;
        }
        while (n > 0);
 
        while (top > 0)
        {
            --top;
            fputc(stack[top], fp);
        }
    }
}
 
/* test */
int main(void)
{
    int ret = 0;
    FILE *fp = NULL;
    int nombres[] =
    {
        -1,
        -2,
        INT_MIN,
        0,
        INT_MAX,
        1,
        2,
        3,
        4,
        255,
        256,
        257,
        256,
        512,
        513,
        1024
    };
 
    fp = fopen("test.txt", "w");
    if (fp != NULL)
    {
        size_t i;
 
        for (i = 0; i < ARRAY_LEN(nombres); i++)
        {
            int_write_as_bits(nombres[i], fp);
            fputs("\n", fp);
        }
 
        fclose(fp), fp = NULL;
    }
    else
    {
        fprintf(stderr, "Erreur: impossible d'ouvrir le fichier!\n");
        ret = EXIT_FAILURE;
    }
 
    return ret;
}

Ce qui me donne le résultat suivant:

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
 
11111111111111111111111111111111
11111111111111111111111111111110
10000000000000000000000000000000
0
1111111111111111111111111111111
1
10
11
100
11111111
100000000
100000001
100000000
1000000000
1000000001
10000000000

[Sve@r]

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
unsigned int n = nb;
        ...
            /* On s'assure que n gere les representations negatives en complement
               a deux. */
            n = -1 * nb;
            n = -1 * n;

Là je ne pige absolument pas ce que ça va faire...???

[Thierry Chappuis]

Là je ne pige absolument pas ce que ça va faire...???

Si n est un entier de type unsigned int, la représentation binaire de n est assurée d'être équivalente à ~n + 1. Ainsi, sur le plan bianire, 1 * n est assuré d'être le complément à deux de n.

Sur les architectures où les entiers négatifs sont représentés en complément à deux, n et nb ont la même représentation. En revanche, sur les autres architectures, on force ainsi la représentation en complément à 2.

J'aurais pu écrire:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
if (nb < 0)
{
    n = -1 * nb;
    n = ~N + 1;
}

qui est équivalent.

Thierry

[Darksnakes]

en fait je suis sur un projet de compression si ça peut aider a comprendre ce que je demande. j'ai donc besoin d'écrire ces nombre qui represente un code dans un fichier, mais pour que le fichier compressé soit plus petit, j'ai besoin d'ecrire bit a bit dans le fichier, et donc j'avais besoin d'une fonction qui me dise sur combien de bit ce nombre va etre écrit (sachant qu'on ne peut ecrire que par des octet)