Dans cet article, nous allons tout apprendre sur les différents types d'opérateurs dans le langage de programmation C # et comment les utiliser.
Les opérateurs sont des symboles utilisés pour effectuer des opérations sur des opérandes. Les opérandes peuvent être des variables et / ou des constantes.
Par exemple , dans 2+3, +est un opérateur qui est utilisé pour effectuer une opération d'addition, tandis que 2et 3sont des opérandes.
Les opérateurs sont utilisés pour manipuler des variables et des valeurs dans un programme. C # prend en charge un certain nombre d'opérateurs classés en fonction du type d'opérations qu'ils effectuent.
1. Opérateur d'affectation de base
L'opérateur d'affectation de base (=) est utilisé pour affecter des valeurs aux variables. Par exemple,
double X; x = 50,05;
Ici, 50,05 est attribué à x.
Exemple 1: Opérateur d'affectation de base
using System; namespace Operator ( class AssignmentOperator ( public static void Main(string() args) ( int firstNumber, secondNumber; // Assigning a constant to variable firstNumber = 10; Console.WriteLine("First Number = (0)", firstNumber); // Assigning a variable to another variable secondNumber = firstNumber; Console.WriteLine("Second Number = (0)", secondNumber); ) ) )
Lorsque nous exécutons le programme, la sortie sera:
Premier nombre = 10 Deuxième nombre = 10
Ceci est un exemple simple qui illustre l'utilisation de l'opérateur d'affectation.
Vous avez peut-être remarqué l'utilisation d'accolades ( )dans l'exemple. Nous en discuterons dans le formatage des chaînes. Pour l'instant, gardez simplement à l'esprit que (0)la première variable qui suit la chaîne (1)est remplacée par la deuxième variable et ainsi de suite.
2. Opérateurs arithmétiques
Les opérateurs arithmétiques sont utilisés pour effectuer des opérations arithmétiques telles que l'addition, la soustraction, la multiplication, la division, etc.
Par exemple,
int x = 5; int y = 10; int z = x + y; // z = 15Opérateurs arithmétiques C #
| Opérateur | Nom de l'opérateur | Exemple |
|---|---|---|
| + | Opérateur d'addition | 6 + 3 donne 9 |
| - | Opérateur de soustraction | 10 - 6 donne 4 |
| * | Opérateur de multiplication | 4 * 2 donne 8 |
| / | Opérateur de division | 10/5 donne 2 |
| % | Opérateur modulo (reste) | 16% 3 donne 1 |
Exemple 2: Opérateurs arithmétiques
using System; namespace Operator ( class ArithmeticOperator ( public static void Main(string() args) ( double firstNumber = 14.40, secondNumber = 4.60, result; int num1 = 26, num2 = 4, rem; // Addition operator result = firstNumber + secondNumber; Console.WriteLine("(0) + (1) = (2)", firstNumber, secondNumber, result); // Subtraction operator result = firstNumber - secondNumber; Console.WriteLine("(0) - (1) = (2)", firstNumber, secondNumber, result); // Multiplication operator result = firstNumber * secondNumber; Console.WriteLine("(0) * (1) = (2)", firstNumber, secondNumber, result); // Division operator result = firstNumber / secondNumber; Console.WriteLine("(0) / (1) = (2)", firstNumber, secondNumber, result); // Modulo operator rem = num1 % num2; Console.WriteLine("(0) % (1) = (2)", num1, num2, rem); ) ) )
Lorsque nous exécutons le programme, la sortie sera:
14,4 + 4,6 = 19 14,4 - 4,6 = 9,8 14,4 * 4,6 = 66,24 14,4 / 4,6 = 3,1304347826087 26% 4 = 2
Les opérations arithmétiques sont effectuées dans l'exemple ci-dessus. Les variables peuvent être remplacées par des constantes dans les instructions. Par exemple,
résultat = 4,5 + 2,7; // le résultat contiendra 7.2 result = firstNumber - 3.2; // le résultat tiendra 11.2
3. Opérateurs relationnels
Les opérateurs relationnels sont utilisés pour vérifier la relation entre deux opérandes. Si la relation est vraie, le résultat sera true, sinon il en résultera false.
Les opérateurs relationnels sont utilisés dans la prise de décision et les boucles.
Opérateurs relationnels C #| Opérateur | Nom de l'opérateur | Exemple |
|---|---|---|
| == | Égal à | 6 == 4 donne la valeur false |
| > | Plus grand que | 3> -1 prend la valeur true |
| < | Moins que | 5 <3 donne faux |
| > = | Plus grand ou égal à | 4> = 4 prend la valeur true |
| <= | Inférieur ou égal à | 5 <= 3 donne la valeur false |
| ! = | Pas égal à | 10! = 2 prend la valeur true |
Exemple 3: Opérateurs relationnels
using System; namespace Operator ( class RelationalOperator ( public static void Main(string() args) ( bool result; int firstNumber = 10, secondNumber = 20; result = (firstNumber==secondNumber); Console.WriteLine("(0) == (1) returns (2)",firstNumber, secondNumber, result); result = (firstNumber> secondNumber); Console.WriteLine("(0)> (1) returns (2)",firstNumber, secondNumber, result); result = (firstNumber < secondNumber); Console.WriteLine("(0) = secondNumber); Console.WriteLine("(0)>= (1) returns (2)",firstNumber, secondNumber, result); result = (firstNumber <= secondNumber); Console.WriteLine("(0) <= (1) returns (2)",firstNumber, secondNumber, result); result = (firstNumber != secondNumber); Console.WriteLine("(0) != (1) returns (2)",firstNumber, secondNumber, result); ) ) )
Lorsque nous exécutons le programme, la sortie sera:
10 == 20 renvoie False 10> 20 renvoie False 10 = 20 renvoie False 10 <= 20 renvoie Vrai 10! = 20 renvoie Vrai
4. Opérateurs logiques
Les opérateurs logiques sont utilisés pour effectuer une opération logique tel que and, or. Les opérateurs logiques opèrent sur des expressions booléennes ( trueet false) et retournent des valeurs booléennes. Les opérateurs logiques sont utilisés dans la prise de décision et les boucles.
Voici comment le résultat est évalué pour les opérateurs logiques ANDet OR.
| Opérande 1 | Opérande 2 | OU (||) | ET (&&) |
|---|---|---|---|
| vrai | vrai | vrai | vrai |
| vrai | faux | vrai | faux |
| faux | vrai | vrai | faux |
| faux | faux | faux | faux |
En termes simples, le tableau peut être résumé comme suit:
- Si l'un des opérandes est vrai, l'
ORopérateur l'évalueratrue. - Si l'un des opérandes est faux, l'
ANDopérateur l'évaluerafalse.
Exemple 4: Opérateurs logiques
using System; namespace Operator ( class LogicalOperator ( public static void Main(string() args) ( bool result; int firstNumber = 10, secondNumber = 20; // OR operator result = (firstNumber == secondNumber) || (firstNumber> 5); Console.WriteLine(result); // AND operator result = (firstNumber == secondNumber) && (firstNumber> 5); Console.WriteLine(result); ) ) )
Lorsque nous exécutons le programme, la sortie sera:
Vrai faux
5. Opérateurs unaires
Contrairement aux autres opérateurs, les opérateurs unaires opèrent sur un seul opérande.
Opérateurs unaires C #| Opérateur | Nom de l'opérateur | La description |
|---|---|---|
| + | Unaire Plus | Laisse le signe de l'opérande tel quel |
| - | Moins unaire | Inverse le signe de l'opérande |
| ++ | Incrément | Incrémenter la valeur de 1 |
| - | Décrémenter | Décrémenter la valeur de 1 |
| ! | Négation logique (non) | Inverse la valeur d'un booléen |
Exemple 5: Opérateurs unaires
using System; namespace Operator ( class UnaryOperator ( public static void Main(string() args) ( int number = 10, result; bool flag = true; result = +number; Console.WriteLine("+number = " + result); result = -number; Console.WriteLine("-number = " + result); result = ++number; Console.WriteLine("++number = " + result); result = --number; Console.WriteLine("--number = " + result); Console.WriteLine("!flag = " + (!flag)); ) ) )
Lorsque nous exécutons le programme, la sortie sera:
+ number = 10 -number = -10 ++ number = 11 --number = 10! flag = False
Les opérateurs d' incrémentation (++)et de décrémentation (--)peuvent être utilisés comme préfixe et suffixe. S'il est utilisé comme préfixe, le changement de valeur de variable est vu sur la même ligne et s'il est utilisé comme suffixe, le changement de valeur de variable est vu sur la ligne suivante. Cela sera clair par l'exemple ci-dessous.
Exemple 6: Opérateurs de post et pré-incrémentation en C #
using System; namespace Operator ( class UnaryOperator ( public static void Main(string() args) ( int number = 10; Console.WriteLine((number++)); Console.WriteLine((number)); Console.WriteLine((++number)); Console.WriteLine((number)); ) ) )
Lorsque nous exécutons le programme, la sortie sera:
10 11 12 12
We can see the effect of using ++ as prefix and postfix. When ++ is used after the operand, the value is first evaluated and then it is incremented by 1. Hence the statement
Console.WriteLine((number++));
prints 10 instead of 11. After the value is printed, the value of number is incremented by 1.
The process is opposite when ++ is used as prefix. The value is incremented before printing. Hence the statement
Console.WriteLine((++number));
prints 12.
The case is same for decrement operator (--).
6. Ternary Operator
The ternary operator ? : operates on three operands. It is a shorthand for if-then-else statement. Ternary operator can be used as follows:
variable = Condition? Expression1 : Expression2;
L'opérateur ternaire fonctionne comme suit:
- Si l'expression indiquée par Condition est
true, le résultat de Expression1 est affecté à variable. - Si tel est le cas
false, le résultat de Expression2 est affecté à la variable.
Exemple 7: opérateur ternaire
using System; namespace Operator ( class TernaryOperator ( public static void Main(string() args) ( int number = 10; string result; result = (number % 2 == 0)? "Even Number" : "Odd Number"; Console.WriteLine("(0) is (1)", number, result); ) ) )
Lorsque nous exécutons le programme, la sortie sera:
10 est un nombre pair
Pour en savoir plus, visitez l'opérateur ternaire C #.
7. Opérateurs de décalage de bits et de bits
Les opérateurs de bits et de décalage de bits sont utilisés pour effectuer des opérations de manipulation de bits.
Opérateurs C # Bitwise et Bit Shift| Opérateur | Nom de l'opérateur |
|---|---|
| ~ | Complément au niveau du bit |
| & | ET au niveau du bit |
| | | OU au niveau du bit |
| ^ | OU exclusif au niveau du bit |
| << | Décalage gauche au niveau du bit |
| >> | Décalage vers la droite au niveau du bit |
Exemple 8: Opérateur de décalage de bit et de bit
using System; namespace Operator ( class BitOperator ( public static void Main(string() args) ( int firstNumber = 10; int secondNumber = 20; int result; result = ~firstNumber; Console.WriteLine("~(0) = (1)", firstNumber, result); result = firstNumber & secondNumber; Console.WriteLine("(0) & (1) = (2)", firstNumber,secondNumber, result); result = firstNumber | secondNumber; Console.WriteLine("(0) | (1) = (2)", firstNumber,secondNumber, result); result = firstNumber secondNumber; Console.WriteLine("(0) (1) = (2)", firstNumber,secondNumber, result); result = firstNumber << 2; Console.WriteLine("(0) <> 2; Console.WriteLine("(0)>> 2 = (1)", firstNumber, result); ) ) )
Lorsque nous exécutons le programme, la sortie sera:
~ 10 = -11 10 et 20 = 0 10 | 20 = 30 10 20 = 30 10 <> 2 = 2
Pour en savoir plus, visitez les opérateurs C # Bitwise et Bit Shift.
8. Opérateurs d'affectation de composés
Opérateurs d'affectation de composés C #| Opérateur | Nom de l'opérateur | Exemple | Équivalent à |
|---|---|---|---|
| + = | Affectation d'ajout | x += 5 | x = x + 5 |
| - = | Affectation de soustraction | x -= 5 | x = x - 5 |
| * = | Affectation de multiplication | x *= 5 | x = x * 5 |
| / = | Affectation de division | x /= 5 | x = x / 5 |
| % = | Affectation du module | x %= 5 | x = x % 5 |
| & = | Affectation ET au niveau du bit | x &= 5 | x = x & 5 |
| | = | Affectation OR au niveau du bit | x |= 5 | x = x | 5 |
| = | Affectation XOR au niveau du bit | x ^= 5 | x = x 5 |
| << = | Affectation du décalage gauche | x <<= 5 | x = x << 5 |
| >> = | Affectation du décalage vers la droite | x>>= 5 | x = x>> 5 |
| => | Opérateur Lambda | x => x*x | Returns x*x |
Exemple 9: Opérateur d'affectation de composés
using System; namespace Operator ( class BitOperator ( public static void Main(string() args) ( int number = 10; number += 5; Console.WriteLine(number); number -= 3; Console.WriteLine(number); number *= 2; Console.WriteLine(number); number /= 3; Console.WriteLine(number); number %= 3; Console.WriteLine(number); number &= 10; Console.WriteLine(number); number |= 14; Console.WriteLine(number); number ^= 12; Console.WriteLine(number); number <>= 3; Console.WriteLine(number); ) ) )
Lorsque nous exécutons le programme, la sortie sera:
15 12 24 8 2 2 14 2 8 1
Nous discuterons des opérateurs Lambda dans un didacticiel ultérieur.
