[c# 튜토리얼] C# 연산자

C# 연산자

연산자는 컴파일러에게 특정 수학 또는 논리 연산을 수행하도록 지시하는 기호입니다. C#에는 다음과 같이 분류되는 다양한 기본 연산자 세트가 있습니다.

산술 연산자

관계 연산자

논리 연산자

비트 연산자

대입 연산자

기타 연산자

이 튜토리얼에서는 산술 연산자, 관계 연산자, 논리 연산자, 비트 연산자, 할당 연산자 및 기타 연산자를 하나씩 설명합니다.

산술 연산자

다음 표에는 C#에서 지원하는 모든 산술 연산자가 나와 있습니다. 변수 A의 값이 10이고 변수 B의 값이 20이라고 가정하면

Operator

Description

Instance

+ 두 피연산자 A + B를 더하면 30이 됩니다.

- 첫 번째 피연산자에서 두 번째 피연산자 A - B를 빼고 -10을 얻습니다.

* 곱하기 두 피연산자 A * B는 200을 얻습니다

/ 분자를 분모로 나누기 B / A는 2를 얻습니다

% 모듈로 연산자, 정수 나누기 후 B % A의 나머지는 0을 얻습니다.

++ 자동 증가 연산자, 정수 값이 1씩 증가 A++는 11을 얻음

-- 감소 연산자, 정수 값은 1씩 감소 A-- 9를 얻음

인스턴스

C#에서 사용할 수 있는 모든 산술 연산자에 대해 알아보려면 다음 예제를 참조하세요.

using System;

namespace OperatorsAppl
{
클래스 프로그램
{
static void Main(string[] args)
          int c;

c = a + b;
Console.WriteLine("라인 1의 값 - c is {0}", c);
c = a - b;
Console.W riteLine( "Line 2 - c의 값은 {0}입니다.", c);
c = a * b;
Console.WriteLine("3행 - c의 값은 {0}입니다.", c);
C = A / B
C =Riteline("4행 -C 값은 {0}입니다. 0}", c);
c = a % b;
console.writline ("5번째 줄 - c의 값은 {0}입니다", c);
c = a++;
Console.WriteLine("라인 6 - c 값은 {0}입니다.", c);
c = a-- ;
Console.WriteLine("라인 7 - c 값은 {0}입니다." , c);
Console.ReadLine();
}
}
}


위 코드를 컴파일하고 실행하면 다음과 같은 결과가 나옵니다.

1행 - c의 값은 31

2행 - c의 값은 11

3행 - c의 값은 210

4행 - c의 값은 2
5행 - c 값은 1
6행 - c 값은 21
7행 - c 값은 22


관계 연산자

다음 표에는 C#에서 지원하는 모든 관계 연산자가 나와 있습니다. 변수 A의 값이 10이고 변수 B의 값이 20이라고 가정하면

Operator

Description

Instance

== 두 피연산자의 값이 같은지 확인합니다. 같으면 조건이 true입니다. (A == B)는 사실이 아닙니다.

!= 두 피연산자의 값이 같은지 확인하고, 같지 않으면 조건이 true입니다. (A != B)는 참입니다.

> 왼쪽 피연산자의 값이 오른쪽 피연산자의 값보다 큰지 확인하면 조건이 true입니다. (A>B)는 사실이 아닙니다.

9c589f6a9f6baefa88a8e9a6b97b93fb= 왼쪽 피연산자의 값이 오른쪽 피연산자의 값보다 크거나 같은지 확인하면 조건이 true입니다. (A >= B)는 사실이 아닙니다.

20a7f1e576eec20cd63915cdf58b5d0a> 왼쪽 피연산자의 값은 오른쪽 피연산자가 지정한 비트 수만큼 오른쪽으로 이동합니다. >> 2는 15(0000 1111)를 얻습니다.

예

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();
        }
    }
}

위 코드를 컴파일하고 실행하면 다음과 같은 결과가 생성됩니다.

Line 1 - c 的值是 12
Line 2 - c 的值是 61
Line 3 - c 的值是 49
Line 4 - c 的值是 -61
Line 5 - c 的值是 240
Line 6 - c 的值是 15

대입 연산자

다음 표에는 C#에서 지원하는 할당 연산자가 나열되어 있습니다.

연산자

설명

인스턴스

=    简单的赋值运算符，把右边操作数的值赋给左边操作数    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）！