C# Opérateurs

Un opérateur est un symbole qui indique au compilateur d'effectuer des opérations mathématiques ou logiques spécifiques. C# dispose d'un riche ensemble d'opérateurs intégrés, classés comme suit :

  • Opérateurs arithmétiques
  • Opérateurs relationnels
  • Opérateurs logiques
  • Opérateurs bit à bit
  • Opérateurs d'affectation
  • Autres opérateurs

Ce tutoriel expliquera un par un les opérateurs arithmétiques, les opérateurs relationnels, les opérateurs logiques, les opérateurs bit à bit, les opérateurs d'affectation et d'autres opérateurs.

Opérateurs arithmétiques

Le tableau suivant présente tous les opérateurs arithmétiques pris en charge par C#. Supposons que la variableAait une valeur de 10, que la variableBait une valeur de 20, alors :

OpérateursDescriptionExemple
+Additionne deux opérandes.A + B donnera 30
-Soustrait le deuxième opérande du premier opérande.A - B donnera -10
*Multiplie deux opérandes.A * B donnera 200
/Numérateur divisé par dénominateurB / A donnera 2
%Opérateur modulo, reste après une division entière.B % A donnera 0
++Opérateur d'incrémentation, augmente une valeur entière de 1.A++ donnera 11
--Opérateur de décrémentation, diminue une valeur entière de 1.A-- donnera 9

Exemple

Voir l'exemple ci-dessous pour comprendre tous les opérateurs arithmétiques disponibles en C# :

Exemple

using System;

namespace OperatorsAppl
{
    class Program
    {
        static void Main(string[] args)
        {
            int a = 21;
            int b = 10;
            int c;

            c = a + b;
            Console.WriteLine("Ligne 1 - la valeur de c est {0}", c);
            c = a - b;
            Console.WriteLine("Ligne 2 - la valeur de c est {0}", c);
            c = a * b;
            Console.WriteLine("Ligne 3 - la valeur de c est {0}", c);
            c = a / b;
            Console.WriteLine("Ligne 4 - la valeur de c est {0}", c);
            c = a % b;
            Console.WriteLine("Ligne 5 - la valeur de c est {0}", c);

            // ++a incrémente avant l'affectation
            c = ++a;
            Console.WriteLine("Ligne 6 - la valeur de c est {0}", c);

            // À ce stade, la valeur de a est 22
            // --a décrémente avant l'affectation
            c = --a;
            Console.WriteLine(Ligne 7 - La valeur de c est {0}, c);
            Console.ReadLine();
        }
    }
}

Lorsque le code ci-dessus est compilé et exécuté, il produit les résultats suivants :

Line 1 - c 的值是 31
Line 2 - c 的值是 11
Line 3 - c 的值是 210
Line 4 - c 的值是 2
Line 5 - c 的值是 1
Line 6 - c 的值是 22
Line 7 - c 的值是 21
  • c = a++: Affectez d'abord a à c, puis incrémentez a.
  • c = ++a: Incrémenter d'abord a, puis affecter a à c.
  • c = a--: Affecter d'abord a à c, puis décrémenter a.
  • c = --a: Décrémenter d'abord a, puis affecter a à c.

Exemple

using System;

namespace OperatorsAppl
{
    class Program
    {
        static void Main(string[] args)
        {
            int a = 1;
            int b;

            // a++ affecte avant d'incrémenter
            b = a++;
            Console.WriteLine("a = {0}", a);
            Console.WriteLine("b = {0}", b);
            Console.ReadLine();

            // ++a incrémente avant l'affectation
            a = 1; // Réinitialiser a
            b = ++a;
            Console.WriteLine("a = {0}", a);
            Console.WriteLine("b = {0}", b);
            Console.ReadLine();

            // a-- affecte avant de décrémenter
            a = 1;  // Réinitialiser a
            b= a--;
            Console.WriteLine("a = {0}", a);
            Console.WriteLine("b = {0}", b);
            Console.ReadLine();

            // --a décrémente avant l'affectation
            a = 1;  // Réinitialiser a
            b= --a;
            Console.WriteLine("a = {0}", a);
            Console.WriteLine("b = {0}", b);
            Console.ReadLine();
        }
    }
}

