C#-Operatoren
Ein Operator ist ein Symbol, das den Compiler anweist, eine bestimmte mathematische oder logische Operation auszuführen. C# verfügt über einen umfangreichen Satz integrierter Operatoren, die wie folgt klassifiziert sind:
Arithmetische Operatoren
Relationale Operatoren
Logische Operatoren
Bitweise Operatoren
Zuweisungsoperatoren
Verschiedene Operatoren
In diesem Tutorial werden arithmetische Operatoren, relationale Operatoren, logische Operatoren, bitweise Operatoren, Zuweisungsoperatoren und andere Operatoren nacheinander erklärt.
Arithmetische Operatoren
Die folgende Tabelle zeigt alle von C# unterstützten arithmetischen Operatoren. Angenommen, der Wert der Variablen A ist 10 und der Wert der Variablen B ist 20, dann gilt:
Operator
Beschreibung
Instanz
+ Addiere die beiden Operanden A + B und erhalte 30
- Subtrahiere den zweiten Operanden A - B vom ersten Operanden und erhalte -10
* Multipliziere die beiden Operanden A * B erhalten 200
/ Teilen Sie den Zähler durch den Nenner B / A erhalten Sie 2
% Modulo-Operator, nach ganzzahliger Division Der Rest von B % A erhält 0
++ Auto-Inkrement-Operator, der ganzzahlige Wert erhöht sich um 1 A++ erhält 11
-- Dekrement-Operator, der ganzzahlige Wert verringert sich um 1 A-- erhält 9
Instanzen
Bitte sehen Sie sich das folgende Beispiel an, um mehr über alle in C# verfügbaren arithmetischen Operatoren zu erfahren:
using System;
namespace OperatorsAppl
{
class Programm
{
static void Main(string[] args)
int c;
c = a + b;
Console.WriteLine("Der Wert von Zeile 1 - c ist {0}", c);
c = a - b;
Console.W riteLine( "Der Wert von Zeile 2 - c ist {0}", c);
c = a * b;
Console.WriteLine("Der Wert von Zeile 3 - c ist {0}", c);
C = A / B
C =Riteline ("Zeile 4 -C-Wert ist {; 0}", c);
c = a % b;
console.writline ("Zeile 5 – Der Wert von c ist {0}", c);
c = a++;
Console.WriteLine("Zeile 6 - Der Wert von c ist {0}", c);
c = a-- ;
Console.WriteLine("Zeile 7 - Der Wert von c ist {0}" , c);
Console.ReadLine();
}
}
}
Wenn der obige Code kompiliert und ausgeführt wird, erzeugt er die folgenden Ergebnisse:
Zeile 2 – Der Wert von c ist 11
Zeile 3 – Der Wert von c ist 210Zeile 4 – Der Wert von c ist 2
Zeile 5 – Der Wert von c ist 1
Zeile 6 – Der Wert von c ist 21
Zeile 7 – Der Wert von c ist 22
Relationale Operatoren
== Prüft, ob die Werte der beiden Operanden gleich sind. Wenn sie gleich sind, ist die Bedingung wahr. (A == B) ist nicht wahr. != Prüft, ob die Werte der beiden Operanden gleich sind. Wenn sie nicht gleich sind, ist die Bedingung wahr. (A != B) ist wahr. > Überprüfen Sie, ob der Wert des linken Operanden größer ist als der Wert des rechten Operanden. Wenn ja, ist die Bedingung wahr. (A > B) ist nicht wahr. < Überprüfen Sie, ob der Wert des linken Operanden kleiner ist als der Wert des rechten Operanden. Wenn ja, ist die Bedingung wahr. (A < B) ist wahr.
>= Überprüfen Sie, ob der Wert des linken Operanden größer oder gleich dem Wert des rechten Operanden ist. Wenn ja, ist die Bedingung wahr. (A >= B) ist nicht wahr.
<= Überprüfen Sie, ob der Wert des linken Operanden kleiner oder gleich dem Wert des rechten Operanden ist. Wenn ja, ist die Bedingung wahr. (A <= B) ist wahr.
Beispiel
Sehen Sie sich das folgende Beispiel an, um mehr über alle in C# verfügbaren relationalen Operatoren zu erfahren:
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");
}
}
}Wenn der obige Code kompiliert und ausgeführt wird, wird er erzeugt die folgenden Ergebnisse:
Line 1 - a 不等于 b Line 2 - a 不小于 b Line 3 - a 大于 b Line 4 - a 小于或等于 b Line 5 - b 大于或等于 a
Logische Operatoren
Die folgende Tabelle zeigt alle von C# unterstützten logischen Operatoren. Nehmen Sie an, dass Variable A ein boolescher Wert „true“ und Variable B ein boolescher Wert „false“ ist, dann:
Operator
Beschreibung
Instanz
&& wird als logischer UND-Operator bezeichnet. Die Bedingung ist wahr, wenn beide Operanden ungleich Null sind. (A && B) ist falsch.
|| wird als logischer ODER-Operator bezeichnet. Die Bedingung ist wahr, wenn einer der beiden Operanden ungleich Null ist. (A || B) ist wahr.
! wird als logischer NOT-Operator bezeichnet. Wird verwendet, um den logischen Zustand des Operanden umzukehren. Der logische NOT-Operator macht die Bedingung falsch, wenn sie wahr ist. !(A && B) ist wahr.
Beispiel
Bitte sehen Sie sich das folgende Beispiel an, um alle in C# verfügbaren logischen Operatoren zu verstehen:
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();
}
}
}Wenn der obige Code kompiliert und ausgeführt wird, wird er erzeugt folgende Ergebnisse:
Line 1 - 条件为真 Line 2 - 条件为真 Line 3 - 条件不为真 Line 4 - 条件为真
Bitweise Operatoren
Bitweise Operatoren wirken auf Bits und führen Operationen Stück für Stück aus. Die Wahrheitstabelle für &, |. und ^ lautet wie folgt:
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
Angenommen, wenn A = 60 und B = 13, jetzt im Binärformat ausgedrückt, lauten sie wie folgt:
A = 0011 1100
B = 0000 1101
-----------------
A&B = 0000 1100
A |B = 0011 1101
A^B = 0011 0001
~A = 1100 0011
In der folgenden Tabelle sind die von C# unterstützten bitweisen Operatoren aufgeführt. Angenommen, der Wert der Variablen A ist 60 und der Wert der Variablen B ist 13, dann:
Operator
Beschreibung
Instanz
& Wenn in beiden Operanden vorhanden, kopiert der binäre UND-Operator ein Bit in das Ergebnis. (A & B) ergibt 12, also 0000 1100
| Wenn in einem der Operanden vorhanden, kopiert der binäre ODER-Operator ein Bit in das Ergebnis. (A | B) erhält 61, also 0011 1101
^ Wenn es in einem der Operanden existiert, aber nicht in beiden, kopiert der binäre XOR-Operator ein Bit in das Ergebnis. (A ^ B) erhält 49, also 0011 0001
~ Der Zweierkomplementoperator ist ein unärer Operator und hat den Effekt, dass Bits „umgedreht“ werden. (~A) erhält -61, also 1100 0011, Zweierkomplement, vorzeichenbehaftete Binärzahl.
<< Binärer Linksverschiebungsoperator. Der Wert des linken Operanden wird um die vom rechten Operanden angegebene Anzahl von Bits nach links verschoben. Ein << 2 ergibt 240, also 1111 0000
>> Der Wert des linken Operanden wird um die vom rechten Operanden angegebene Anzahl von Bits nach rechts verschoben. A >> 2 ergibt 15, also 0000 1111
Beispiel
Bitte schauen Sie sich das folgende Beispiel an, um mehr über alle in C# verfügbaren bitweisen Operatoren zu erfahren:
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();
}
}
}Wenn der obige Code kompiliert und ausgeführt wird, werden die folgenden Ergebnisse erzeugt:
Line 1 - c 的值是 12 Line 2 - c 的值是 61 Line 3 - c 的值是 49 Line 4 - c 的值是 -61 Line 5 - c 的值是 240 Line 6 - c 的值是 15
Zuweisungsoperatoren
Die folgende Tabelle listet die von C# unterstützten Zuweisungsoperatoren auf:
Operator
Beschreibung
Instanz
= 简单的赋值运算符，把右边操作数的值赋给左边操作数 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-Frontend] Node.js-Schnellstart](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
