Algorithme
Méthodes d'opérations sur 8 bits
Objectif : On souhaite écrire une application C# de manipulation interne des bits d'une variable entière non signée sur 8 bits. L'application contiendra 9 méthodes :
 
 

Spécifications des méthodes :
 

1. Une méthode BitSET permettant de mettre à 1 un bit de rang fixé.
2. Une méthode BitCLR permettant de mettre à 0 un bit de rang fixé.
3. Une méthode BitCHG permettant de remplacer un bit de rang fixé par son complément.
4. Une méthode SetValBit permettant de modifier un bit de rang fixé.
5. Une méthode DecalageD permettant de décaler les bits d'un entier, sur la droite de n positions (introduction de n zéros à gauche). 
6. Une méthode DecalageG permettant de décaler les bits d'un entier, sur la gauche de n positions (introduction de n zéros à droite).
7. Une méthode BitRang renvoyant le bit de rang fixé d'une entier.
8. Une méthode ROL permettant de décaler avec rotation, les bits d'un entier, sur la droite de n positions (réintroduction à gauche).
9. Une méthode ROR permettant de décaler avec rotation, les bits d'un entier, sur la gauche de n positions (réintroduction à droite).

 

Exemples de résultats attendus :

Prenons une variable  X entier (par exemple sur 8 bits)             X = 11100010

1. BitSET (X,3) => X = 11101010
2. BitCLR (X,6) => X = 10100010
3. BitCHG (X,3) => X = 11101010
4. SetValBit(X,3,1) => X = 11101010
5. DecalageD (X,3) => X = 00011100
6. DecalageG (X,3) => X = 00010000
7. BitRang (X,3) = 0 ; BitRang (X,6) = 1 ...
8. ROL (X,3) => X = 00010111
9. ROR (X,3) => X = 01011100
 

Implantation en C#

Lors des jeux de tests, bien se rappeler qu'en C# le type primaire int est un type entier signé sur 32 bits (en représentation en complément à deux)
 

Proposition de squelette de classe C# à implanter :

class Application8Bits {
      static void Main(string[ ] args){
          ……..       }
      static int BitSET (int nbr, int num) {  ……..      }
      static int BitCLR (int nbr, int num) {  ……..      }
      static int BitCHG (int nbr, int num) {  ……..      }
      static int SetValBit (int nbr, int rang, int val) {  ……..      }
      static int DecalageD (int nbr, int n) {  ……..      } 
      static int DecalageG (int nbr, int n) {  ……..     }
      static int BitRang (int nbr, int rang) {  ……..   }
      static int ROL (int nbr, int n) {   ……..    }
      static int ROR (int nbr, int n) {  ……..    }
   }

Afin de visualiser les résultats binaires, on se propose d'utiliser la méthode toBinaryString écrite ci-dessous qui permet de stocker dans une chaîne, la représentation binaire de tout nombre entier positif de type int.

static string toBinaryString ( int n )
{
   string [] hexa = { "0000","0001","0010","0011","0100",
   "0101","0110","0111","1000","1001","1010",
   "1011","1100","1101","1110","1111" };
   string s = string.Format("{0:x}",n), res = "";
   for ( int i = 0; i < s.Length; i++ )
   {   char car=(char)s[i];
        if ((car <= '9')&&(car >= '0'))
           res = res+hexa[(int)car-(int)'0'];
        if ((car <= 'f')&&(car >= 'a'))
           res = res+hexa[(int)car-(int)'a'+10];
   }
   return res;
}

La méthode toBinaryString utilise la méthode de classe Format (méthode de la classe string) :
string.Format("{0:x}" , n) qui renvoie une string convertissant l'entier n en sa représentation hexadécimale.
Cette méthode toBinaryString ainsi construite n'a plus qu'à transformer chaque symbole hexadécimal de n en son équivalent binaire sur 4 bits.

Exemple :

Remonter