ABOUT ME

기술 블로그

Today
Yesterday
Total
  • [C#] 연산자
    C# 2023. 5. 26. 23:39

    1. 산술 연산자

    연산자 설명 지원 형식
    + 양쪽 피연산자를 더합니다 모든 수치 데이터 현식
    - 왼쪽 피연산자에서 오른쪽 피연산자를 차감합니다 모든 수치 데이터 현식
    * 양쪽 피연산자를 곱합니다 모든 수치 데이터 현식
    / 왼쪽 연산자를 오른쪽 피연산자로 나눈 몫을 구합니다 모든 수치 데이터 현식
    % 왼쪽 연산자를 오른쪽 피연산자로 나눈 후의 나머지를 구합니다. 모든 수치 데이터 현식
    namespace ArithmaticOperators
    {
        internal class Program
        {
            static void Main(string[] args)
            {
                int a = 111 + 222;
                Console.WriteLine($"a : {a}"); // a : 333
    
                int b = a - 100;
                Console.WriteLine($"b : {b}"); // b : 233
    
                int c = b * 10;
                Console.WriteLine($"c : {c}"); // c : 2330
    
                double d = c / 6.3;
                Console.WriteLine($"d : {d}"); // d : 369.8412698412699
    
                Console.WriteLine($"22 / 7 = {22 / 7}({22 % 7})"); // 22 / 7 = 3(1)
            }
        }
    }

    2. 증감 연산자

    연산자 이름 설명 지원 형식
    ++ 증가 연산자 피연산자의 값을 1 증가시킵니다 모든 수치 데이터 형식과 열거 형식
    -- 감소 연산자 피연산자의 값을 1 감소시킵니다 모든 수치 데이터 형식과 열거 형식
    namespace IncDecOperator
    {
        internal class Program
        {
            static void Main(string[] args)
            {
                int a = 10;
                Console.WriteLine(a++); // 10
                Console.WriteLine(++a); // 12
    
                Console.WriteLine(a--); // 12
                Console.WriteLine(--a); // 10
            }
        }
    }

    3. 관계 연산자

    연산자 설명 지원 형식
    < 왼쪽 피연산자가 오른쪽 피연산자보다 작으면 참, 아니면 거짓 모든 수치 형식과 열거 형식
    > 왼쪽 피연산자가 오른쪽 피연산자보다 크면 참, 아니면 거짓 모든 수치 형식과 열거 형식
    <= 왼쪽 피연산자가 오른쪽 피연산자보다 작거나 같으면 참, 아니면 거짓 모든 수치 형식과 열거 형식
    >= 왼쪽 피연산자가 오른쪽 피연산자보다 크거나 같으면 참, 아니면 거짓 모든 수치 형식과 열거 형식
    == 왼쪽 피연산자가 오른쪽 피연산자와 같으면 참, 아니면 거짓 모든 데이터 형식에 대해 사용 가능
    != 왼쪽 피연산자가 오른쪽 피연산자와 다르면 참, 아니면 거짓 모든 데이터 형식에 대해 사용 가능,
    string와 object 형식에 대해서도 사용이 가능
    namespace Relational10perator
    {
        internal class Program
        {
            static void Main(string[] args)
            {
                Console.WriteLine($"3 > 4 : {3 > 4}"); // 3 > 4 : False
                Console.WriteLine($"3 >= 4 : {3 >= 4}"); // 3 >= 4 : False
                Console.WriteLine($"3 < 4 : {3 < 4}"); // 3 < 4 : True
                Console.WriteLine($"3 <= 4 : {3 <= 4}"); // 3 <= 4 : True
                Console.WriteLine($"3 == 4 : {3 == 4}"); // 3 == 4 : False
                Console.WriteLine($"3 != 4 : {3 != 4}"); // 3 != 4 : True
            }
        }
    }

    4. 논리 연산자

    연산자 이름 설명
    && 논리 곱 연산자(AND) 피연산자로 오는 두 개의 진리값이 모두 참(True)이어야 참을 반환, 아니면 거짓(False)
    || 논리 합 연산자(OR) 피연산자로 오는 두 개의 진리값 중에 하나라도 참이라면 참을 반환, 아니면 거짓
    ! 부정 연산자(NOT) 피연산자의 진리값을 반대로 뒤집는다. 참이면 거짓, 거짓일 경우 참으로 반환
    namespace LogicalOperator
    {
        internal class Program
        {
            static void Main(string[] args)
            {
                Console.WriteLine("Testing && ... ");
                Console.WriteLine($"1 > 0 && 4 < 5 : {1 > 0 && 4 < 5}"); // True
                Console.WriteLine($"1 > 0 && 4 > 5 : {1 > 0 && 4 > 5}"); // False
                Console.WriteLine($"1 == 0 && 4 > 5 : {1 == 0 && 4 > 5}"); // False
                Console.WriteLine($"1 == 0 && 4 < 5 : {1 == 0 && 4 < 5}"); // False
    
                Console.WriteLine("\nTesting || ... ");
                Console.WriteLine($"1 > 0 || 4 < 5 : {1 > 0 || 4 < 5}"); // True
                Console.WriteLine($"1 > 0 || 4 > 5 : {1 > 0 || 4 > 5}"); // True
                Console.WriteLine($"1 == 0 || 4 > 5 : {1 == 0 || 4 > 5}"); // False
                Console.WriteLine($"1 == 0 || 4 < 5 : {1 == 0 || 4 < 5}"); // True
    
                Console.WriteLine("\nTesting ! ... ");
                Console.WriteLine($"!True : {!true}"); // False
                Console.WriteLine($"!False : {!false}"); // True
            }
        }
    }

    5. 조건 연산자

    조건식 ? 참일 때의 값 : 거짓일 때의 값;
    namespace ConditionalOperator
    {
        internal class Program
        {
            static void Main(string[] args)
            {
                string result = (10 % 2) == 0 ? "짝수" : "홀수";
    
                Console.WriteLine(result); // 짝수
            }
        }
    }

    6. null 조건부 연산자

    using System.Collections;
    
    namespace NullConditionalOperator
    {
        internal class Program
        {
            static void Main(string[] args)
            {
                ArrayList a = null;
                a?.Add("야구"); // a?.이 null을 반환하므로 Add() 메소드는 호출되지 않음
                a?.Add("축구");
                Console.WriteLine($"Count : {a?.Count}"); // Count :
                Console.WriteLine($"{a?[0]}"); //
                Console.WriteLine($"{a?[1]}"); // 
    
                a = new ArrayList(); // a는 이제 더 이상 null이 아닙니다.
                a?.Add("야구");
                a?.Add("축구");
                Console.WriteLine($"Count : {a?.Count}"); // Count: 2
                Console.WriteLine($"{a?[0]}"); // 야구
                Console.WriteLine($"{a?[1]}"); // 축구
            }
        }
    }

    7. 비트 연산자

    연산자 이름 설명 지원 형식
    << 왼쪽 시프트 연산자 첫 번째 피연산자의 비트를 두 번째 피연산자의 수만큼 왼쪽으로 이동시킵니다 첫 번째 피연산자는 int, uint, long, ulong이며 두 번째 피연산자는 int형식만 지원합니다.
    >> 오른쪽 시프트 연산자 첫 번째 피연산자의 비트를 두 번째 피연산자의 수만큼 오른쪽으로 이동시킵니다 << 와 같습니다.
    & 논리곱(AND) 연산자 두 피연산자의 비트 논리곱을 수행 합니다 정수 계열 형식과 bool 형식에 대해 사용할 수 있습니다
    | 논리합(OR) 연산자 두 피연산자의 비트 논리합을 수행 합니다 &와 같습니다
    ^ 배타적 논리합(XOR) 연산자 두 피연산자의 비트 배타적 논리합을 수행합니다 &와 같습니다
    ~ 보수(NOT) 연산자 피연산자의 비트를 0은 1로, 1은 0으로 반전시킵니다. 단항 연산자입니다. int, uint, long, ulong에 대해 사용이 가능합니다.

    7-1. 시프트 연산자 예시

    namespace ShiftOperator
    {
        internal class Program
        {
            static void Main(string[] args)
            {
                Console.WriteLine("Testing << ... ");
    
                int a = 1;
                Console.WriteLine("a      : {0:D5} (0x{0:X8})", a);      // a      : 00001 (0x00000001)
                Console.WriteLine("a << 1 : {0:D5} (0x{0:X8})", a << 1); // a << 1 : 00002 (0x00000002)
                Console.WriteLine("a << 2 : {0:D5} (0x{0:X8})", a << 2); // a << 2 : 00004 (0x00000004)
                Console.WriteLine("a << 5 : {0:D5} (0x{0:X8})", a << 5); // a << 5 : 00032 (0x00000020)
    
                Console.WriteLine("\nTesting >> ... ");
    
                int b = 255;
                Console.WriteLine("b      : {0:D5} (0x{0:X8})", b);      // b      : 00255 (0x000000FF)
                Console.WriteLine("b >> 1 : {0:D5} (0x{0:X8})", b >> 1); // b >> 1 : 00127 (0x0000007F)
                Console.WriteLine("b >> 2 : {0:D5} (0x{0:X8})", b >> 2); // b >> 2 : 00063 (0x0000003F)
                Console.WriteLine("b >> 5 : {0:D5} (0x{0:X8})", b >> 5); // b >> 5 : 00007 (0x00000007)
    
                Console.WriteLine("\nTesting >> 2 ... ");
    
                int c = -255;
                Console.WriteLine("c      : {0:D5} (0x{0:X8})", c);      // c      : -00255 (0xFFFFFF01)
                Console.WriteLine("c >> 1 : {0:D5} (0x{0:X8})", c >> 1); // c >> 1 : -00128 (0xFFFFFF80)
                Console.WriteLine("c >> 2 : {0:D5} (0x{0:X8})", c >> 2); // c >> 2 : -00064 (0xFFFFFFC0)
                Console.WriteLine("c >> 5 : {0:D5} (0x{0:X8})", c >> 5); // c >> 5 : -00008 (0xFFFFFFF8)
            }
        }
    }

    7-2. 비트 논리 연산자

    namespace BitwiseOperator
    {
        internal class Program
        {
            static void Main(string[] args)
            {
                int a = 9;
                int b = 10;
    
                Console.WriteLine($"{a} & {b} : {a & b}"); // 9 & 10 : 8
                // 9(1001) & 10(1010) => 8(1000)
                // 둘다 1(true) 인 것
                
                Console.WriteLine($"{a} | {b} : {a | b}"); // 9 | 10 : 11
                // 9(1001) | 10(1010) => 11(1011)
                // 둘중 하나라도 1(true) 인 것
                
                Console.WriteLine($"{a} ^ {b} : {a ^ b}"); // 9 ^ 10 : 3
                // 9(1001) ^ 10(1010) => 3(0011)
                // 진리 값이 서로 달라야 true
    
                int c = 255;
                Console.WriteLine("~{0}(0x{0:X8}) : {1}(0x{1:X8})", c, ~c); 
                // ~255(0x000000FF) : -256(0xFFFFFF00)
            }
        }
    }

    8. 할당 연산자

    연산자 이름 설명
    = 할당 연산자 오른쪽 피연산자를 왼쪽 피연산자에게 할당합니다.
    += 덧셈 할당 연산자 a += b; 는 a = a + b;와 같습니다.
    -= 뺄샘 할당 연산자 a -= b; 는 a = a - b;와 같습니다.
    *= 곱셈 할당 연산자 a *= b; 는 a = a * b;와 같습니다.
    /= 나눗셈 할당 연산자 a /= b; 는 a = a / b;와 같습니다.
    %= 나머지 할당 연산자 a %= b; 는 a = a % b;와 같습니다.
    &= 논리곱 할당 연산자 a &= b; 는 a = a & b;와 같습니다.
    |= 논리합 할당 연산자 a |= b; 는 a = a | b;와 같습니다.
    ^= 배타적 논리합 할당 연산자 a ^= b; 는 a = a ^ b;와 같습니다.
    <<= 왼쪽 시프트 할당 연산자 a <<= b; 는 a = a << b;와 같습니다.
    >>= 오른쪽 시프트 할당 연산자 a >>= b; 는 a = a >> b;와 같습니다.
    namespace AssignmentOperator
    {
        internal class Program
        {
            static void Main(string[] args)
            {
                int a;
                a = 100;
                Console.WriteLine($"a = 100 : {a}"); // a = 100 : 100
                a += 90;
                Console.WriteLine($"a += 90 : {a}"); // a += 90 : 190
                a -= 80;
                Console.WriteLine($"a -= 80 : {a}"); // a -= 80 : 110
                a *= 70;
                Console.WriteLine($"a *= 70 : {a}"); // a *= 70 : 7700
                a /= 60;
                Console.WriteLine($"a /= 60 : {a}"); // a /= 60 : 128
                a %= 50;
                Console.WriteLine($"a %= 50 : {a}"); // a %= 50 : 28
                a &= 40;
                Console.WriteLine($"a &= 40 : {a}"); // a &= 40 : 8
                a |= 30;
                Console.WriteLine($"a |= 30 : {a}"); // a |= 30 : 30
                a ^= 20;
                Console.WriteLine($"a ^= 20 : {a}"); // a ^= 20 : 10
                a <<= 10;
                Console.WriteLine($"a <<= 10 : {a}"); // a <<= 10 : 10240
                a >>= 1;
                Console.WriteLine($"a >>= 1 : {a}"); // a >>= 1 : 5120
            }
        }
    }

    9. Null 병합 연산자 (??)

    ?? 연산자는 두개의 피연산자를 받아들이고 왼쪽 피연산자가 null인지를 평가합니다.
    왼쪽 피연산자가 null이 아닐 경루 왼쪽 피연산자를 반환하고
    왼쪽 피연산자가 null일 경우 오른쪽 피연산자를 반환합니다.
    namespace NullCoalescing
    {
        internal class Program
        {
            static void Main(string[] args)
            {
                int? num = null;
                Console.WriteLine($"{num ?? 0}");
                // 0
    
                num = 99;
                Console.WriteLine($"{num ?? 0}");
                // 99
    
                string str = null;
                Console.WriteLine($"{str ?? "Default"}");
                // Default
    
                str = "Specific";
                Console.WriteLine($"{str ?? "Default"}");
                // Specific
            }
        }
    }

    10. 연산자의 우선 순위

    우선순위 종류 연산자
    1 증가/감소 연산자 및 Null 조건부 연산자 후위 ++/-- 연산자, ?. , ?[]
    2 증가/감소 연산자 전위 ++/-- 연산자
    3 산술 연산자 *, /, %
    4 산술 연산자 +, -
    5 시프트 연산자 <<, >>
    6 관계 연산자 <, >, <=, >=, is, as
    7 관계 연산자 == , !=
    8 비트 논리 연산자 &
    9 비트 논리 연산자 ^
    10 비트 논리 연산자 |
    11 논리 연산자 &&
    12 논리 연산자 ||
    13 Null 병합 연산자 ??
    14 조건 연산자 ?:
    15 할당 연산자 =, *=, /=, %=, +=, -=, <<=, >>=, &=, ^=, |=

    댓글