En exécutant le programme ci-dessus, le résultat de sortie est :

a = 2
b = 1
a = 2
b = 2
a = 0
b = 1
a = 0
b = 0

Opérateurs relationnels

Le tableau suivant présente tous les opérateurs relationnels pris en charge par C#. Supposons que la variableAa une valeur de 10, que la variableBa une valeur de 20, alors :

OpérateursDescriptionExemple
==Vérifie si les valeurs de deux opérandes sont égales ; si elles sont égales, la condition est vraie.(A == B) n'est pas vraie.
!=Vérifie si les valeurs de deux opérandes sont égales ; si elles ne sont pas égales, la condition est vraie.(A != B) est vraie.
>Vérifie si la valeur de l'opérande gauche est supérieure à la valeur de l'opérande droit ; si c'est le cas, la condition est vraie.(A > B) n'est pas vraie.
<Vérifie si la valeur de l'opérande gauche est inférieure à la valeur de l'opérande droit ; si c'est le cas, la condition est vraie.(A < B) est vraie.
>=Vérifie si la valeur de l'opérande gauche est supérieure ou égale à la valeur de l'opérande droit ; si c'est le cas, la condition est vraie.(A >= B) n'est pas vraie.
<=Vérifie si la valeur de l'opérande gauche est inférieure ou égale à la valeur de l'opérande droit ; si c'est le cas, la condition est vraie.(A <= B) est vraie.

Exemple

Consultez l'exemple ci-dessous pour comprendre tous les opérateurs relationnels disponibles en C# :

Exemple

using System;

class Program
{
  static void Main(string[] args)
  {
      int a = 21;
      int b = 10;
     
      if (a == b)
      {
          Console.WriteLine("Ligne 1 - a est égal à b");
      }
      else
      {
          Console.WriteLine("Ligne 1 - a n'est pas égal à b");
      }
      if (a < b)
      {
          Console.WriteLine("Ligne 2 - a est inférieur à b");
      }
      else
      {
          Console.WriteLine("Ligne 2 - a n'est pas inférieur à b");
      }
      if (a > b)
      {
          Console.WriteLine("Ligne 3 - a est supérieur à b");
      }
      else
      {
          Console.WriteLine("Ligne 3 - a n'est pas supérieur à b");
      }
      /* Changer les valeurs de a et b */
      a = 5;
      b = 20;
      if (a <= b)
      {
         Console.WriteLine(Ligne 4 - a est inférieur ou égal à b);
      }
      if (b >= a)
      {
         Console.WriteLine(Ligne 5 - b est supérieur ou égal à a);
      }
  }
}

Lorsque le code ci-dessus est compilé et exécuté, il produit les résultats suivants :

Line 1 - a 不等于 b
Line 2 - a 不小于 b
Line 3 - a 大于 b
Line 4 - a 小于或等于 b
Line 5 - b 大于或等于 a

Opérateurs logiques

Le tableau suivant montre tous les opérateurs logiques pris en charge par C#. Supposons que la variableAsoit une valeur booléenne true, que la variableBsoit une valeur booléenne false, alors :

OpérateursDescriptionExemple
&&Appelé l'opérateur ET logique. Si les deux opérandes sont non nuls, la condition est vraie.(A && B) est faux.
||Appelé opérateur logique OU. Si l'un des opérandes est non nul, la condition est vraie.(A || B) est vrai.
!On l'appelle l'opérateur logique NON. Il est utilisé pour inverser l'état logique d'un opérande. Si la condition est vraie, l'opérateur logique NON la rendra fausse.!(A && B) est vrai.

Exemple

