[c#-Tutorial] C#-Operatoren

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 1 – Der Wert von c ist 31

Zeile 2 – Der Wert von c ist 11

Zeile 3 – Der Wert von c ist 210

Zeile 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

Die folgende Tabelle zeigt alle von C# unterstützten relationalen Operatoren. Angenommen, der Wert der Variablen A ist 10 und der Wert der Variablen B ist 20, dann:

Operator

Beschreibung

Instanz

== 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.

94496ec4f5c22db9ca8f8e34725833a6= Ü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.

fe95b55636923dc98ecc8186f4ce7d70> 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    

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）！