Programmation C

Opérateurs :
En C, les opérateurs sont classés selon 15 niveaux de priorité, la plus haute valant 15, et la plus faible, valant 1.

Voyons quelques opérateurs,

Cast :
L'opérateur de transtypage (cast), permet de modifier le type de données que peut receuillir une variable.
Voici la syntaxe :
NomVar = (type) NomVar; // type correspond au nouveau type (int, float, etc.)

Voici un exemple concret :

int x;
x = (double) 3/2;
printf("%d",x); // imprime la valeur à virgule flottante : 1.5.

Sans transtypage, la valeur affichée serait 1. En effet, cela ne renvoi pas une erreur, mais la partie décimale est simplement ignorée en cas d'un type entier.

sizeof() :
cet opérateur calcule l'occupation mémoire en octets d'une variable. Voici la syntaxe de cet opérateur :

short a;
long b;
double c;

printf("%i, %i, %i",sizeof(a), sizeof(b), sizeof(c));

ceci affiche a l'écran : 2, 4, 8, car les variables occupent respectivement ces occupations mémoires.

L'opérateur d'adressage & :
Les variables possèdent une adresse mémoire unique. La donnée contenue dans une variable se trouve à l'adresse mémoire de celle-ci.

int x;
x = 560;
printf("%i",x); // Affiche la valeur numérique 560
printf("%i",&x); // Affiche l'adresse mémoire de la variable x.

Opérateurs de bits

Dans ce cas, nous travaillons sur chaque bit individuellement, et ceci exige des opérandes entiers.

ET binaire :
Le ET ( & ) binaire renvoi 1 si les 2 bits sont positionnés ( 1 ), sinon, 0.

OU binaire :
Le OU binaire ( | ) renvoi 1 si l'un des 2 bits sont positionnés, sinon 0.
Le OU binaire ( ^ ) renvoi 1 uniquement si l'un des 2 bits est positionnés, sinon 0.

NON binaire :
Le non binaire ( ~ ) est le complément à 1 de la variable.
Il renvoi 1 si le bits n'est pas positionné ( 0 )
Et renvoi 0 si le bit est positionné ( 1 ).

Voici un tableau qui illustre ce qui vient d'être dit, on considère dans chaque cas, BIT 1 et BIT 2, puis, nous constatons :

Opérateurs de décalage >> et << :
L'opérateur << décale vers la gauche tous les bits de l'opérande gauche, d'un nombre de positions correspondant à la valeur de l'opérande droit. Les positions binaires laissées libres sur la droite sont mises à 0.
Exemple, la constante décimale 15, de type int :
15 << 4, ce qui donne au niveau binaire :
0000000000001111 << 4, ce qui donne le résultat : 0000000011110000 ( qui est le nombre 240 ).

Notez simplement, qu'un décalage de N positions vers la gauche correspond à une multiplication par 2^N.

Il en va de même pour un décalage vers la droite ( >> ), et la règle que l'on tire est la suivante :
un décalage de N positions vers la droite correspond à une division par 2^N.