Voir l'exemple ci-dessous pour comprendre tous les opérateurs logiques disponibles en C# :

Exemple

using System;

namespace OperatorsAppl
{
    class Program
    {
        static void Main(string[] args)
        {
            bool a = true;
            bool b = true;
           
            if (a && b)
            {
               Console.WriteLine(Ligne 1 - la condition est vraie);
            }
            if (a || b)
            {
                Console.WriteLine(Ligne 2 - la condition est vraie);
            }
            /* Changer les valeurs de a et b */
            a = false;
            b = vrai;
            if (a && b)
            {
                Console.WriteLine(Ligne 3 - la condition est vraie);
            }
            else
            {
                Console.WriteLine("Ligne 3 - la condition n'est pas vraie");
            }
            if (!(a && b))
            {
                Console.WriteLine(Ligne 4 - la condition est vraie);
            }
            Console.ReadLine();
        }
    }
}

Lorsque le code ci-dessus est compilé et exécuté, il produit les résultats suivants :

Line 1 - 条件为真
Line 2 - 条件为真
Line 3 - 条件不为真
Line 4 - 条件为真

Opérateurs bit à bit

Les opérateurs bit à bit agissent sur les bits et effectuent des opérations bit par bit. Les tables de vérité pour &, | et ^ sont les suivantes :

pqp & qp | qp ^ q
00000
01011
11110
10011

Supposons que A = 60 et B = 13. Exprimés en format binaire, ils sont les suivants :

A = 0011 1100

B = 0000 1101

-----------------

A&B = 0000 1100

A|B = 0011 1101

A^B = 0011 0001

~A  = 1100 0011

Le tableau suivant répertorie les opérateurs bit à bit pris en charge par C#. Supposons que la variableAait une valeur de 60, que la variableBait une valeur de 13, alors :

OpérateursDescriptionExemple
&Si présent dans les deux opérandes, l'opérateur AND binaire copie un bit dans le résultat.(A & B) donne 12, soit 0000 1100.
|Si présent dans l'un ou l'autre des opérandes, l'opérateur OR binaire copie un bit dans le résultat.(A | B) donne 61, soit 0011 1101.
^Si présent dans un opérande mais pas dans les deux, l'opérateur XOR binaire copie un bit dans le résultat.(A ^ B) a pour valeur 49, soit 0011 0001.
~L'opérateur de complément bit à bit est un opérateur unaire qui a pour effet d'« inverser » les bits, c'est-à-dire que 0 devient 1 et 1 devient 0, y compris le bit de signe.(~A ) aura pour résultat -61, qui est 1100 0011, la forme en complément à deux d'un nombre binaire signé.
<<Opérateur de décalage binaire vers la gauche. La valeur de l'opérande gauche est décalée vers la gauche du nombre de bits spécifié par l'opérande droit.A << 2 a pour valeur 240, soit 1111 0000.
>>Opérateur de décalage binaire à droite. La valeur de l'opérande de gauche est décalée vers la droite du nombre de bits spécifié par l'opérande de droite.A >> 2 a pour valeur 15, soit 0000 1111.

Exemple

Voir l'exemple ci-dessous pour comprendre tous les opérateurs bit à bit disponibles en C# :

Exemple

using System;
namespace OperatorsAppl
{
    class Program
    {
        static void Main(string[] args)
        {
            int a = 60;            /* 60 = 0011 1100 */  
            int b = 13;            /* 13 = 0000 1101 */
            int c = 0;          

             c = a & b;           /* 12 = 0000 1100 */
             Console.WriteLine("Ligne 1 - la valeur de c est {0}", c );

             c = a | b;           /* 61 = 0011 1101 */
             Console.WriteLine("Ligne 2 - la valeur de c est {0}", c);

             c = a ^ b;           /* 49 = 0011 0001 */
             Console.WriteLine("Ligne 3 - la valeur de c est {0}", c);

             c = ~a;               /*-61 = 1100 0011 */
             Console.WriteLine("Ligne 4 - la valeur de c est {0}", c);

             c = a << 2;     /* 240 = 1111 0000 */
             Console.WriteLine("Ligne 5 - la valeur de c est {0}", c);

             c = a >> 2;     /* 15 = 0000 1111 */
             Console.WriteLine("Ligne 6 - la valeur de c est {0}", c);
            Console.ReadLine();
        }
    }
}

