Langage C

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 : 14
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 : 11 et res : 10
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 à b
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;
                                }
                            
condition ET non satisfaite
a est supérieure à b OU c est égale à d
a est différente de zero

Partager ce cours avec tes amis :

Rédigé par M. ESSADDOUKI

Learning a new programming language is an easy thing, but the most difficult thing is how to design efficient algorithms for real-world problems, so don't be a programmer, be a problems solver.

Cours Similaires :