1. Les opérateurs arythmétiques

Tout d’abord les quatre opérations bien connues :

• L’addition : le signe ’+’

  il est donc possible dans le programme C suivant ( test_plus.c ) de faire :

  #include <stdio.h> int main() { int a = 3; int b = 7; int c = 0; printf("a=%d | b=%d |c=%d\n", a, b, c ); c = a+b; printf("a=%d | b=%d |c=%d\n", a, b, c ); // c est maintenant egal a 10 ( 3+7 ) a = a+c; printf("a=%d | b=%d |c=%d\n", a, b, c ); // a est maintenant egal a 13 ( 10+3 ) b= 3+50; printf("a=%d | b=%d |c=%d\n", a, b, c ); // b est maintenant egal a 53 ( 3+50 ) return(1); }
• La soustraction : le signe ’-’

  il est donc possible dans le programme C suivant ( test_moins.c ) de faire :

  #include <stdio.h> int main() { int a = 3; int b = 7; int c = 13; printf("a=%d | b=%d |c=%d\n", a, b, c ); b = c-a; printf("a=%d | b=%d |c=%d\n", a, b, c ); // b est maintenant egal a 10 ( 13-3 ) a = c-2; printf("a=%d | b=%d |c=%d\n", a, b, c ); // a est maintenant egal a 8 ( 10-2 ) c= 140-22; printf("a=%d | b=%d |c=%d\n", a, b, c ); // c est maintenant egal a 118 return(1); }
• La multiplication : le signe ’*’

  il est donc possible dans le programme C suivant ( test_x.c ) de faire :

  #include <stdio.h> int main() { int a = 3; int b = 7; int c = 0; printf("a=%d | b=%d |c=%d\n", a, b, c ); c = a*b; printf("a=%d | b=%d |c=%d\n", a, b, c ); // c est maintenant egal a 21 ( 3*7 ) a = c*2; printf("a=%d | b=%d |c=%d\n", a, b, c ); // a est maintenant egal a 42 ( 21*2 ) b= 3*4; printf("a=%d | b=%d |c=%d\n", a, b, c ); // b est maintenant egal a 12 return(1); }
• La division : le signe ’/’

  il est donc possible dans le programme C suivant ( test_div.c ) de faire :

  #include <stdio.h> int main() { int a = 30; int b = 0; int c = 2; printf("a=%d | b=%d |c=%d\n", a, b, c ); b = a/c; printf("a=%d | b=%d |c=%d\n", a, b, c ); // b est maintenant egal a 15 ( 30/2 ) c = b/5; printf("a=%d | b=%d |c=%d\n", a, b, c ); // c est maintenant egal a 3 ( 15/5 ) a= 300/50; printf("a=%d | b=%d |c=%d\n", a, b, c ); // a est maintenant egal a 6 return(1); }

  Ensuite, un opérateur moins connu mais très utile, qui va nous permettre de connaître le reste d’une division entre deux entiers.

• Le modulo : le signe ’%’

  il est donc possible dans le programme C suivant ( test_mod.c ) de faire :

  #include <stdio.h> int main() { int a = 30; int b = 7; int c = 73; printf("a=%d | b=%d |c=%d\n", a, b, c ); b = a%b; printf("a=%d | b=%d |c=%d\n", a, b, c ); // b est maintenant egal a 2 ( 30/7=4 RESTE=2 ) c = c%7; printf("a=%d | b=%d |c=%d\n", a, b, c ); // c est maintenant egal a 3 ( 73/7 = 10 RESTE 3 ) a= 299%29; printf("a=%d | b=%d |c=%d\n", a, b, c ); // a est maintenant egal a 9 ( 299/29 = 10 RESTE 9 ) return(1); }

2. Les opérateurs et expressions d’affectation de variables

• L’affectation simple : le signe ’=’

  il est donc possible dans le programme C suivant ( test_affect.c )de faire :

  #include <stdio.h> int main() { int a = 3; int b = 7; int c = 0; char caractere_saisi ='\0'; printf("a=%d | b=%d |c=%d\n", a, b, c ); c = a+b; printf("a=%d | b=%d |c=%d\n", a, b, c ); // c est maintenant egal a 10 ( 3+7 ) a = a+c; printf("a=%d | b=%d |c=%d\n", a, b, c ); // a est maintenant egal a 13 ( 10+3 ) b= 3+9; printf("a=%d | b=%d |c=%d\n", a, b, c ); // b est maintenant egal a 12 printf("saisissez un caractere SVP\n"); caractere_saisi = getchar(); printf("caractere_saisi = %c\n", caractere_saisi ); return(1); }
