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; }
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.
