Opérateurs C#
Un opérateur est un symbole qui indique au compilateur d'effectuer une opération mathématique ou logique spécifique. C# possède un riche ensemble d'opérateurs intégrés, qui sont classés comme suit :
Opérateurs arithmétiques
Opérateurs relationnels
Opérateurs logiques
Opérateurs au niveau du bit
Opérateurs d'affectation
Opérateurs divers
Ce tutoriel expliquera les opérateurs arithmétiques, les opérateurs relationnels, les opérateurs logiques, les opérateurs au niveau du bit, les opérateurs d'affectation et les autres opérateurs un par un.
Opérateurs arithmétiques
Le tableau suivant présente tous les opérateurs arithmétiques pris en charge par C#. Supposons que la valeur de la variable A est 10 et la valeur de la variable B est 20, alors :
Opérateur
Description
Instance
L'addition des deux opérandes A B obtiendra 30
- Soustraire le deuxième opérande A - B du premier opérande obtiendra -10
* Multiplier les deux opérandes A * B obtiendra 200
/ Divisez le numérateur par le dénominateur B / A obtiendra 2
% Opérateur Modulo, le reste après division entière B % A obtiendra 0
Opérateur d'incrémentation, la valeur entière augmente de 1 A obtiendra 11
-- Opérateur de décrémentation, la valeur entière diminue de 1 A-- obtiendra 9
Exemple
S'il vous plaît consultez l'exemple suivant pour en savoir plus sur tous les opérateurs arithmétiques disponibles en C# :
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); 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; ", c ); c = a;
console.writeline (" La valeur de la ligne 6-C est {0} ",
c = a-; la valeur de c est {0}", c);
Console.ReadLine(); Lorsque le code est compilé et exécuté, il produit les résultats suivants :
Ligne 1 - La valeur de c est 31
Ligne 2 - La valeur de c est 11
Ligne 3 - La valeur de c est 210
Ligne 4 - La valeur de c est 2
Ligne 5 - La valeur de c est 1
Ligne 6 - La valeur de c est 21
Ligne 7 - La valeur de c est 22
Opérateur
Description
Instance
== Vérifie si les valeurs des deux opérandes sont égales. Si elles sont égales, la condition est vraie. (A == B) n'est pas vrai.
!= Vérifie si les valeurs des deux opérandes sont égales. Si elles ne sont pas égales, la condition est vraie. (A != B) est vrai.
> Vérifiez si la valeur de l'opérande de gauche est supérieure à la valeur de l'opérande de droite, si c'est le cas, la condition est vraie. (A > B) n’est pas vrai.
< Vérifiez si la valeur de l'opérande de gauche est inférieure à la valeur de l'opérande de droite, si c'est le cas, la condition est vraie. (A &Lt ; B) est vrai.
>= Vérifiez si la valeur de l'opérande de gauche est supérieure ou égale à la valeur de l'opérande de droite, si c'est le cas, la condition est vraie. (A >= B) n’est pas vrai.
<= Vérifiez si la valeur de l'opérande de gauche est inférieure ou égale à la valeur de l'opérande de droite, si c'est le cas, la condition est vraie. (A <= B) est vrai.
Exemple
Veuillez consulter l'exemple ci-dessous pour en savoir plus sur tous les opérateurs relationnels disponibles en C# :
using System;
class Program
{
static void Main(string[] args)
{
int a = 21;
int b = 10;
if (a == b)
{
Console.WriteLine("Line 1 - a 等于 b");
}
else
{
Console.WriteLine("Line 1 - a 不等于 b");
}
if (a < b)
{
Console.WriteLine("Line 2 - a 小于 b");
}
else
{
Console.WriteLine("Line 2 - a 不小于 b");
}
if (a > b)
{
Console.WriteLine("Line 3 - a 大于 b");
}
else
{
Console.WriteLine("Line 3 - a 不大于 b");
}
/* 改变 a 和 b 的值 */
a = 5;
b = 20;
if (a <= b)
{
Console.WriteLine("Line 4 - a 小于或等于 b");
}
if (b >= a)
{
Console.WriteLine("Line 5 - b 大于或等于 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 variable A est une valeur booléenne vraie et que la variable B est une valeur booléenne fausse, alors :
Opérateur
Description
Instance
&& est appelé l'opérateur logique AND. La condition est vraie si les deux opérandes sont non nuls. (A && B) est faux.
|| est appelé l'opérateur logique OU. La condition est vraie si l’un des deux opérandes est différent de zéro. (A || B) est vrai.
! est appelé l'opérateur NON logique. Utilisé pour inverser l'état logique de l'opérande. L'opérateur logique NON rendra la condition fausse si elle est vraie. !(A && B) est vrai.
Exemple
Veuillez consulter l'exemple ci-dessous pour comprendre tous les opérateurs logiques disponibles en C# :
using System;
namespace OperatorsAppl
{
class Program
{
static void Main(string[] args)
{
bool a = true;
bool b = true;
if (a && b)
{
Console.WriteLine("Line 1 - 条件为真");
}
if (a || b)
{
Console.WriteLine("Line 2 - 条件为真");
}
/* 改变 a 和 b 的值 */
a = false;
b = true;
if (a && b)
{
Console.WriteLine("Line 3 - 条件为真");
}
else
{
Console.WriteLine("Line 3 - 条件不为真");
}
if (!(a && b))
{
Console.WriteLine("Line 4 - 条件为真");
}
Console.ReadLine();
}
}
}Lorsque le code ci-dessus est compilé et exécuté, il produit le résultats suivants :
Line 1 - 条件为真 Line 2 - 条件为真 Line 3 - 条件不为真 Line 4 - 条件为真
Opérateurs au niveau du bit
Les opérateurs au niveau du bit agissent sur les bits et effectuent des opérations petit à petit. La table de vérité pour &, | et ^ est la suivante :
p
q
p & q
p | q
p ^ q
0 0 0 0 0 0
0 1 0 1 1 1
1 1 1 1 0
1 0 0 1 1
Supposons que si A = 60, et B = 13, maintenant exprimés au 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 au niveau du bit pris en charge par C#. Supposons que la valeur de la variable A est 60 et la valeur de la variable B est 13, alors :
Opérateur
Description
Instance
& S'il est présent dans les deux opérandes, l'opérateur binaire AND copie un bit dans le résultat. (A & B) donnera 12, soit 0000 1100
| S'il est présent dans l'un ou l'autre des opérandes, l'opérateur binaire OU copie un bit dans le résultat. (A | B) obtiendra 61, soit 0011 1101
^ S'il existe dans l'un des opérandes mais pas dans les deux, l'opérateur binaire XOR copie un bit dans le résultat . (A ^ B) obtiendra 49, soit 0011 0001
~ L'opérateur complément à deux est un opérateur unaire et a pour effet de "retourner" les bits. (~A) obtiendra -61, soit 1100 0011, complément à 2, nombre binaire signé.
<< Opérateur de décalage binaire vers la gauche. La valeur de l'opérande de gauche est décalée vers la gauche du nombre de bits spécifié par l'opérande de droite. Un << 2 obtiendra 240, soit 1111 0000
>> 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 obtiendra 15, soit 0000 1111
Exemple
Veuillez consulter l'exemple ci-dessous pour en savoir plus sur tous les opérateurs au niveau du bit disponibles en C# :
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("Line 1 - c 的值是 {0}", c );
c = a | b; /* 61 = 0011 1101 */
Console.WriteLine("Line 2 - c 的值是 {0}", c);
c = a ^ b; /* 49 = 0011 0001 */
Console.WriteLine("Line 3 - c 的值是 {0}", c);
c = ~a; /*-61 = 1100 0011 */
Console.WriteLine("Line 4 - c 的值是 {0}", c);
c = a << 2; /* 240 = 1111 0000 */
Console.WriteLine("Line 5 - c 的值是 {0}", c);
c = a >> 2; /* 15 = 0000 1111 */
Console.WriteLine("Line 6 - c 的值是 {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érateur
Description
Instance
= 简单的赋值运算符，把右边操作数的值赋给左边操作数 C = A + B 将把 A + B 的值赋给 C
+= 加且赋值运算符，把右边操作数加上左边操作数的结果赋值给左边操作数 C += A 相当于 C = C + A
-= 减且赋值运算符，把左边操作数减去右边操作数的结果赋值给左边操作数 C -= A 相当于 C = C - A
*= 乘且赋值运算符，把右边操作数乘以左边操作数的结果赋值给左边操作数 C *= A 相当于 C = C * A
/= 除且赋值运算符，把左边操作数除以右边操作数的结果赋值给左边操作数 C /= A 相当于 C = C / A
%= 求模且赋值运算符，求两个操作数的模赋值给左边操作数 C %= A 相当于 C = C % A
<<= 左移且赋值运算符 C <<= 2 等同于 C = C << 2
>>= 右移且赋值运算符 C >>= 2 等同于 C = C >> 2
&= 按位与且赋值运算符 C &= 2 等同于 C = C & 2
^= 按位异或且赋值运算符 C ^= 2 等同于 C = C ^ 2
|= 按位或且赋值运算符 C |= 2 等同于 C = C | 2
实例
请看下面的实例，了解 C# 中所有可用的赋值运算符：
using System;
namespace OperatorsAppl
{
class Program
{
static void Main(string[] args)
{
int a = 21;
int c;
c = a;
Console.WriteLine("Line 1 - = c 的值 = {0}", c);
c += a;
Console.WriteLine("Line 2 - += c 的值 = {0}", c);
c -= a;
Console.WriteLine("Line 3 - -= c 的值 = {0}", c);
c *= a;
Console.WriteLine("Line 4 - *= c 的值 = {0}", c);
c /= a;
Console.WriteLine("Line 5 - /= c 的值 = {0}", c);
c = 200;
c %= a;
Console.WriteLine("Line 6 - %= c 的值 = {0}", c);
c <<= 2;
Console.WriteLine("Line 7 - <<= c 的值 = {0}", c);
c >>= 2;
Console.WriteLine("Line 8 - >>= c 的值 = {0}", c);
c &= 2;
Console.WriteLine("Line 9 - &= c 的值 = {0}", c);
c ^= 2;
Console.WriteLine("Line 10 - ^= c 的值 = {0}", c);
c |= 2;
Console.WriteLine("Line 11 - |= c 的值 = {0}", c);
Console.ReadLine();
}
}
}当上面的代码被编译和执行时，它会产生下列结果：
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
杂项运算符
下表列出了 C# 支持的其他一些重要的运算符，包括 sizeof、typeof 和 ? :。
运算符描述实例 sizeof()返回数据类型的大小。sizeof(int)，将返回 4. typeof()返回 class 的类型。typeof(StreamReader); &返回变量的地址。&a; 将得到变量的实际地址。 *变量的指针。*a; 将指向一个变量。 ? :条件表达式 如果条件为真 ? 则为 X : 否则为 Y is判断对象是否为某一类型。If( Ford is Car) // 检查 Ford 是否是 Car 类的一个对象。 as强制转换，即使转换失败也不会抛出异常。Object obj = new StringReader("Hello");
StringReader r = obj as StringReader;
实例
using System;
namespace OperatorsAppl
{
class Program
{
static void Main(string[] args)
{
/* sizeof 运算符的实例 */
Console.WriteLine("int 的大小是 {0}", sizeof(int));
Console.WriteLine("short 的大小是 {0}", sizeof(short));
Console.WriteLine("double 的大小是 {0}", sizeof(double));
/* 三元运算符符的实例 */
int a, b;
a = 10;
b = (a == 1) ? 20 : 30;
Console.WriteLine("b 的值是 {0}", b);
b = (a == 10) ? 20 : 30;
Console.WriteLine("b 的值是 {0}", b);
Console.ReadLine();
}
}当上面的代码被编译和执行时，它会产生下列结果：
int 的大小是 4 short 的大小是 2 double 的大小是 8 b 的值是 30 b 的值是 20
C# 中的运算符优先级
运算符的优先级确定表达式中项的组合。这会影响到一个表达式如何计算。某些运算符比其他运算符有更高的优先级，例如，乘除运算符具有比加减运算符更高的优先级。
例如 x = 7 + 3 * 2，在这里，x 被赋值为 13，而不是 20，因为运算符 * 具有比 + 更高的优先级，所以首先计算乘法 3*2，然后再加上 7。
下表将按运算符优先级从高到低列出各个运算符，具有较高优先级的运算符出现在表格的上面，具有较低优先级的运算符出现在表格的下面。在表达式中，较高优先级的运算符会优先被计算。
类别
运算符
结合性
后缀 () [] -> . ++ - - 从左到右
一元 + - ! ~ ++ - - (type)* & sizeof 从右到左
乘除 * / % 从左到右
加减 + - 从左到右
移位 << >> 从左到右
关系 < <= > >= 从左到右
相等 == != 从左到右
位与 AND & 从左到右
位异或 XOR ^ 从左到右
位或 OR | 从左到右
逻辑与 AND && 从左到右
逻辑或 OR || 从左到右
条件 ?: 从右到左
赋值 = += -= *= /= %=>>= <<= &= ^= |= 从右到左
逗号 , 从左到右
实例
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("(a + b) * c / d 的值是 {0}", e);
e = ((a + b) * c) / d; // (30 * 15 ) / 5
Console.WriteLine("((a + b) * c) / d 的值是 {0}", e);
e = (a + b) * (c / d); // (30) * (15/5)
Console.WriteLine("(a + b) * (c / d) 的值是 {0}", e);
e = a + (b * c) / d; // 20 + (150/5)
Console.WriteLine("a + (b * c) / d 的值是 {0}", e);
Console.ReadLine();
}
}
}当上面的代码被编译和执行时，它会产生下列结果：
(a + b) * c / d 的值是 90 ((a + b) * c) / d 的值是 90 (a + b) * (c / d) 的值是 90 a + (b * c) / d 的值是 50
以上就是【c#教程】C# 运算符的内容，更多相关内容请关注PHP中文网（www.php.cn）！
![[Web front-end] Démarrage rapide de Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