• L’affectation avec incrémentation : le signe ’=’ precede d’un autre opérateur

  il est donc possible dans le programme C suivant ( test_incr.c ) de faire :

  #include <stdio.h> int main() { int a = 3; int b = 7; int c = 10; printf("a=%d | b=%d |c=%d\n", a, b, c ); c += 2; // equivalent a c = c+2 printf("a=%d | b=%d |c=%d\n", a, b, c ); // c est maintenant egal a 12 ( 10+2 ) a -= 3; // equivalent a a = a-3 printf("a=%d | b=%d |c=%d\n", a, b, c ); // a est maintenant egal a 9 ( 12-3 ) b *= 2; // equivalent a b = b * 2 printf("a=%d | b=%d |c=%d\n", a, b, c ); // b est maintenant egal a 14 ( 7*2 ) c /= 3; // equivalent a c = c/3 printf("a=%d | b=%d |c=%d\n", a, b, c ); // c est maintenant egal a 4 ( 12/3 ) return(1); }

  Ce ’mélange des opérateurs’ peut aussi s’appliquer aux opérateurs de manipulation de bits

3. Les opérateurs de comparaison

• La comparaison d’égalité : le signe ’==’

  Cet opérateur va nous permettre de tester si deux variables sont égales. il est donc possible dans le programme C suivant ( test_egal.c ) de faire :

  #include <stdio.h> int main() { int a = 3; int b = 7; int c = 3; printf("a=%d | b=%d |c=%d\n", a, b, c ); if ( a == c ) // ceci est vrai ( a est egal a c ) { printf(" a est egal a c\n"); }; if ( a == 3 ) // ceci est vrai ( a est egal a c ) { printf(" a est egal a 3\n"); }; if ( a == b ) // ceci est faux { printf(" a est egal a b\n"); } else { printf("a n est pas egal a b\n"); } if ( a == 20 ) // ceci est faux { printf(" a est egal a 20\n"); } else { printf(" a n est pas egal a 20\n"); } return(1); }
• La comparaison de différence : l’opérateur ’ !=’

  Cet opérateur va nous permettre de savoir si deux variables sont différentes. il est donc possible dans le programme C suivant ( test_diff.c ) de faire :

  #include <stdio.h> int main() { int a = 3; int c = 10; printf("a=%d | c=%d\n", a, c ); if ( a != c ) // ceci est vrai ( a est different a c ) { printf(" a est different de c\n"); }; if ( a != 3 ) // ceci est faux ( a n'est pas different de 3 ) { printf(" a est different de 3\n"); } else { printf(" a n'est pas different de 3, donc a = 3\n"); } return(1); }
• La comparaison d’infériorité : les opérateurs ’<’ et ’<=’

  Ces opérateurs va nous permettre de savoir, respectivement, si une variable est ’inférieure’(<) ou ’inférieure ou égale’(<=) à une autre. il est donc possible dans le programme C suivant ( test_inf.c ) de faire :

  #include <stdio.h> int main() { int a = 3; int b = 10; int c = 10; if ( a <= c ) // ceci est vrai ( a est inferieur ou egal a c ) { printf(" a est inferieur ou egal a c\n"); }; if ( b < c ) // ceci est faux ( b n'est pas inferieur a c ) { printf(" b est inferieur a c\n"); }; if ( a <= 3 ) // ceci est vrai ( a est inferieur ou egal a 3 ) { printf(" a est inferieur ou egal a 3\n"); }; if ( b < 10 ) // ceci est faux ( b n'est pas inferieur a 10 ) { printf(" b est inferieur a 10\n"); }; return(1); }
