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
140
141
142
143
144
145
146
147
148
149
150
151
152
153
| /*--- Inclusion des headers ---------------------------------------------------------------------------------------------------------------*/
#include <stdio.h>
#include <limits.h> /* pour INT_MIN sur certains compilateurs */
#include <ctype.h> /* nécessaire pour tolower */
/*--- Définition des constantes ------------------------------------------------------------------------------------------------------------*/
#define TAILLEINT 8*sizeof(int) /*Dans le cas d'un compilateur 64 bits, sizeof(int) = 8 */
/*--- Prototypage des fonctions et des procédures (déclarations) ---------------------------------------------------------------------------*/
void aff_bits (int x);
int inverse (int x, int p, int n);
void soulignement (int x,int p,int n);
int rot_droite(int x,int b);
/*--- Définition des fonctions et des procédures --------------------------------------------------------------------------------------------*/
void aff_bits (int x)
/*=============================================================================================================================================
Description : Permet d'afficher un entier signé en binaire sur 32 bits
Entrée : entier x entré par l'utilisateur
=============================================================================================================================================*/
{
int i;
unsigned int masque = INT_MIN; /*le masque est non signé pour que ça affiche un 0 et pas un 1 lors du décalage à droite du masque
On Choisit INT_MIN car ça permet de tester le nombre de gauche à droite, en décalant à chaque fois de 1 */
for (i=0;i<TAILLEINT;i++)
{
printf("%d ",((x&masque)?1:0)); /*On utilise l'opérateur & car s'il y a 1&1 ça retourne 1, 1&0 retourne. Alors que 1|0 et 1^0 retourne aussi 1.*/
masque=(masque >>1);
}
}
int inverse (int x, int p, int n)
/*==============================================================================================================================================
Description : Permet d'inverser les bits sur une zone donnée, on compte p bits à partir de la droite, et on compte n bits vers la droite à partir
de cet indice.
Entrées : entier x entré par l'utilisateur
entier p entré par l'utilisateur
entier n entré par l'utilisateur
Sortie : entier y inversé sur la zone n à partir de p
=======================================================================================================================================================*/
{
int masque=(~(-1<<n))<<(p-n); /*On choisit le nombre -1 car en binaire il n'y a que des 1, on le décale de n bits vers la gauche pour obtenir un masque
avec que des 1 et des 0 sur la droite sur n bits, puis on fait l'inverse de ce masque pour n'obtenir que des 0 et des 1
uniquement sur n bits, puis on décale ce masque sur la gauche de n-p bits. Ainsi on obtient un masque constitué uniquement
de 1 qui correspond pile à la zone à inverser. */
int y = masque ^ x; /*1^0=1 et 1^1=0, ce qui permet d'inverser les bits. */
return(y);
}
void soulignement (int x,int p,int n)
/*=======================================================================================================================================================
Description : permet de souligner la zone du bit à inverser.
Entrées : entier x entré par l'utilisateur
entier p entré par l'utilisateur
entier n entré par l'utilisateur
=========================================================================================================================================================*/
{
int i;
printf("\n");
for (i=1;i<=TAILLEINT-p;i++) printf(" ");
for (i=1;i<=n;i++) printf("--");
printf("\n");
}
int rot_droite(int x,int b)
/*=========================================================================================================================================================
Description : permet d'effectuer une permutation circulaire vers la droite de b bits d'un entier x.
Entrées : entier x entré par l'utilisateur
entier b correspondant au nombre de bits de rotation
Sortie : entier z permuté vers la droite.
===========================================================================================================================================================*/
{
int i;
unsigned int z=x; /* On copie l'entier x dans un entier non signé afin que le décalage vers la droite ne donne pas des 1 dans le cas où il y a un 1 au 32e bit. */
for(i=1;i<=b;i++) z=((z&1)?((z>>1)|INT_MIN):(z>>1)); /* On choisit de tester avec le chiffre 1 car on va tester le bit le plus à droite. S"il s'agit d'un 0, il
suffit juste de décaler sur la droite, et un 0 est ajouté à gauche du nombre, s'il s'agit d'un 1, on applique
| avec INT_MIN car ça va rajouter un 1 sur le bit de poids fort après le décalage. */
return (z);
}
int main()
{
int ok; /* variable qui permet de vérifier qu'on a bien saisi un nombre et non des caractères. */
int x; /* nombre entré par l'utilisateur */
int p; /* Permet de pointer la zone du bit à inverser */
int n; /* Permet d'indiquer le nombre de bits à inverser */
int y; /* entier inversé */
int b; /* nombre de bits qur lesquels on va effectuer la permutation circulaire */
int z; /* entier permuté */
char rep; /* variable de réponse pour recommencer le programme */
printf("\n\t\tM A N I P U L A T I O N D E B I T S\n\t\t-------------------------------------------\n\n");
do
{
do
{
printf("Donnez un entier quelconque : ");
ok = scanf("%d",&x);
while (getchar()!='\n');
} while (!ok);
printf("Voici sa representation en binaire :\n");
aff_bits(x);
printf("\n\n\n");
printf("On va inverser n bits de ce nombre a compter du p eme :\n");
do
{
printf("Donner p ( > 0 et <= %d) : ",TAILLEINT);
ok = scanf("%d",&p);
while (getchar()!='\n');
} while (!ok && p<=0 && p > TAILLEINT);
do
{
printf("Donner n ( > 0 et <= %d) : ",p);
ok = scanf("%d",&n);
while (getchar()!='\n');
} while (!ok && n<=0 && n > p);
y=inverse(x,p,n);
aff_bits(y);
soulignement(x,p,n);
printf("\n\nSur le nombre %d de representation binaire :\n",x);
aff_bits(x);
printf("\nOn va effectuer une permutation circulaire vers la DROITE de b bits.\n");
do
{
printf("Donner b (>0) : ");
ok = scanf("%d",&b);
while (getchar()!='\n');
} while (!ok && b<=0);
z=rot_droite(x,b);
aff_bits(z);
printf("Recommencer ? (o/n) : ");
scanf("%c",&rep);
while (getchar()!='\n');
} while (tolower(rep)!='n');
return 0;
} |
Manipulation de bits
Répondre avec citation
Partager