/******************* manipbits.cpp *****************/
#include <iostream>
#include <ctype.h>
using namespace std;
const int tailleint = 8 * sizeof(int); // variable contenant la taille (en bits) d'un nombre entier
void aff_bits( int n ); // affiche la representation binaire de "n"
int inverse( int x, int p, int n ); // complmente les n bits de x partir du bit la position p
int rot_droite( int n, int b ); // permutation circulaire vers la droite de b bits d'un entier n
#ifdef _WIN32
void soulign_bit( int p, int nb ); //souligne les bits modifiés lors de l'inversion ( uniquement sous windows)
#endif
/*************************************/
/****** fonction principale **********/
/*************************************/
int main()
{
int entier, nbinv, pos, nbrot, choix;
bool vrf;
char rep;
cout << "\t********************************************************" << endl;
cout << "\t**************** Manipulation de bits ******************" << endl;
cout << "\t********************************************************" << endl << endl;
do
{
do
{
vrf = true;
cout << "Entrez un nombre entier dont on manipulera la representation binaire:";
if ( ! ( cin >> entier ) ) vrf = false;
cin.clear();
cin.ignore( 80, '\n' );
}while ( ! vrf );
cout << "Choisissez l' operation que vous voulez realiser sur ces bits:" << endl;
cout << "1/ Affichage de la representation binaire de n" << endl;
cout << "2/ Inversion de bits" << endl;
cout << "3/ Rotation des bits (vers la droite)" << endl;
cout << "4/ Fin du programme" << endl;
do
{
vrf = true;
cout << "Veuillez entrer l'option que vous souhaiter:";
if ( ! ( cin >> choix ) || choix < 1 || choix > 4 ) vrf = false;
cin.clear();
cin.ignore( 80, '\n' );
}while ( ! vrf );
if ( choix == 1 )
{
cout << "Voici la representation binaire du nombre n:" << endl;
aff_bits( entier );
} else if ( choix == 2 )
{
cout << "Nous allons maintenant inverser un certain nombre de ces bits" << endl;
do
{
vrf = true;
cout << "Entrez le nombre de bits a inverser ( entre 1 et " << tailleint << " ):";
if ( ! ( cin >> nbinv ) || nbinv > tailleint || nbinv < 1 ) vrf = false;
cin.clear();
cin.ignore( 80, '\n' );
}while ( ! vrf );
do
{
vrf = true;
cout << "Entrez la position a partir de laquelle inverser ces bits ( entre " << nbinv << " et " << tailleint << " ):";
if ( ! ( cin >> pos ) || pos < nbinv || pos > tailleint ) vrf = false;
cin.clear();
cin.ignore( 80, '\n' );
}while ( ! vrf );
cout << "Voici la representation binaire du nombre n avant inversion:" << endl;
aff_bits( entier );
cout << endl;
cout << "Voici la nouvelle representation binaire apres inversion des " << nbinv << " bits." << endl;
aff_bits( inverse( entier, pos, nbinv ) );
#ifdef _WIN32
soulign_bit( pos, nbinv );
#endif
cout << endl;
} else if ( choix == 3 )
{
cout << "Nous allons effectuer des rotations de ces bits vers la droite" << endl;
do
{
vrf = true;
cout << "Entrer le nombre de rotations a effectuer ( > 0 ):";
if ( ! ( cin >> nbrot ) || nbrot < 1 ) vrf = false;
cin.clear();
cin.ignore( 80, '\n' );
}while ( ! vrf );
cout << "Voici la representation binaire du nombre n avant rotation des bits:" << endl;
aff_bits( entier );
cout << endl;
cout << "Voivi la nouvelle representation binaire apres " << nbrot << " rotations vers la droite." << endl;
aff_bits( rot_droite( entier, nbrot ) );
} else if ( choix == 4 )
{
return 0;
}
cout << "Voulez-vous recommencer? (o/n):";
cin >> rep;
cin.ignore( 80, '\n' );
}while ( tolower(rep) == 'o' );
return 0;
}
/*************************************/
/********* fonction aff_bits *********/
/*************************************/
void aff_bits( int n )
{
unsigned int bit;
unsigned int masque = 1;
masque <<= ( tailleint - 1 ); // permet de décaler le bit 1 vers la gauche;
for ( int i = 1; i <= tailleint; i++ )
{
bit = ( n & masque ) >> ( tailleint - 1 ); // l'application de ce masque permet de déterminer la valeur du premier bit de n en mettant tous les autres à zéro
cout << bit << " ";
n <<= 1;
if ( i % 4 == 0) cout << " ";
}
cout << endl;
}
/*************************************/
/********* fonction inverse **********/
/*************************************/
int inverse( int x, int p, int n )
{
unsigned int masque = 1; // masque qui servira à inverser les bits choisis
for ( int i = 1; i < n; i++ ) masque = masque * 2 + 1; // on met les n bits à inverser à 1
x ^= ( masque <<= ( p - n ) ); // on positionne les bits à inverser puis on inverse les bits choisis dans le nombre entier x
return x;
}
/*************************************/
/****** fonction rot_droite **********/
/*************************************/
int rot_droite( int n, int b )
{
unsigned int masque;
b %= tailleint; // avec le reste de la division de b par la taille de l'entier, on peut simuler une rotation de "plusieurs tours"
for ( int i = 0; i < b; i++ )
{
masque = 1;
masque &= n; // on verifie la valeur du dernier bit
masque <<= ( tailleint - 1 ); // on met le premier bit à 1 et on laisse les autres à 0
n >>= 1;
if ( masque == 0 ) n &= ( ~( 1 << ( tailleint - 1 ) ) ); // on met le premier bit de n à 0
else n |= masque; // on met le premier bit de n à 1
}
return n;
}
#ifdef _WIN32
/*************************************/
/****** fonction soulign_bit *********/
/*************************************/
void soulign_bit( int p, int nb )
{
for ( int i = 1; i <= ( tailleint - p + nb ); i++ )
{
if ( i <= ( tailleint - p ) ) cout << " ";
else if( i >= ( tailleint - p ) ) cout << "- ";
if ( ( i % 4 ) == 0 ) cout << " ";
}
cout << endl << endl;
}
#endif