Programmer l’Arduino – Les opérateurs

Un opérateur est un symbole qui indique au compilateur d’effectuer des fonctions mathématiques ou logiques spécifiques. Le langage C est riche en opérateurs intégrés et fournit les types d’opérateurs suivants:

• Opérateurs arithmétiques
• Opérateurs de comparaison
• Opérateurs booléens
• Opérateurs bit à bit
• Opérateurs composés

 
 

Opérateurs arithmétiques

Supposons que la variable A détient la valeur 10 et la variable B détient la valeur 20 alors

Nom de l’opérateur	Opérateur	Description	Exemple
Opérateur d’affectation	=	Stocke la valeur à droite du signe égal dans la variable à gauche du signe égal.	A = B
addition	+	Ajoute deux opérandes	A + B donnera 30
soustraction	–	Soustrait le second opérande du premier	A – B donnera -10
multiplication	*	Multipliez les deux opérandes	A * B donnera 200
division	/	Diviser le numérateur par dénominateur	B / Adonnera 2
modulo	%	Opérateur modulo et le reste d’après une division entière	B % A donnera 0

Exemple :

void loop() {
   int a = 10,b = 20,c;
   c = a + b;
   c = a - b;
   c = a * b;
   c = a / b;
   c = a % b;
} 

 

Opérateurs de comparaison

Supposons que la variable A détient la valeur 10 et la variable B détient la valeur 20 alors

Nom de l’opérateur	Opérateur	Description	Exemple
égal à	==	Vérifie si la valeur de deux opérandes est égale ou non, si oui, la condition devient vraie.	(A == B) est faux
différent de	!=	Vérifie si la valeur de deux opérandes est égale ou non, si les valeurs ne sont pas égales, la condition devient vraie.	(A != B) est vrai
inférieur	<	Vérifie si la valeur de l’opérande gauche est inférieure à la valeur de l’opérande droit, si oui, la condition devient vraie.	(A < B) est vrai
supérieur	>	Vérifie si la valeur de l’opérande gauche est supérieure à la valeur de l’opérande droit, si oui, la condition devient vraie.	(A > B) est faux
inférieur ou égal à	<=	Vérifie si la valeur de l’opérande gauche est inférieure ou égale à la valeur de l’opérande droit, si oui, la condition devient vraie.	(A <= B) est vrai
supérieur ou égal à	>=	Vérifie si la valeur de l’opérande gauche est supérieure ou égale à la valeur de l’opérande droit, si oui, la condition devient vraie.	(A >= B) est faux

Exemple :

void loop () { 
   int x = 10,y = 5
   bool z = false;
   if(x == y)
      z = true;
   else
      z = false;

   if(x != y)
      z = true;
   else
      z = false;
   
   if(x < y)
      z = true;
   else
      z = false;
   
   if(x > y)
      z = true;
   else
      z = false;
   
   if(x <= y)
      z = true;
   else
      z = false;
   
   if(x >= y)
      z = true;
   else
      z = false;
}

Résultat :

z = false
z = true
z = false
z = true
z = false
z = false

 
 

Opérateurs booléens

Supposons que la variable A détient la valeur 10 et la variable B détient la valeur 20 alors

Nom de l’opérateur	Opérateur	Description	Exemple
and	&&	Opérateur logique AND. Si les deux opérandes ne sont pas zéro alors la condition devient vraie.	(A && B) est vrai
or	||	Opérateur logique OR. Si l’un des deux opérandes n’est pas nul, alors la condition devient vraie.	(A || B) est vrai
not	!	Opérateur logique NOT. Utilisé pour inverser l’état logique de son opérande. Si une condition est vraie, l’opérateur logique NOT fera fausses.	!(A && B) est faux

Exemple :

void loop () {
   int x = 9,y = 4
   bool z = false;
   if((x > y)&& (y < x))
      z = true;
   else
      z = false;

   if((x == y)|| (y < x))
      z = true;
   else
      z = false;

   if( !(x == y)&& (y < x))
      z = true;
   else
      z = false;
} 

Résultat :

z = true
z = true
z = true

 

Opérateurs bit à bit

Supposons que la variable A détient la valeur 60 et la variable B détient la valeur 13 alors

Nom de l’opérateur	Opérateur	Description	Exemple
and	&	L’opération binaire AND (aussi connue sous le nom de « fonction AND ») produira toujours une sortie si les deux entrées sont 1 et produiront une sortie 0 si une ou les deux entrées sont 0.	(A & B) donnera 12 lequel est 0000 1100
or	|	L’opération binaire OR (également appelée fonction OR binaire) produira toujours une sortie si l’une de ses entrées est 1 et produira une sortie 0 si les deux entrées sont 0.	(A | B) donnera 61 lequel est 0011 1101
xor	^	L’opération binaire XOR  (également appelée la fonction XOR binaire) produira toujours une sortie si l’une de ses entrées est 1 et produira une sortie 0 si les deux entrées sont 0 ou 1.	(A ^ B) donnera 49 lequel est 0011 0001
not	~	L’opérateur unaire et a pour effet de « flipping » bits.	(~A ) donnera -60 lequel est 1100 0011
shift left	<<	Décalage vers la gauche les bits d’une expression	A << 2 donnera 240 lequel est 1111 0000
shift right	>>	Décalage vers la droit les bits d’une expression	A >> 2 donnera 15 lequel est 0000 1111

Exemple :

void loop() {
   int x = 10,y = 20
   int z = 0;
   z = x & y ;
   z = x | y ;
   z = x ^ y ;
   z = x ~ y ;
   z = x << y ;
   z = x >> y ; 
}

Résultat :

z = 12
z = 61
z = 49
z = -60
z = 240
z = 15

 
 

Opérateurs composés

Supposons que la variable A détient la valeur 10 et la variable B détient la valeur 20 alors

Nom de l’opérateur	Opérateur	Description	Exemple
incrémentation	++	L’opérateur d’incrémentation, augmente la valeur d’un entière à 1	A++ donnera 11
Décrémentation	—	L’opérateur de décrémentation, diminue la valeur d’un entière à 1	A– donnera 9
Addition composé	+=	Addition combinée à l’affectation, ajoute l’opérande droit à l’opérande gauche et attribue le résultat à l’opérande gauche	B += A est équivalent à B = B+ A
Soustraction composée	-=	Soustraction combinée à l’affectation, soustrait l’opérande droit de l’opérande gauche et affecte le résultat à l’opérande gauche	B -= A est équivalent à B = B – A
Multiplication composée	*=	Multiplication combinée à l’affectation, Il multiplie l’opérande droit avec l’opérande gauche et attribue le résultat à l’opérande gauche	B*= A est équivalent à B = B* A
Division composée	/=	Division combinée à l’affectation, Il divise l’opérande gauche avec l’opérande droit et attribue le résultat à l’opérande gauche	B /= A est équivalent à B = B / A
Modulo composé	%=	Modulo combinée à l’affectation, il prend le module en utilisant deux opérandes et affecte le résultat à l’opérande gauche	B %= A est équivalent à B = B % A
OR binaire Composé	|=	OU inclusif combinée à l’affectation	A |= 2 est identique à A = A | 2
AND binaire Composé	&=	AND binaire combinée à l’affectation	A &= 2 est identique à A = A & 2

Exemple :

void loop () {
   int x = 10,y = 20
   
   x++;
   x--;
   y += x;
   y -= x;
   y *= x;
   y /= x;
  x %= y;
  x |= y;
  x &= y;
}

Résultat :

x = 11
x = 9
y = 30
y = 10
y = 200
y = 2
x = 0
x = 61
x = 12