Lorsque le code ci-dessus est compilé et exécuté, il produit les résultats suivants :

Line 1 - c 的值是 12
Line 2 - c 的值是 61
Line 3 - c 的值是 49
Line 4 - c 的值是 -61
Line 5 - c 的值是 240
Line 6 - c 的值是 15

Opérateurs d'affectation

Le tableau suivant répertorie les opérateurs d'affectation pris en charge par C# :

OpérateursDescriptionExemple
=Opérateur d'affectation simple, affecte la valeur de l'opérande droit à l'opérande gauche.C = A + B affectera la valeur de A + B à C
+=Opérateur d'addition et d'affectation, affecte à l'opérande de gauche le résultat de l'addition de l'opérande de droite à l'opérande de gauche.C += A équivaut à C = C + A.
-=Opérateur de soustraction et d'affectation, affecte à l'opérande de gauche le résultat obtenu en soustrayant l'opérande de droite de l'opérande de gauche.C -= A équivaut à C = C - A.
*=Opérateur de multiplication et d'affectation, affecte à l'opérande de gauche le résultat de la multiplication de l'opérande de droite par l'opérande de gauche.C *= A est équivalent à C = C * A.
/=Opérateur de division et d'affectation, affecte à l'opérande de gauche le résultat de la division de l'opérande de gauche par l'opérande de droite.C /= A est équivalent à C = C / A.
%=Opérateur de modulo et d'affectation, prend le modulo de deux opérandes et l'affecte à l'opérande gauche.C %= A est équivalent à C = C % A.
<<=Opérateur de décalage à gauche et d'affectation.C <<= 2 est équivalent à C = C << 2
>>=Opérateur de décalage à droite et d'affectation.C >>= 2 est équivalent à C = C >> 2
&=Opérateur ET bit à bit et d'affectation.C &= 2 est équivalent à C = C & 2
^=Opérateur OU exclusif bit à bit et d'affectation.C ^= 2 est équivalent à C = C ^ 2
|=Opérateur OU bit à bit et d'affectation.C |= 2 est équivalent à C = C | 2

Exemple

Voir l'exemple ci-dessous pour comprendre tous les opérateurs d'affectation disponibles en C# :

Exemple

using System;

namespace OperatorsAppl
{
    class Program
    {
        static void Main(string[] args)
        {
            int a = 21;
            int c;

            c = a;
            Console.WriteLine(Ligne 1 - = valeur de c = {0}, c);

            c += a;
            Console.WriteLine(Ligne 2 - += valeur de c = {0}, c);

            c -= a;
            Console.WriteLine("Ligne 3 - -= valeur de c = {0}", c);

            c *= a;
            Console.WriteLine("Ligne 4 - *= valeur de c = {0}", c);

            c /= a;
            Console.WriteLine(Ligne 5 - /= valeur de c = {0}, c);

            c = 200;
            c %= a;
            Console.WriteLine(Ligne 6 - %= valeur de c = {0}, c);

            c <<= 2;
            Console.WriteLine(Ligne 7 - <<= valeur de c = {0}, c);

            c >>= 2;
            Console.WriteLine(Ligne 8 - >>= valeur de c = {0}, c);

            c &= 2;
            Console.WriteLine(Ligne 9 - &= valeur de c = {0}, c);

            c ^= 2;
            Console.WriteLine(Ligne 10 - ^= valeur de c = {0}, c);

            c |= 2;
            Console.WriteLine(Ligne 11 - |= valeur de c = {0}, c);
            Console.ReadLine();
        }
    }
}

