CyBWarrior

1. Opérateurs arithmétiques
2. Opérateurs d’assignation
3. Opérateurs d’incrémentation / décrémentation
4. Opérateurs logiques
   1. Le non !
   2. Le ou ||
   3. Le et &&
5. Opérateurs binaires
   1. Le non ~
   2. Le ou |
   3. Le et &
   4. Le ou exclusif ^
   5. Le décalage de bits << et >>
6. Opérateurs relationnels

Le opérateurs sont des elements du langage C lui permettant de traiter les données. On y retrouve ainsi des opérateurs
arithmetiques, logiques, binaires, etc…
Si vous connaissez d’autres langages, certains (voir tous) de ces opérateurs vous paraitront familiers.

Opérateurs arithmétiques

Pour réaliser les 4 opérations, le C utilise les opérateurs suivants :

Opérateur	Fonction	Exemple de code	Résultat
+	Addition	printf( »%d », 5 + 5);	10
-	Soustraction	printf( »%d », 25 – 10);	15
*	Multiplication	printf( »%d », 5 * 5);	25
/	Division	printf( »%d », 63 / 7);	9
%	Modulo (reste d’une division)	printf( »%d », 20 % 3);	2

On peut bien sur utiliser ces opérateurs avec des variables :

#include 
int main(){
int a=5;
int b=1;
int c=10;

a = a + b * c;
printf("Resultat : %d", a);/* Sortie -> 15 */
return 0;
}

Opérateurs d’assignation

Vous connaissez déjà un des ces opérateurs : l’opérateur =.
Vous serez peut-être surpris mais il n’est pas tout seul.
Prenons un exemple. Pour ajouter 5 à une variable et enregistrer le résultat de cette opération
dans cette même variable, vous serez certainement tenté d’écrire :

int a=10;

a = a + 5;/* a = 15 */

Ce n’est pas faux et c’est même tout à fait correct.
Mais le C peut faire mieux dans ce cas là avec l’opérateur += qui ajoute les opérandes
de droite à la variable placée à gauche et place le résultat dans cette même variable.
Ainsi, on peut écrire :

int a=10;

a+=5;/* Reviens à écrire a = a + 5 */

Cette possibilité est étendue aux 4 autres opérateurs :

Opérateur	Exemple	Equivalence
+=	a += b;	a = a + b;
-=	a -= b;	a = a – b;
*=	a *= b;	a = a * b;
/=	a /= b;	a = a / b;
%=	a %= b;	a = a % b;

Opérateurs d’incrémentation / décrémentation

Prenons la variable x. Nous voulons lui ajouter 1 et seulement 1.
On peut écrire :

int x=0;

x += 1;/* Reviens à écrire x = x + 1 */

Là aussi le C permet d’aller encore plus vite en écrivant à la place :

int x=0;

x++;/* Reviens à écrire x += 1, ce qui revient à écrire x = x + 1 */

La décrémentation (enlever une unité) se passe de la même façon, mais avec – au lieu de
++ :

int x=0;

x--;/* Reviens à écrire x -= 1, ce qui revient à écrire x = x - 1 */

Attention ! Il convient de distinguer la pré-incrémentation / décrémentation de la
post-incrémentation / décrémentation.
Lors de cette dernière, l’opérateur est placé après la variable, comme dans :

int x=0;

x++;/* Post-incrémentation */

Pour effectuer une pré-incrémentation, on écrira :

int x=0;

++x;/* Pré-incrémentation */

Quel est l’intérêt ?
Voici un exemple :

#include 
int main(){
int a=5;
int b=5;
/*  a et b ont tout les deux pour valeur 5  */

printf("a++ = %d", a++);/* Sortie -> a++ = 5*/
printf("++b = %d", ++b);/* Sortie -> ++b = 6*/
return 0;
}

La voilà la différence :

• Dans le 1^er cas, la variable est incrémentée après avoir renvoyée sa valeur
• Dans le 2^ème, la variable est incrémentée avant d’avoir renvoyée sa valeur

Opérateurs logiques

Les opérateurs logiques permettent d’effectuer des opérations logiques dites booleennes.
Un ordinateur etant un système electrique, il ne comprend que deux états : ouvert (1) ou fermé (0).
C’est sur ces valeurs (1 et 0) que les opérateurs logiques permettent de travailler.
Le C définit une expression comme étant à 1 si celle-ci est différente de 0. Ainsi,
21 sera considéré comme 1.
Ces opérateurs seront très utilisés plus tard, avec les conditions et les boucles.
Il existe 3 opérateurs logiques : le non (!), le et (&&) et le ou (||).

Le non !

Le non effectue une inversion. On utilise le point d’exclamation (!).

Argument	Résultat
0	1
1	0

Exemple :

#include 
int main(){
int variable=32;

printf("%d", !variable);/* Sortie -> 0 */
printf("%d", !!variable);/* Sortie -> 1 */
return 0;
}

Le ou ||

Le ou renvoi 1 si l’une des deux opérandes au moins est à 1.
On utilise l’opérateur ||.

1er argument	2ème argument	Résultat
0	0	0
0	1	1
1	0	1
1	1	1

Exemple :

#include 
int main(){
printf("%d", 0 || 0);/* Sortie -> 0 */
printf("%d", 0 || 20);/* Sortie -> 1 */
printf("%d", 20 || 30);/* Sortie -> 1 */
return 0;
}

