Les opérateurs sont la base de tout langage de programmation. Ainsi la fonctionnalité de C# le langage est incomplet sans l’utilisation d’opérateurs. Les opérateurs nous permettent d'effectuer différents types d'opérations sur opérandes . Dans C# , les opérateurs peuvent être catégorisés basé sur leur différent Fonctionnalité :

• Opérateurs arithmétiques
• Opérateurs relationnels
• Opérateurs logiques
• Opérateurs au niveau du bit
• Opérateurs d'affectation
• Opérateur conditionnel

En C#, les opérateurs peuvent également être classés basé sur le nombre d'opérandes :

• Opérateur unaire : Opérateur qui prend un opérande pour effectuer l’opération.
• Opérateur binaire : Opérateur qui prend deux opérandes pour effectuer l’opération.
• Opérateur ternaire : Opérateur qui prend trois opérandes pour effectuer l’opération.
  

Opérateurs arithmétiques

programme principal en java

Ceux-ci sont utilisés pour effectuer des opérations arithmétiques/mathématiques sur les opérandes. Le Opérateurs binaires entrant dans cette catégorie sont :

• Ajout: Le '+' L'opérateur ajoute deux opérandes. Par exemple, x+y .
• Soustraction: Le '-' L’opérateur soustrait deux opérandes. Par exemple, xy .
• Multiplication: Le '*' L'opérateur multiplie deux opérandes. Par exemple, x*y .
• Division: Le '/' L'opérateur divise le premier opérande par le second. Par exemple, x/y .
• Module : Le '%' L'opérateur renvoie le reste lorsque le premier opérande est divisé par le second. Par exemple, x%y .

Exemple:

// C# program to demonstrate the working  // of Binary Arithmetic Operators using System; namespace Arithmetic {  class GFG  {    // Main Function  static void Main(string[] args)  {    int result;  int x = 10, y = 5;    // Addition  result = (x + y);  Console.WriteLine('Addition Operator: ' + result);    // Subtraction  result = (x - y);  Console.WriteLine('Subtraction Operator: ' + result);    // Multiplication  result = (x * y);  Console.WriteLine('Multiplication Operator: '+ result);    // Division  result = (x / y);  Console.WriteLine('Division Operator: ' + result);    // Modulo  result = (x % y);  Console.WriteLine('Modulo Operator: ' + result);  }  } }>

Sortir:

Addition Operator: 15 Subtraction Operator: 5 Multiplication Operator: 50 Division Operator: 2 Modulo Operator: 0>

Ceux qui entrent dans la catégorie des Opérateurs unaires sont:

• Incrément: Le '++' L’opérateur est utilisé pour incrémenter la valeur d’un entier. Lorsqu'il est placé avant le nom de la variable (également appelé pré-incrémentation opérateur), sa valeur est incrémentée instantanément. Par exemple, ++x .
  Et lorsqu'il est placé après le nom de la variable (aussi appelé opérateur de post-incré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++ .
