Maison > Article > développement back-end > [Tutoriel c#] Opérateurs C#
[Tutoriel c#] Opérateurs C#
- 黄舟original
- 2016-12-26 14:11:461041parcourir
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.
46e861b9935ce888772af959b61a0856= 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.
560465ae6e9cd362ef4979b221d87e74> 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
2ae07beea27b22cf33a0557967238e99>= 右移且赋值运算符 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 从右到左
乘除 * / % 从左到右
加减 + - 从左到右
移位 10e3fdaca48eb0367c6d60dbc98f885d> 从左到右
关系 7cb9091baf3e2c81106f6565e75575c8 >= 从左到右
相等 == != 从左到右
位与 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）！