Lorsque le code ci-dessus est compilé et exécuté, il produit les résultats suivants :

Line 1 - =     c 的值 = 21
Line 2 - +=    c 的值 = 42
Line 3 - -=    c 的值 = 21
Line 4 - *=    c 的值 = 441
Line 5 - /=    c 的值 = 21
Line 6 - %=    c 的值 = 11
Line 7 - <<=    c 的值 = 44
Line 8 - >>=    c 的值 = 11
Line 9 - &=    c 的值 = 2
Line 10 - ^=    c 的值 = 0
Line 11 - |=    c 的值 = 2

Autres opérateurs

Le tableau suivant répertorie quelques autres opérateurs importants pris en charge par C#, notammentsizeof、typeofet? :。

OpérateursDescriptionExemple
sizeof()Renvoie la taille d'un type de données.sizeof(int) renverra 4.
typeof()Renvoie le type d'une classe.typeof(StreamReader);
&Renvoie l'adresse d'une variable.&a; obtiendra l'adresse réelle de la variable.
*Pointeur vers une variable.*a; pointe vers une variable.
? :Expression conditionnelleSi la condition est vraie ? alors X : sinon Y
estDétermine si un objet est d'un certain type.If( Ford is Car) // Vérifier si Ford est un objet de la classe Car.
asConversion par cast, même si la conversion échoue, elle ne lèvera pas d'exception.Object obj = new StringReader("Hello");
StringReader r = obj as StringReader;

Exemple

Exemple

using System;

namespace OperatorsAppl
{
   
   class Program
   {
      static void Main(string[] args)
      {
         
         /* Exemple de l'opérateur sizeof */
         Console.WriteLine("La taille de int est {0}", sizeof(int));
         Console.WriteLine("La taille de short est {0}", sizeof(short));
         Console.WriteLine("La taille de double est {0}", sizeof(double));
         
         /* Exemple de l'opérateur ternaire */
         int a, b;
         a = 10;
         b = (a == 1) ? 20 : 30;
         Console.WriteLine("La valeur de b est {0}", b);

         b = (a == 10) ? 20 : 30;
         Console.WriteLine("La valeur de b est {0}", b);
         Console.ReadLine();
      }
   }
}

Lorsque le code ci-dessus est compilé et exécuté, il produit les résultats suivants :

int 的大小是 4
short 的大小是 2
double 的大小是 8
b 的值是 30
b 的值是 20

Le mot-clé typeof est utilisé pour obtenir l'objet de type d'un type ; il est couramment utilisé pour la réflexion et la création dynamique d'instances de type.

Voici un exemple simple utilisant typeof :

Exemple

using System;

class Program
{
    static void Main(string[] args)
    {
        Type type = typeof(string);
        Console.WriteLine(type.FullName);
        Console.ReadKey();
    }
}

Dans le code ci-dessus, nous utilisons le mot-clé typeof pour obtenir l'objet de type du type string et le stockons dans une variable type de type Type. Ensuite, nous utilisons la propriété FullName pour imprimer le nom qualifié complet de ce type.

Lorsque le code ci-dessus est compilé et exécuté, il produit les résultats suivants :

System.String

Précédence des opérateurs en C#

La précédence des opérateurs détermine le regroupement des termes dans une expression. Cela influence la façon dont une expression est évaluée. Certains opérateurs ont une précédence plus élevée que d'autres. Par exemple, les opérateurs de multiplication et de division ont une précédence plus élevée que les opérateurs d'addition et de soustraction.

Par exemple x = 7 + 3 * 2, ici x reçoit 13, et non 20, car l'opérateur * a une précédence plus élevée que +, donc la multiplication 3*2 est calculée en premier, puis 7 est ajouté.

Le tableau suivant liste les opérateurs par ordre de précédence décroissante. Les opérateurs ayant une précédence plus élevée apparaissent en haut du tableau, et les opérateurs ayant une précédence plus faible apparaissent en bas. Dans une expression, les opérateurs ayant une précédence plus élevée sont évalués en premier.

