Programmer L'Arduino - Les Opérateurs - WayToLearnX

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

 

• Différences entre microprocesseur 8086 et 8088
• Différences entre microprocesseur 8085 et 8086
• Programmer l’Arduino – Strings
• Programmer l’Arduino – Les fonctions
• Programmer l’Arduino – Les boucles
• Programmer l’Arduino – Les structures conditionnelles
• Programmer l’Arduino – Les opérateurs
• Programmer l’Arduino – Les variables et constantes
• Programmer l’Arduino – Les types de données
• Programmer l’Arduino – La structure du programme
• Programmer l’Arduino – L’installation
• Programmer l’Arduino – Description de la carte Arduino
• Programmer l’Arduino – Introduction

QCMs qui pourraient vous intéresser :

• Questions techniques sur MYSQL
• QCM MySQL Corrigé – Optimisation de requêtes
• QCM Base de données avec correction
• QCM sur PHP
• QCM Symfony
• QCM AngularJS
• QCM React
• QCM HTML / CSS
• QCM Java – Programmation Orientée Objet
• QCM Python
• QCM Cloud Computing
• QCM Framework Spring
• QCM Javascript
• QCM jQuery
• QCM Oracle
• QCM sur GIT – Gestionnaire de version
• QCM Linux – Gestion de processus
• QCM Réseau
• QCM Architecture des ordinateurs
• QCM Securité informatique
• QCM En Informatique Générale
• QCM en C
• QCM en C#
• QCM sur l'algorithmique
• QCM Word
• QCM Excel
• QCM PowerPoint
• QCM Access