Le et &&

Le et renvoi 1 si les des deux opérandes sont à 1.
On utilise l’opérateur &&.

1er argument	2ème argument	Résultat
0	0	0
0	1	0
1	0	0
1	1	1

Exemple :

#include 
int main(){
printf("%d", 0 && 0);/* Sortie -> 0 */
printf("%d", 0 && 12);/* Sortie -> 0 */
printf("%d", 78 && 0);/* Sortie -> 0 */
printf("%d", 42 && 9);/* Sortie -> 1 */
return 0;
}

Opérateurs binaires

Pour bien comprendre à quoi servent les opérateurs binaires, vous devez tout d’abord savoir qu’est
ce que le binaire. C’est pourquoi je vous invite à lire ceci : La numération.
Ensuite, ce qui suit deviendra compréhensible

Le non ~

Le non ne permet non pas d’inverser tout les bits d’un nombre, mais d’effectuer le complément
à deux de ce nombre. On utilise l’opérateur ~ :

#include 
int main(){
int nombre=3;/* 11 en binaire */

nombre = ~ nombre;
printf("%d", nombre);/* Sortie -> -4 */
}

Le ou |

Le ou effectue un ou (!) entre chaques bits des deux opérandes. On utilise l’opérateur
| :

#include 
int main(){
int a=2;/* 2 -> 10 en binaire */
int b=1;/* 1 -> 01 en binaire */
int resultat=a | b;
/*1 | 0 -> 1
0 | 1 -> 1
resultat = 11 = 3*/
printf("%d", resultat);/* Sortie -> 3*/
return 0;
}

Le et &

Comme le ou, le et effectue un et entre chaques bits des deux opérandes. On utilise l’opérateur
& :

#include 
int main(){
int a=255;/* 255 -> 11111111 en binaire*/
int b=170;/* 170 -> 10101010 en binaire*/
int resultat=a & b;
/*1 & 1 -> 1
1 & 0 -> 0
1 & 1 -> 1
1 & 0 -> 0
1 & 1 -> 1
1 & 0 -> 0
1 & 1 -> 1
1 & 0 -> 0
resultat = 10101010 = 170*/
printf("%d", resultat);/* Sortie -> 170 */
return 0;
}

Le ou exclusif ^

Le ou exclusif effectue un ou exclusif (en l’aurait deviné ) entre les bits des deux opérandes. On
utilise l’opérateur ^ :

#include 
int main(){
int a=255;/* 255 -> 11111111 en binaire*/
int resultat = a ^ a;
/*1 ^ 1 -> 0
1 ^ 1 -> 0
1 ^ 1 -> 0
1 ^ 1 -> 0
1 ^ 1 -> 0
1 ^ 1 -> 0
1 ^ 1 -> 0
1 ^ 1 -> 0
resultat = 00000000 = 0*/
printf("%d", resultat);/* Sortie -> 0 */
return 0;
}

Le décalage de bits << et >>

On peut facilement décaler les bits d’un nombre vers la gauche ou la droite d’un certain nombre
de bits.
Pour décaler les bits vers la gauche, on utilise l’opérateur <<. Pour les décaler vers
la droite, c’est >> qui est utiliser.
Dans tout les cas, on place à gauche de l’opérande le nombre à modifier, et à sa droite le nombre
de bits à décaler :

#include 
int main(){
int a=3;// 3 -> 11 en binaire

a = a << 4;
/*On décale de 4 rang vers la gauche, donc :
11 - > 110000 = 48*/
printf("%d", a);/* Sortie -> 48 */

a = a >> 8;
/*On décale de 8 rand vers la droite, donc :
110000 -> 0*/
printf("%d", a);/* Sortie -> 0 */

return 0;
}

À noter que comme pour les opérateurs d’affectation énoncés ci-dessus, ces opérateurs peuvent dans
certains cas être résumés ainsi :

Opérateur	Exemple	Equivalence
|=	a |= b;	a = a | b;
&=	a &= b;	a = a & b;
~=	a ~= b;	a = a ~ b;
<<=	a <<= b;	a = a << b;
>>=	a >>= b;	a = a >> b;

Opérateurs relationnels

Les opérateurs relationnels permettent de comparer des données.
Le résultat de ces opérateurs est un résultat booleen, c’est à dire que l’expression sera évaluée soit à 1,
soit à 0. On peut ainsi combiner ces expressions avec les opérateurs logiques énoncés plus haut.
Voici un tableau récapitulatif :

Opérateur	Description	Exemple de code	Résultat
==	Egualité	int a=25; int b=a; printf( »%d », a==b);	1
!=	Inégalité	int a=120; int b=350; printf( »%d », a != b);	1
<	Inférieur	int a=10; int b=100; printf( »%d », a < b);	1
<=	Inférieur ou égal	int a=100; int b=100; printf( »%d », a <= b);	1
>	Supérieur	int a=100; int b=10; printf( »%d », a > b);	1
>=	Supérieur ou égal	int a=100; int b=100; printf( »%d », a >= b);	1

Le C possede encore d’autres opérateurs, mais nous les decouvrirons plus tard, car ils concernent des choses
specifiquent que nous n’avons pas encore découvertes.

Series Navigation

«Langage C – Les variablesLangage C – Structure conditionnelle»