les opérateurs en C
Les opérateurs sont la base de tout langage de programmation. Ainsi, la fonctionnalité du langage C est incomplète sans l'utilisation d'opérateurs. Les opérateurs nous permettent d’effectuer différents types d’opérations sur des opérandes. En C, les opérateurs peuvent être classés dans les catégories suivantes:
- Opérateurs arithmétiques (+, -, *, /,%, post-incrémentation, pré-incrémentation, post-décrémentation, pré-décrémentation)
- Opérateurs relationnels (==,! =,>, < ,> = & <=) Opérateurs logiques (&&, || et !)
- Opérateurs binaires (&, |, ^, ~, >> et <<)
- Opérateurs d'affectation (=, +=, -=, *=, etc)
- Autres opérateurs (conditionnel, virgule, sizeof, address, redirection)
Opérateurs arithmétiques
Ils sont utilisés pour effectuer des opérations arithmétiques/mathématiques sur les opérandes. Les opérateurs binaires appartenant à cette catégorie sont:
- Addition : L'opérateur ‘+’ ajoute deux opérandes. Par exemple, x+y.
- Soustraction: l'opérateur ‘ - ' soustrait deux opérandes. Par exemple, x-y.
- Multiplication: l'opérateur ’ * ' multiplie deux opérandes. Par exemple, x*y.
- Division: l'opérateur '/' divise le premier opérande par le second. Par exemple, x/y.
- Module: l'opérateur ' % ' renvoie le reste lorsque le premier opérande est divisé par le second. Par exemple, x%y.
Exemple 1 :
#include < stdio.h>
int main()
{
int a = 10, b = 4, res;
res = a + b; // addition
printf("a+b : %d\n", res);
res = a - b; // soustraction
printf("a-b : %d\n", res);
res = a * b; // multiplication
printf("a*b : %d\n", res);
res = a / b; // division
printf("a/b : %d\n", res);
res = a % b; // Module
printf("a mod b : %d\n", res);
return 0;
}
a-b : 6
a*b : 40
a/b : 2
a mod b : 2
Ceux qui entrent dans la catégorie des opérateurs arithmétiques unaires sont:
-
Incrémentation : L’opérateur «++» permet d’incrémenter la valeur d’un entier.
Quand il est est placé devant le nom de la variable (également appelé opérateur de pré-incrémentation), sa valeur est incrémentée instantanément. Par exemple, ++x.
Et quand il est placé après le nom de la variable (également appelé opérateur post-incrémentation), sa valeur est conservée temporairement jusqu'à l'exécution de cette instruction et est mise à jour avant l'exécution de l'instruction suivante. Par exemple, x++. -
Décrémentation : L’opérateur "--" sert à décrémenter la valeur d’un entier.
Quand il est est placé avant le nom de la variable (également appelé opérateur de pré-décrémentation), sa valeur est décrémentée instantanément. Par exemple, --x.
Et quand il est placé après le nom de la variable (également appelé opérateur post-décrémentation), sa valeur est conservée temporairement jusqu'à l'exécution de cette instruction et elle est mise à jour avant l'exécution de l'instruction suivante. Par exemple, x--
Exemple 2 :
#include < stdio.h>
int main()
{
int a = 10, b = 4, res;
// post-incrémentation:
res = a++;
printf("a : %d et res : %d\n", a, res);
// post-décrémentation
res = a--;
printf("a is %d et res : %d\n", a, res);
// pré-incrémentation
res = ++a;
printf("a : %d et res : %d\n", a, res);
// pré-décrémentation
res = --a;
printf("a : %d et res : %d\n", a, res);
return 0;
}
a is 10 et res : 11
a : 11 et res : 11
a : 10 et res : 10
Opérateurs relationnels et logiques
Opérateurs relationnels
Les opérateurs relationnels sont utilisés pour comparer deux valeurs.
-
L'opérateur ‘==’ vérifie si les deux opérandes sont égales ou non. Si oui, il renvoie la valeur true. Sinon, il retourne false. Par exemple, 5==5 retournera true.
-
L'opérateur ‘!=’ vérifie si les deux opérandes sont égaux ou non. elle renvoie la valeur true si les deux opérandes ne sont pas égaux, Sinon, il retourne false. C'est le complément booléen exact de l'opérateur‘==’. Par exemple, 5!=5 retournera false.
-
L’opérateur ‘>’ vérifie si le premier opérande est supérieur au deuxième opérande. Si c'est le cas, cela retourne true. Sinon, il retourne false. Par exemple, 6 > 5 retournera true.
-
L’opérateur ‘<‘ vérifie si le premier opérande est inférieur au deuxième opérande. Si c'est le cas, cela retourne true. Sinon, il retourne false. Par exemple, 6 < 5 renverra false.
-
L’opérateur ‘> =’ vérifie si le premier opérande est supérieur ou égal au deuxième opérande. Si c'est le cas, cela retourne true. Sinon, il retourne false. Par exemple, 5 > = 5 retournera true.
-
L’opérateur ‘<=’ vérifie si le premier opérande est inférieur ou égal au deuxième opérande. Si c'est le cas, cela retourne true. Sinon, il retourne false. Par exemple, 5 <= 5 retournera également true.
Exemple 3 :
#include
int main()
{
int a = 10, b = 4;
// supérieure à
if (a > b)
printf("a est supérieure à b\n");
else
printf("a est inférieure ou égale à b\n");
// supérieure ou égale
if (a >= b)
printf("a est supérieure ou égale à b\n");
else
printf("a est inférieure à b\n");
// inférieure à
if (a < b)
printf("a est inférieure à b\n");
else
printf("a est supérieure ou égal b\n");
// inférieure ou égale
if (a <= b)
printf("a est inférieure ou égale à b\n");
else
printf("a est supérieure à b\n");
// égales
if (a == b)
printf("les valeurs a et b sont égales \n");
else
printf("a et b ne sont pas égales\n");
// ne sont pas égales
if (a != b)
printf("les valeurs a et b ne sont pas égales \n");
else
printf("les valeurs a et b sont égales b\n");
return 0;
}
a est supérieure ou égale à b
a est supérieure ou égal b
a est supérieure à b
a et b ne sont pas égales
les valeurs a et b ne sont pas égales
Opérateurs logiques
Ils sont utilisés pour combiner deux ou plusieurs conditions / contraintes ou pour compléter l'évaluation de la condition d'origine considérée.
Ils sont décrits ci-dessous:
-
ET logique: l’opérateur ‘&&’ retourne true lorsque les deux conditions considérées sont remplies. Sinon, il retourne false.
Par exemple, a && b renvoie true lorsque a et b sont vraies (c'est-à-dire différentes de zéro). -
OU logique: l’opérateur «||» renvoie la valeur true lorsque l’une (ou les deux) des conditions considérées est remplie. Sinon, il retourne false.
Par exemple, a || b renvoie true si l'un des a ou b est true (c'est-à-dire différente de zéro). Bien sûr, il retourne true lorsque a et b sont toutes les deux vraies. -
NON logique: L’opérateur ‘!’ Renvoie true si la condition considérée n’est pas remplie. Sinon, il retourne false. Par exemple,!A retourne true si a est false, c’est-à-dire quand a = 0.
Exemple 4 :
#include
int main()
{
int a = 10, b = 4, c = 10, d = 20;
// ET logique
if (a > b && c == d)
printf("a est supérieure à b ET c est égale à d\n");
else
printf("condition ET non satisfaite\n");
// OU logique
if (a > b || c == d)
printf("a est supérieure à b OU c est égale à d\n");
else
printf("Ni a n'est supérieure à b ni c n'est égale à d ");
// NON logique
if (!a)
printf("a est zéro\n");
else
printf("a est différente de zero");
return 0;
}
a est supérieure à b OU c est égale à d
a est différente de zero
