Opérations sur les bits.

Manipulation au bit près

operators ~ ^ & | << >>

Voir version :

Pas de dépendances

Télécharger :

#include <stdio.h>

void printbin(unsigned char n)
{
    int i;
    for(i=sizeof(unsigned char)*8-1;i>=0;i--)
        printf("%d",((n>>i)&1));
    printf("\n");
}

int main()
{
    unsigned char n=1;
    printbin(n);
    n=n<<3;
    printbin(n);
    n=n>>1;
    printbin(n);
    n=~n;
    printbin(n);
    n=n&7;
    printbin(n);
    n=n^7;
    printbin(n);
    n=n|133;
    printbin(n);
    return 0;
}




Commentaires


  Ce tutorial est pour ceux qui sont habitués au binaire.
  Si vous ne savez pas exactement comment ça marche, vous risquez d'etre largué.

  Dans un octet, il y a 8 bits.
  En général, on utilise une variable comme un nombre entier.
  Ce tutorial permet de placer des bits la ou on veut dans un octet : manipulation au niveau du bit.

  Utiliser ce genre d'opérateurs est fait pour optimiser la mémoire, et/ou la vitesse, ainsi que 
  dans les algorithmes de compression.
  Donc cela s'adresse déja a des programmeurs confirmés.

  La fonction printbin écrit n en binaire. En lisant la suite, vous pourrez la décortiquer a votre 
  aise.

  Mais l'essentiel est dans le main.

  je définis n=1
  en binaire, sous 8 bits, ça s'écrit :

   00000001

Les opérateurs << et >>
***********************

  J'utilise ensuite l'opétateur <<  (appelé aussi SHL = SHIFT LEFT)
  qui sert a décaler tous les bits a gauche !!
  avec 3, ça donne un décalage de 3 cases pour tout le monde a gauche :

   00001000
       <---    

  La meme chose avec l'opérateur >> (appelé aussi SHR = SHIFT RIGHT)
  avec 1 ici :

   00000100
       ->   

  Note : les bits qui sortent a gauche ou a droite sont perdus. Les nouveaux bits apparus sont des 0.

  Note : les opérateurs ROL et ROR qui permettent d'éviter cela par une Rotation ciruclaire des bits
  ne sont pas définis comme natifs en C ou en C++.
  Cela dit, rien n'empeche de passer en assembleur inline pour cela :

   int n=1;
   _asm
   {
     MOV AX,n
     ROR n,3
     MOV n,AX
   }

  Astuce : 
  Multiplier par 2 revient a décaler les bits a gauche une fois.
  Diviser par 2 revient a décaler les bits a droite une fois.

  donc :
   a=n*2(puissance)i; <=> a= n << i;

L'opérateur ~
*************

  L'opérateur NOT bit a bit :

  Change tous les bits :

  On avait

   00000100

  donc on trouve :

   11111011

L'opérateur &
*************

  L'opérateur AND (ou ET bit a bit)

  Compare 2 nombres bit par bit, et met un 1 UNIQUEMENT si les 2 sont a 1. 0 sinon.

   7 = 00000111
   n = 11111011
   ------------
   & = 00000011


L'opérateur ^
*************

  L'opérateur XOR (OU EXCLUSIF)

  Compare 2 nombres bit par bit, et met un 1 si l'un OU l'autre est a 1. Mais PAS les 2.

   7 = 00000111
   n = 00000011
   ------------
   ^ = 00000100

L'opérateur |
*************

  L'opérateur OR (OU INCLUSIF)

  Compare 2 nombres bit par bit, et met un 1 si l'un OU l'autre ou les 2 est a 1.

 133 = 10000101
   n = 00000100
   ------------
   | = 10000101


  Note : Tous ces opérateurs sont des opérateurs de tres bas niveau : c'est a dire que c'est quelque chose
  de tres tres rapide pour un ordinateur. Ce sont les opérateurs les plus rapides.


Laissez un commentaire / post a comment