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
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
| #include <stdio.h>
#include <stdlib.h>
#include <limits.h>
#include <ctype.h>
static int uint_to_binary_repr(char *s_buffer, size_t buffsize, unsigned int number, size_t nbits);
unsigned int binary_repr_to_uint(char const *s_buffer, char const **endptr);
int main(void)
{
char s_buffer[33];
char s_buffer2[33];
unsigned int number, number2, result;
/* Manupulations de bits */
printf("Manipulations de bits --------------------------\n\n");
uint_to_binary_repr(s_buffer, sizeof s_buffer, 1, 0);
printf("La représentation binaire de 1 est: %s\n", s_buffer);
number = binary_repr_to_uint(s_buffer, NULL);
uint_to_binary_repr(s_buffer, sizeof s_buffer, ~number + 1, 0);
printf("Son complément à 2 est: %s\n\n", s_buffer);
/* Manupulations de bits */
printf("Addition de nombres ----------------------------\n\n");
uint_to_binary_repr(s_buffer, sizeof s_buffer, 1, 0);
uint_to_binary_repr(s_buffer2, sizeof s_buffer2, 2, 0);
number = binary_repr_to_uint(s_buffer, NULL);
number2 = binary_repr_to_uint(s_buffer2, NULL);
uint_to_binary_repr(s_buffer, sizeof s_buffer, number + number2, 0);
result = binary_repr_to_uint(s_buffer, NULL);
printf("%u + %u = %u\n", number, number2, result);
return EXIT_SUCCESS;
}
/**
* Fournit la représentation binaire d'un entier non signé de type int unsigned
* int.
*
* @param s_buffer tampon dans lequelle est placé la représentation binaire
* sous la forme d'une chaîne de caractères.
* @param buffsize taille du tampon
* @param number entier non signé à représenter sous forme binaire
* @param nbits nombre de bits utilisés par la représentation. Si nbits est
* inférieur au nombre de bits nécessaires, le nombre minimal de
* bits nécessaires est utilisé. nbits est majoré par le nombre de
* bits utilisés pour représenter un entier de type int.
*
* @return code d'erreur valant -1 si la taille du tampon fourni est
* insuffisante, et 0 sinon
*/
int uint_to_binary_repr(char *s_buffer, size_t buffsize, unsigned int number, size_t nbits)
{
int err = 0;
size_t i;
unsigned int n = number;
const size_t MAX_BITS = sizeof number * CHAR_BIT;
size_t MIN_BITS = 0;
/* Calcul du nombre minimal de bits nécessaires pour représenter
l'entier considéré */
do
{
n /= 2;
MIN_BITS++;
}
while (n > 0u);
nbits = (nbits > MAX_BITS) ? MAX_BITS :
(nbits < MIN_BITS) ? MIN_BITS : nbits;
if (buffsize > nbits)
{
s_buffer[nbits] = 0;
for (i = 0; i < nbits; ++i)
{
s_buffer[nbits-(i+1)] = (number & (1 << i)) ? '1' : '0';
}
}
else
{
err = -1;
}
return err;
}
/**
* Converti la représentation binaire d'un nombre en un nombre non-signé de
* type unsigned int. La fonction analyse au plus sizeof(unsigned int) * CHAR_BIT
* bits à partir du bit de poids fort (MSB). Les espaces (caractères
* reconnus comme tels par isspace()) de tête sont ignorés, et la lecture
* s'arrête à la rencontre du 1er caractère invalide.
*
* @param s_buffer tampon dans lequelle se trouve la représentation binaire à
* convertir en unsigned int
* @param endptr si endptr n'est pas NULL, l'adresse du 1er caractère invalide
* est placée dans *endptr. Si aucun catactère n'est valide,
* l'adresse de s_buffer est placée dans *endptr.
*
* @return entier non-signé correspondant à la représentation bianire fournie.
* Si la valeur 0 est retournée alors que *endptr pointe sur s_buffer,
* aucun caractère n'a été lu.
*/
unsigned int binary_repr_to_uint(char const *s_buffer, char const **endptr)
{
unsigned int number = 0;
char const *pc;
size_t nbits = 0;
if (s_buffer != NULL)
{
/* On ignore les espaces de tête */
for (pc = s_buffer; isspace(*pc); pc++)
{
continue;
}
while (nbits < sizeof number * CHAR_BIT && (*pc == '1' || *pc == '0'))
{
number = number * 2 + (*pc - '0');
nbits++;
pc++;
}
if (endptr != NULL)
{
*endptr = (nbits >= 1u) ? pc : s_buffer;
}
}
return number;
} |