• La comparaison de supériorité : les opérateurs ’>’ et ’>=’

  Ces opérateurs va nous permettre de savoir, respectivement, si une variable est ’supérieure’(>) ou ’supérieure ou égale’(>=) à une autre. il est donc possible dans le programme C suivant ( test_sup.c ) de faire :

  #include <stdio.h> int main() { int a = 3; int b = 10; int c = 10; printf("a=%d | b=%d |c=%d\n", a, b, c ); if ( b >= c ) // ceci est vrai ( b est superieur ou egal a c ) { printf(" b est superieur ou egal a c\n"); } if ( b > c ) // ceci est faux ( b n'est pas superieur a c ) { printf(" b est superieur a c\n"); } else { printf(" b n'est pas superieur a c\n"); } if ( a >= 3 ) // ceci est vrai ( a est superieur ou egal a 3 ) { printf(" a est superieur ou egal a 3\n"); } if ( b > 10 ) // ceci est faux ( b n'est pas superieur a 10 ) { printf(" b est superieur a 10\n"); } else { printf(" b n'est pas superieur a 10\n"); } return(1); }

4. Les opérateurs d’incrémentation/décrémentation

Ici, rien de bien sorcier, seulement deux opérateurs ( ++ et — ) :

• L’opérateur ’++’

  Cet opérateur sert a incrémenter ( ajouter 1 a une variable ). il est donc possible dans le programme C suivant ( test_incr2.c ) de faire :

  #include <stdio.h> int main() { int a = 3; printf("a=%d\n", a ); a++; // Maintenant a est egal a 4 printf("a=%d\n", a ); a=a+1; // Fait la meme chose que a++ ( incremente de 1 ) // Maintenant, a est egal a 5 printf("a=%d\n", a ); return(1); }
• L’opérateur ’—’

  Cet opérateur sert a décrémenter ( enlever 1 a une variable ). il est donc possible dans le programme C suivant ( test_decr.c ) de faire :

  #include <stdio.h> int main() { int a = 10; printf("a=%d\n", a ); a--; // Maintenant a est egal a 9 printf("a=%d\n", a ); a=a-1; // Fait la meme chose que a++ ( incremente de 1 ) // Maintenant, a est egal a 8 printf("a=%d\n", a ); return(1); }

5. Les opérateurs de manipulation des bits

Attention, là, ça se corse carrément, personne ne vous en voudra de passer a la suite et de revenir ici plus tard :

Les opérateurs logiques : ’&’, ’|’, ’ ’ et ’^’

Ces opérateurs servent à manipuler les bits qui composent une variable. Les types de variables auxquels ces opérateurs s’appliquent sont :

• int : Les entiers
• long int : Les entiers longs
• unsigned int : Les entiers non signés ( supérieurs a 0 )
• char : un caractère
• unsigned char : un caractère aussi

ATTENTION, ces opérateurs ne s’appliquent pas aux types float, double ( chiffres réels avec virgule ).

• Le et binaire : l’opérateur ’&’

  Cet opérateur sert a ne garder que les bits qui se trouvent dans les deux variables auxquelles s’applique le et binaire. il est donc possible dans le programme C suivant ( test_et.c ) de faire :

  #include <stdio.h> int main() { int a = 40; // en binaire, cela donne 00000000000000000000000000101000 int b = 0; int c = 0; int masque=8; // en binaire, cela donne 00000000000000000000000000001000 printf("a = %d\n", a); b=a&masque; // Permets d'eliminer tous les bits qui ne sont pas dans le masque // b est donc egal a 8, c'est a dire en binaire 00000000000000000000000000001000 // car le bit qui signifie 32 ( le 6eme en partant de la droite ) a ete elimine // ( il ne faisait pas partie du masque ) printf("b = %d\n", b); a=64; // en binaire, cela donne 00000000000000000000000001000000 printf("a = %d\n", a); b=a&masque; printf("b = %d\n", b); // Permets d'eliminer tous les bits qui ne sont pas dans le masque // b est donc egal a 0, cest a dire en binaire 00000000000000000000000000000000 // car le bit qui signifie 64 ( le 7eme en partant de la droite ) a ete elimine // ( il ne faisait pas partie du masque ) return(1); }
• Le ou binaire : l’opérateur ’|’

  Cet opérateur sert a ajouter certains bits a une variable. il est donc possible dans le programme C suivant ( test_ou.c ) de faire :

  #include <stdio.h> int main() { int a = 8; // en binaire, cela donne 00000000000000000000000000001000 int bits_a_ajouter = 32; // en binaire, cela donne 00000000000000000000000000100000 int c=0; printf("a = %d\n", a ); c= a|bits_a_ajouter; // On melange les bits des deux varaibles printf("c = %d\n", c ); // c est dorenavant egal a 40 car le bit demande a ete ajoute a ceux de a // cela donne en binaire : 00000000000000000000000000101000 return(1); }