• Décrément : Le '- -' L’opérateur est utilisé pour décrémenter la valeur d’un entier. Lorsqu'il 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 lorsqu'il est placé après le nom de la variable (aussi appelé opérateur de 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:

// C# program to demonstrate the working  // of Unary Arithmetic Operators using System; namespace Arithmetic {    class GFG {    // Main Function  static void Main(string[] args)  {    int a = 10, res;    // post-increment example:  // res is assigned 10 only,   // a is not updated yet  res = a++;    //a becomes 11 now  Console.WriteLine('a is {0} and res is {1}', a, res);      // post-decrement example:  // res is assigned 11 only, a is not updated yet  res = a--;    //a becomes 10 now  Console.WriteLine('a is {0} and res is {1}', a, res);       // pre-increment example:  // res is assigned 11 now since a  // is updated here itself  res = ++a;    // a and res have same values = 11  Console.WriteLine('a is {0} and res is {1}', a, res);      // pre-decrement example:  // res is assigned 10 only since  // a is updated here itself  res = --a;    // a and res have same values = 10  Console.WriteLine('a is {0} and res is {1}',a, res);       }  } }>

Sortir:

a is 11 and res is 10 a is 10 and res is 11 a is 11 and res is 11 a is 10 and res is 10>

Opérateurs relationnels

Les opérateurs relationnels sont utilisés pour comparer deux valeurs. Voyons-les un par un :

• '==' (Égal à) L'opérateur vérifie si les deux opérandes donnés sont égaux ou non. Si c'est le cas, cela renvoie vrai. Sinon, il renvoie faux. Par exemple, 5==5 reviendra vrai.
• '!='(Différent de) L'opérateur vérifie si les deux opérandes donnés sont égaux ou non. Sinon, cela renvoie vrai. Sinon, il renvoie faux. C'est le complément booléen exact de '==' opérateur. Par exemple, 5!=5 renverra faux.
• '>' (Supérieur à) L'opérateur vérifie si le premier opérande est supérieur au deuxième opérande. Si c'est le cas, cela renvoie vrai. Sinon, il renvoie faux. Par exemple, 6>5 reviendra vrai.
• '<'(Inférieur à) L'opérateur vérifie si le premier opérande est inférieur au deuxième opérande. Si c'est le cas, cela renvoie vrai. Sinon, il renvoie faux. Par exemple, 6<5 renverra faux.
• '>=' (Supérieur à égal à) 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 renvoie vrai. Sinon, il renvoie faux. Par exemple, 5>=5 reviendra vrai.
• '<=' (inférieur à égal à) 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 renvoie vrai. Sinon, il renvoie faux. Par exemple, 5<=5 reviendra également vrai.

Exemple:

// C# program to demonstrate the working  // of Relational Operators using System; namespace Relational {   class GFG {    // Main Function  static void Main(string[] args)  {  bool result;  int x = 5, y = 10;    // Equal to Operator  result = (x == y);  Console.WriteLine('Equal to Operator: ' + result);    // Greater than Operator  result = (x>y);  Console.WriteLine('Supérieur à l'opérateur : ' + résultat);    // Inférieur à Résultat de l'opérateur = (x< y);  Console.WriteLine('Less than Operator: ' + result);    // Greater than Equal to Operator  result = (x>= y);  Console.WriteLine('Supérieur ou égal à : '+ résultat);    // Inférieur à égal au résultat de l'opérateur = (x<= y);  Console.WriteLine('Lesser than or Equal to: '+ result);    // Not Equal To Operator  result = (x != y);  Console.WriteLine('Not Equal to Operator: ' + result);  } } }>

Sortir:

Equal to Operator: False Greater than Operator: False Less than Operator: True Greater than or Equal to: False Lesser than or Equal to: True Not Equal to Operator: True>

Opérateurs logiques

Elles sont utilisées pour combiner deux ou plusieurs conditions/contraintes ou pour compléter l'évaluation de la condition d'origine prise en compte. Ils sont décrits ci-dessous :

• ET logique : Le '&&' L’opérateur renvoie vrai lorsque les deux conditions prises en compte sont remplies. Sinon, il renvoie faux. Par exemple, un B renvoie vrai lorsque a et b sont tous deux vrais (c'est-à-dire non nuls).
• OU logique : Le '||' L’opérateur renvoie vrai lorsqu’une (ou les deux) des conditions prises en compte est remplie. Sinon, il renvoie faux. Par exemple, un || b renvoie vrai si l'un des a ou b est vrai (c'est-à-dire différent de zéro). Bien sûr, cela renvoie vrai lorsque a et b sont vrais.
• NON logique : Le '!' L'opérateur renvoie vrai, la condition prise en compte n'est pas satisfaite. Sinon, il renvoie faux. Par exemple, !un renvoie vrai si a est faux, c'est-à-dire lorsque a=0.

Exemple:

// C# program to demonstrate the working  // of Logical Operators using System; namespace Logical {   class GFG {    // Main Function  static void Main(string[] args)   } }>

Sortir:

chaîne java avec format

AND Operator: False OR Operator: True NOT Operator: False>

Opérateurs au niveau du bit

En C#, il existe 6 opérateurs au niveau du bit qui fonctionnent au niveau bit ou utilisés pour effectuer des opérations bit par bit. Voici les opérateurs au niveau du bit :

• & (ET au niveau du bit) Prend deux nombres comme opérandes et effectue AND sur chaque bit de deux nombres. Le résultat de AND est 1 uniquement si les deux bits sont 1.
• | (OU au niveau du bit) Prend deux nombres comme opérandes et effectue OU sur chaque bit de deux nombres. Le résultat du OU est 1, l'un des deux bits est 1.
• ^ (XOR au niveau du bit) Prend deux nombres comme opérandes et effectue XOR sur chaque bit de deux nombres. Le résultat de XOR est 1 si les deux bits sont différents.
• ~ (Complément au niveau du bit) Prend un nombre comme opérande et inverse chaque bit qui est 1 à 0 et 0 à 1.
• << (décalage à gauche) Prend deux nombres, décale à gauche les bits du premier opérande, le deuxième opérande décide du nombre de places à décaler.
• >> (décalage à droite) Prend deux nombres, décale vers la droite les bits du premier opérande, le deuxième opérande décide du nombre de places à décaler.

Exemple:

// C# program to demonstrate the working  // of Bitwise Operators using System; namespace Bitwise {   class GFG {    // Main Function  static void Main(string[] args)    int x = 5, y = 10, result;    // Bitwise AND Operator  result = x & y;  Console.WriteLine('Bitwise AND: ' + result);    // Bitwise OR Operator  result = x  } }>

Sortir:

Bitwise AND: 0 Bitwise OR: 15 Bitwise XOR: 15 Bitwise Complement: -6 Bitwise Left Shift: 20 Bitwise Right Shift: 1>

Opérateurs d'affectation

Les opérateurs d'affectation sont utilisés pour attribuer une valeur à une variable. L'opérande du côté gauche de l'opérateur d'affectation est une variable et l'opérande du côté droit de l'opérateur d'affectation est une valeur. La valeur du côté droit doit être du même type de données que la variable du côté gauche, sinon le compilateur générera une erreur.

Différents types d'opérateurs d'affectation sont présentés ci-dessous :

• =(Affectation simple) : C'est l'opérateur d'affectation le plus simple. Cet opérateur permet d'attribuer la valeur de droite à la variable de gauche.
  Exemple:

a = 10; b = 20; ch = 'y';>

• +=(Ajouter une affectation) : Cet opérateur est une combinaison d'opérateurs '+' et '='. Cet opérateur ajoute d'abord la valeur actuelle de la variable de gauche à la valeur de droite, puis affecte le résultat à la variable de gauche.
  Exemple:

(a += b) can be written as (a = a + b)>

Si initialement la valeur stockée dans a est 5. Alors (a += 6) = 11.

• -=(Soustraire l'affectation) : Cet opérateur est une combinaison d'opérateurs '-' et '='. Cet opérateur soustrait d'abord la valeur actuelle de la variable de gauche de la valeur de droite, puis affecte le résultat à la variable de gauche.
  Exemple:

(a -= b) can be written as (a = a - b)>

Si initialement la valeur stockée dans a est 8. Alors (a -= 6) = 2.

• *=(Multiplier l'affectation) : Cet opérateur est une combinaison d'opérateurs '*' et '='. Cet opérateur multiplie d'abord la valeur actuelle de la variable de gauche par la valeur de droite, puis affecte le résultat à la variable de gauche.
  Exemple:

(a *= b) can be written as (a = a * b)>

Si la valeur initiale stockée dans a est 5. Alors (a *= 6) = 30.

• /=(Affectation de division) : Cet opérateur est une combinaison d’opérateurs « / » et « = ». Cet opérateur divise d'abord la valeur actuelle de la variable de gauche par la valeur de droite, puis affecte le résultat à la variable de gauche.
  Exemple:

(a /= b) can be written as (a = a / b)>

Si initialement la valeur stockée dans a est 6. Alors (a /= 2) = 3.

• %=(Affectation du module) : Cet opérateur est une combinaison d’opérateurs « % » et « = ». Cet opérateur modulo d'abord la valeur actuelle de la variable de gauche par la valeur de droite puis affecte le résultat à la variable de gauche.
  Exemple:

(a %= b) can be written as (a = a % b)>

Si la valeur initiale stockée dans a est 6. Alors (a %= 2) = 0.

• <<=(Affectation du décalage vers la gauche) : Cet opérateur est une combinaison d'opérateurs '<<' et '='. Cet opérateur décale d'abord à gauche la valeur actuelle de la variable de gauche de la valeur de droite, puis affecte le résultat à la variable de gauche.
  Exemple:

(a <<= 2) can be written as (a = a << 2)>

Si initialement la valeur stockée dans a est 6. Alors (a <<= 2) = 24.

• >>=(Affectation du décalage vers la droite) : Cet opérateur est une combinaison d'opérateurs '>>' et '='. Cet opérateur décale d'abord vers la droite la valeur actuelle de la variable de gauche de la valeur de droite, puis affecte le résultat à la variable de gauche.
  Exemple:

(a>>= 2) peut s'écrire sous la forme (a = a>> 2)>

Si initialement la valeur stockée dans a est 6. Alors (a>>= 2) = 1.

• &=(Au niveau du bit ET Affectation) : Cet opérateur est une combinaison d'opérateurs '&' et '='. Cet opérateur d'abord au niveau du bit ET la valeur actuelle de la variable de gauche par la valeur de droite, puis affecte le résultat à la variable de gauche.
  Exemple:

(a &= 2) can be written as (a = a & 2)>

Si initialement la valeur stockée dans a est 6. Alors (a &= 2) = 2.

• ^= (OU exclusif au niveau du bit) : Cet opérateur est une combinaison d'opérateurs '^' et '='. Cet opérateur d'abord Bitwise Exclusive OU la valeur actuelle de la variable de gauche par la valeur de droite, puis affecte le résultat à la variable de gauche.
  Exemple:

(a ^= 2) can be written as (a = a ^ 2)>

Si initialement la valeur stockée dans a est 6. Alors (a ^= 2) = 4.

• |=(OU inclusif au niveau du bit) : Cet opérateur est une combinaison d'opérateurs '|' et '='. Cet opérateur d'abord Bitwise Inclusive OU la valeur actuelle de la variable de gauche par la valeur de droite, puis affecte le résultat à la variable de gauche.
  Exemple :

(a |= 2) can be written as (a = a | 2)>

Si initialement, la valeur stockée dans a est 6. Alors (a |= 2) = 6.

Exemple:

// C# program to demonstrate the working  // of Assignment Operators using System; namespace Assignment {   class GFG {    // Main Function  static void Main(string[] args)  = 4;   Console.WriteLine('Bitwise Inclusive OR Assignment Operator: ' + x);     } }>

Sortir :

Add Assignment Operator: 25 Subtract Assignment Operator: 15 Multiply Assignment Operator: 75 Division Assignment Operator: 5 Modulo Assignment Operator: 0 Left Shift Assignment Operator: 32 Right Shift Assignment Operator: 2 Bitwise AND Assignment Operator: 4 Bitwise Exclusive OR Assignment Operator: 8 Bitwise Inclusive OR Assignment Operator: 12>

Opérateur conditionnel

Il s'agit d'un opérateur ternaire qui est une version abrégée de l'instruction if-else. Il a trois opérandes d’où le nom de ternaire. Il renverra l'une des deux valeurs en fonction de la valeur d'une expression booléenne.

Syntaxe:

condition ? first_expression : second_expression;>

Explication:
condition : elle doit être évaluée à vrai ou faux.
Si la condition est vraie
first_expression est évaluée et devient le résultat.
Si la condition est fausse,
second_expression est évalué et devient le résultat.

exemples de systèmes d'exploitation

Exemple:

// C# program to demonstrate the working  // of Conditional Operator using System; namespace Conditional {   class GFG {    // Main Function  static void Main(string[] args)  {  int x = 5, y = 10, result;    // To find which value is greater  // Using Conditional Operator  result = x>oui ? x : oui;     // Pour afficher le résultat Console.WriteLine('Result: ' + result);    // Pour trouver quelle valeur est la plus grande // Utilisation de l'opérateur conditionnel result = x< y ? x : y;     // To display the result  Console.WriteLine('Result: ' + result);  } } }>

Sortir :

Result: 10 Result: 5>