Aperçu simple de la précédence.: D'abord les parenthèses, puis multiplication/division, puis addition/soustraction, puis décalages, puis relationnels, puis logiques, puis conditionnels, et enfin virgule., 。

Catégorie OpérateursAssociativité
Postfixe() [] -> . ++ - -   De gauche à droite
Unaire + - ! ~ ++ - - (type)* & sizeof  De droite à gauche
Multiplicatif * / % De gauche à droite
Additif+ -  De gauche à droite
Décalage << >>  De gauche à droite
Relation< <= > >=  De gauche à droite
Égalité == !=  De gauche à droite
ET bit à bit&  De gauche à droite
OU exclusif bit à bit ^  De gauche à droite
OU bit à bit |  De gauche à droite
ET logique&&  De gauche à droite
OU logique ||  De gauche à droite
Conditions?:  De droite à gauche
Affectation = += -= *= /= %=>>= <<= &= ^= |= De droite à gauche
comma ,  De gauche à droite

Exemple

Exemple

using System;

namespace OperatorsAppl
{
   
   class Program
   {
      static void Main(string[] args)
      {
         int a = 20;
         int b = 10;
         int c = 15;
         int d = 5;
         int e;
         e = (a + b) * c / d;     // ( 30 * 15 ) / 5
         Console.WriteLine(La valeur de (a + b) * c / d est {0}, e);

         e = ((a + b) * c) / d;   // (30 * 15 ) / 5
         Console.WriteLine("La valeur de ((a + b) * c) / d est {0}", e);

         e = (a + b) * (c / d);   // (30) * (15/5)
         Console.WriteLine("La valeur de (a + b) * (c / d) est {0}", e);

         e = a + (b * c) / d;    //  20 + (150/5)
         Console.WriteLine(La valeur de a + (b * c) / d est {0}, e);
         Console.ReadLine();
      }
   }
}

Lorsque le code ci-dessus est compilé et exécuté, il produit les résultats suivants :

(a + b) * c / d 的值是 90
((a + b) * c) / d 的值是 90
(a + b) * (c / d) 的值是 90
a + (b * c) / d 的值是 50

Précédence des opérateurs arithmétiques et des opérateurs d'affectation :

Exemple

int a = 10, b = 5, c = 2;
int result = a + b * c;  // Calculer d'abord la multiplication, puis l'addition
Console.WriteLine(result);  // sortie 20

result = (a + b) * c;     // Calculer d'abord l'addition, puis la multiplication
Console.WriteLine(result);  // sortie 30

a += b * c;               // Calculer d'abord la multiplication, puis effectuer l'affectation d'addition
Console.WriteLine(a);       // sortie 20

Précédence des opérateurs logiques :

Exemple


bool a = true, b = false, c = true;
bool result = a || b && c;  // Calculer d'abord l'opération AND, puis l'opération OR
Console.WriteLine(result);  // Sortie true

result = (a || b) && c;     // Calculer d'abord l'opération OR, puis l'opération AND
Console.WriteLine(result);  // Sortie true

result = a || (b && c);     // Calculer d'abord l'opération AND, puis l'opération OR
Console.WriteLine(result);  // Sortie true

Précédence des opérateurs conditionnels :

Exemple

int a = 10, b = 5;
string result = a > b ? "a est supérieur à b" : "a n'est pas supérieur à b";  // Déterminez d'abord la relation de taille, puis exécutez l'instruction conditionnelle
Console.WriteLine(result);  // Sortie "a est supérieur à b"

Remarque :Étant donné que les parenthèses peuvent modifier la priorité des opérateurs, dans les applications pratiques, il est recommandé d'utiliser autant que possible des parenthèses pour clarifier l'ordre des opérations et améliorer la lisibilité et l'exactitude du code.

autres extensions