• Le ou EXCLUSIF binaire : l’opérateur ’^’

  Cet opérateur sert a enlever certains bits a une variable. La règle est la suivante : Si les deux bits de même rang sont a 0, le resultat sera a 0. Si les deux bits de même rang sont différents, le resulta sera a 1. Si les deux bits de même rang sont a 1 le resultat sera a 0

  Pour résumer, seuls les bits de même rang qui sont différents, seront a 1, et tous les autres seront a 0.

  il est donc possible dans le programme C suivant ( test_ou_ex.c ) de faire :

  #include <stdio.h> int main() { char a = 24; // en binaire, cela donne 00011000 char masque = 48; // en binaire, cela donne 00110000 int c=0; printf("a = %d\n", a ); printf("masque = %d\n", masque ); c= a^masque; // On melange exclusivement les bits des deux varaibles printf("c = %d\n", c ); // c est dorenavant egal a // cela donne en binaire : 00101000 return(1); }
• Le complément a un unaire : l’opérateur ’ ’

  Cet opérateur sert a inverser chacun des bits de la variable.

  Chaque bit a 0 sera mis a 1

  Chaque bit a 1 sera mis a 0

  il est donc possible dans le programme C suivant ( test_compl1.c ) de faire :

  #include <stdio.h> int main() { unsigned char a = 2; // en binaire, cela donne 00000010 unsigned char b = 0; printf("a = %d\n", a ); b=~a; // On permute tous les bits // b est donc egal a 253 // c'est a dire en binaire : 11111101 // car chaque bit qui etait a 0 est maintenant a 1 // et chaque bit qui etait a 1 est maintenant a 0 printf("b = %d\n", b ); return(1); } <cadre> </li></ul> <h3> Les opérateurs de décalage de bits : '<<' et '>>' </h3> Ces opérateurs servent à décaler les bits qui composent une variable. <ul><li> Le décalage a gauche : l'opérateur '<<' On peut decaler a gauche tous les bits d'une variable comme dans le programme C suivant ( test_decal_gauche.c ) de faire : <cadre> #include <stdio.h> int main() { unsigned char a = 6; // en binaire, cela donne 00000110 unsigned char b = 0; printf("a = %d\n", a ); // On decale tous les bits d'une position vers la gauche b=a<<1; // Apres decalage a gauche ( d'une position ) // de tous les bits de a, b est egal a 12 // c'est a dire en binaire : 00001100 printf("b = %d\n", b ); // On peut aussi tout decaler de deux positions vers la gauche b=a<<2; // Apres decalage a gauche ( de deux positions ) // de tous les bits de a, b est egal a 24 // c'est a dire en binaire : 00011000 printf("b = %d\n", b ); return(1); }
• Le décalage a droite : l’opérateur ’>>’

  On peut decaler a droite tous les bits d’une variable comme dans le programme C suivant ( test_decal_droite.c ) de faire :

  #include <stdio.h> int main() { unsigned char a = 48; // en binaire, cela donne 00110000 unsigned char b = 0; printf("a = %d\n", a ); // On decale tous les bits d'une position vers la droite b=a>>1; // Apres decalage a droite ( d'une position ) // de tous les bits de a, b est egal a 24 // c'est a dire en binaire : 00011000 printf("b = %d\n", b ); // On peut aussi tout decaler de deux positions vers la droite b=b>>2; // Apres decalage a droite ( de deux positions ) // de tous les bits de b, b est egal a 6 // c'est a dire en binaire : 00000110 printf("b = %d\n", b ); return(1); }

Comme vous pouvez le constater :

• Décaler d’une position a gauche équivaut à multiplier par deux
• Décaler de deux positions a gauche équivaut à multiplier par quatre
• Décaler de n positions a gauche équivaut à multiplier par ( n exposant 2)
• Décaler d’une position a droite équivaut à diviser par 2
• Décaler de deux positions a droite équivaut à diviser par 4
• Décaler de n positions a droite équivaut à diviser par ( n exposant 2)
• Les bits qui sortent du champ ( la taille de la variable ), sont irrémédiablement perdus.
• Dans le cas du décalage a gauche, les nouveaux bits qui apparaissent a gauche sont initialisés avec des zéros.
• Dans le cas du décalage a droite, les nouveaux bits qui apparaissent a droite sont initialisés avec des zéros.