12. 비트 연산자

참고영상 : https://youtu.be/VtqhZQP7T4c

1바이트는 8비트이다. 데이터형식의 크기는 모두 '바이트'단위로 이루어져 있다.

 

비트 수준에서 데이터를 가공해야 하는 경우가 종종 생긴다. 비트 연산자를 이를 위한 연산자이다.

 

1) 시프트 연산자 : 비트를 왼쪽이나 오른쪽으로 이동시키는 연산자

비트를 이동시킬 때는 규칙이 있다.

밀려서 빠져나온 비트는 과감하게 버린다.

양수에 대한 시프트 연산자는 비게된 비트 만큼 0을 채워 넣는다.

음수에 대한 시프트 연산자는 비게된 비트 만큼 1을 채워 넣는다.

            int a = 240;                  // 00000000 00000000 00001111 00000000
            int resultl_1 = a << 2; // 00000000 00000000 00111100 00000000
            int result_2 = a >> 2;  // 00000000 00000000 00000011 11000000

 

240(0000 0000 1111 0000)을 왼쪽으로 2비트 시프트한 결과는

960(0000 0011 1100 0000)이고 반대로 2비트 시프트한 결과는 60이었다.

원본 데이터를 a, 옮긴 비트 수는 b라고 할 때,

왼쪽 시프트 연산을 하면 aX2(b 제곱)의 결과가,

오른쪽 시프트 연산을 하면 a % 2(b 제곱)의 결과가 나온다.

(이 점을 이용해서 시프트 연산은 고속의 곱셈과 나눗셈을 구현하는 데 사용되기도 하고

&연산자, | 연산자와 함께 byte처럼 작은 단위로 쪼개진 데이터를 다시 하나의 int나 long 형식으로

재조립하는데 사용되기도 한다.)

using System;
using System.Collections;
using System.Collections.Generic;
using System.Globalization;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using static System.Console;

namespace Hello
{
    class MainApp
    {
        static void Main(string[] args)
        {
            WriteLine("Testing <<");
            int a = 1;
            WriteLine("a          : {0:D5} (0x{0:X8})", a);
            WriteLine("a << 1 : {0:D5} (0x{0:X8})",a<<1);
            WriteLine("a << 2 : {0:D5} (0x{0:X8})", a<<2);
            WriteLine("a << 5 : {0:D5} (0x{0:X8})", a<<5);

            WriteLine("Testing >>");
            int b = 255;
            WriteLine("a          : {0:D5} (0x{0:X8})", b);
            WriteLine("a >> 1 : {0:D5} (0x{0:X8})", b >> 1);
            WriteLine("a >> 2 : {0:D5} (0x{0:X8})", b >> 2);
            WriteLine("a >> 5 : {0:D5} (0x{0:X8})", b >> 5);

            WriteLine("Testing >>");
            int c = -255;
            WriteLine("a          : {0:D5} (0x{0:X8})", c);
            WriteLine("a >> 1 : {0:D5} (0x{0:X8})", c >> 1);
            WriteLine("a >> 2 : {0:D5} (0x{0:X8})", c >> 2);
            WriteLine("a >> 5 : {0:D5} (0x{0:X8})", c >> 5);
        }
    }
}

출력결과

Testing <<
a          : 00001 (0x00000001)
a << 1 : 00002 (0x00000002)
a << 2 : 00004 (0x00000004)
a << 5 : 00032 (0x00000020)
Testing >>
a          : 00255 (0x000000FF)
a >> 1 : 00127 (0x0000007F)
a >> 2 : 00063 (0x0000003F)
a >> 5 : 00007 (0x00000007)
Testing >>
a          : -00255 (0xFFFFFF01)
a >> 1 : -00128 (0xFFFFFF80)
a >> 2 : -00064 (0xFFFFFFC0)
a >> 5 : -00008 (0xFFFFFFF8)

1) 비트논리 연산자 : 비트 논리 연산자는 정수 형식에 대해서도 논리 연산을 한다.

우리가 사용하는 데이터는 0과 1로 이루어진다.

int 형식 데이터는 4바이트 즉 32개의 비트로 이루어지고

long 형식 데이터는 64개의 비트(8바이트)로 이루어진다.

비트 논리 연산은 이 비트 덩어리를 이루고 있는 각 비트에 대해 1은 참, 0은 거짓으로 해서 논리 연산을 한다.

&	논리곱(AND) 연산자
|	논리합(OR) 연산자
^	배타적 논리합(XOR) 연산자
~	보수(NOT) 연산자 : 피연산자의 비트에 대해 0은 1로, 1은 0으로 반전시킨다. 단항 연산자이다.

9와 10의 논리곱 결과는 다음과 같이 1000(10진수로는 8이 된다.)

논리곱에서는 둘 중 모두가 참(1)이어야 그 결과가 참(1)이다.

9 :  1 0 0 1

     &&&&

10: 1 0 1 0

8 :  1 0 0 0 (결과)

int result = 9 & 10; //result는 8

9와 10의 논리합 결과는 다음과 같이 1011(10진수로는 11이 된다.)

논리합에서는 둘 중 하나라도 참(1)이면 그 결과가 참(1)이다.

9 :  1 0 0 1

      |  | | |

10: 1 0 1 0

11 :1 0 1 1 (결과)

int result = 9 | 10; //result는 11

9와 10의 배타적 논리합 결과는 다음과 같이 0011(10진수로는 3이 된다.)

배타적 논리합에서는 둘 중 모두가 달라야 그 결과가 참(1)이다.

두개(두 피연산자의 진릿값)가 같으면 거짓(0)이다.

9 :  1 0 0 1

     ^ ^ ^^

10: 1 0 1 0

3 :  0 0 1 1 (결과)

int result = 9 ^ 10; //result는 3

9와 10의 보수 연산 결과는 다음과 같이 0011(10진수로는 3이 된다.)

~는 피연산자가 하나뿐인 단항 연산자로서 비트를 0에서 1로,

1에서 0으로 뒤지는 기능을 한다.

 

예를 들어 크기가 32비트인 int 형식의 변수 a를 선언하고 255로 초기화한다.

255를 담은 a의 비트는 00000000 00000000 00000000 11111111이 되고

이 비트 패턴에서 0을 1로, 1을 0으로 바꾸면 11111111 11111111 11111111 00000000  이 된다.

int a = 255;
int result = ~a; //result는 -256

<최종 소스코드>

using System;
using System.Collections;
using System.Collections.Generic;
using System.Globalization;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using static System.Console;

namespace Hello
{
    class MainApp
    {
        static void Main(string[] args)
        {
            int a = 9;
            int b = 10;

            WriteLine($"{a} & {b} : {a&b}"); //9 & 10 : 8
            WriteLine($"{a} | {b} : {a|b}"); //9 | 10 : 11
            WriteLine($"{a} ^ {b} : {a^b}"); //9 ^ 10 : 3

            int c = 255;
            WriteLine("{0}(0x{0:X8})",c,~c); //255(0x000000FF)
            WriteLine("{1}(0x{1:X8})", c, ~c); //-256(0xFFFFFF00)
        }
    }
}

 

<출력>

9 & 10 : 8
9 | 10 : 11
9 ^ 10 : 3
255(0x000000FF)
-256(0xFFFFFF00)