๐ ๋นํธ ์ฐ์ฐ, ์ํํธ ์ฐ์ฐ
๐ซ ๊ณตํต
์ ์ํ ๋ฐ์ดํฐ์ ์ฐ์ฐ๋ง ๊ฐ๋ฅ (์ค์ํ ๋ฐ์ดํฐ X)
- And, Or, Not, Exclusive-Or/XOR
- Bit Operator, Bit Operation & | ~ ^
- Bit Vector, ๊ธธ์ด w์ 0/1๋ก ๊ตฌ์ฑ๋ ๋ฐ์ดํฐ
๋นํธ ๋ฒกํฐ๋ฅผ ์ด์ฉํ ์งํฉ์ ํํ๊ณผ ์ด์ (๋นํธ ์ฐ์ฐ)
- Bit ์ธ์(ํผ์ฐ์ฐ์)๋ค์ Bit Vector๋ก์จ ๋นํธ ๋จ์ ์ฐ์ฐ Bit Wise Operate
- ๋ง์คํฌ ์ฐ์ฐ
- ์ผ์ข ์ ๋นํธ ํจํด์ผ๋ก, ์ํ๋ ๋นํธ๋ฅผ ์ถ์ถ
- ์๋ ์ค ์ผ๋ถ ์ ํ๋ ๋นํธ ์งํฉ
- ๋นํธ ์ฐ์ฐ์ vs ๋
ผ๋ฆฌ ์ฐ์ฐ์
- || OR, && AND, ! NOT
- 0 = false, !0 = true
- ํญ์ 0์ด๋ 1 ์ฐ์ถ
- Early termination
- Short-Circuit Evaluation
- p && *p, avoids null pointer access
- ๋ฐ๋ฉด ๋นํธ ์ฐ์ฐ์๋ ๋ชจ๋ ์ฐ์ฐ
- Short-Circuit Evaluation
2.1.9 C์ ๋นํธ์ด๋ ์ฐ์ฐ
- ์ข์ธก ์ด๋ x ยซย k
- ์ผ์ชฝ ์ด๊ณผ ๋นํธ๋ค์ ๋ฒ๋ฆผ
- ์ฐ์ธก 0๋ก ์ฑ์
- ์ฐ์ธก ์ด๋ xย ยป k
- ์ค๋ฅธ์ชฝ ์ด๊ณผ ๋นํธ๋ค์ ๋ฒ๋ฆผ
- ๋ ผ๋ฆฌ ์ฌํํธ, ์ผ์ชฝ 0๋ก ์ฑ์
- ์ฐ์ ์ฌํํธ, ์ค๋ฅธ์ชฝ ์ต์์ ๋นํธ ๋ณต์
- 2์ ๋ณด์ ์ ์ ํํ์ ์ ์ฉ
๐ซ ๋นํธ ์ฐ์ฐ
๐ซง &
AND, ๋นํธ AND ์ฐ์ฐ์
์์ชฝ ํผ์ฐ์ฐ์์ ๊ฐ ๋นํธ๋ฅผ ๋น๊ตํ์ฌ ์์ชฝ ๋ชจ๋ 1์ด๋ฉด 1, ์๋๋ผ๋ฉด 0์ผ๋ก ์ค์ .
1
2
3
4
5
6
int x = 3;
// 3, ...0011
int y = 5;
// 5, ...0101
int z = x & y;
// 1, ...0001
๐ซง ^
- XOR, ํฌ๊ด์ ๋นํธ XOR ์ฐ์ฐ์, (eXclusive OR)
- ์์ชฝ ํผ์ฐ์ฐ์์ ๊ฐ ๋นํธ๋ฅผ ๋น๊ตํ์ฌ ์๋ก ๋ค๋ฅด๋ฉด 1, ์๋๋ผ๋ฉด 0์ผ๋ก ์ค์ .
1
2
3
4
5
6
int x = 3;
// 3, ...0011
int y = 5;
// 5, ...0101
int z = x ^ y;
// 6, ...0110
๐ซง |
- OR, ๋ฐฐํ์ ๋นํธ OR ์ฐ์ฐ์
- ์์ชฝ ํผ์ฐ์ฐ์์ ๊ฐ ๋นํธ๋ฅผ ๋น๊ตํ์ฌ ํ ์ชฝ์ด๋ผ๋ 1์ด๋ฉด 1, ์๋๋ผ๋ฉด 0์ผ๋ก ์ค์ .
Shift + ์ญ์ฌ๋์ (Enter ์์ ์๋ ํค, โฉ)
๋ก ์ ๋ ฅํ ์ ์์.
1
2
3
4
5
6
int x = 3;
// 3, ...0011
int y = 5;
// 5, ...0101
int z = x | y;
// 7, ...0111
๐ซง ~
- NOT, ๋นํธ ๋ณด์(๋๋ ๋นํธ NOT) ์ฐ์ฐ์
- ํผ์ฐ์ฐ์์ ๋นํธ ๋ณด์๋ฅผ ๋ง๋ฆ (0์์ 1, 1์์ 0์ผ๋ก ์๋ฅผ ๋ค์ง์)
- ์ฌ๋ด์ผ๋ก,
~
๋ ๋จํญ ์ฐ์ ์ฐ์ฐ์๋ก ๋ถ๋ฅ๋จ. (MSDC ๊ธฐ์ค)
1
2
3
4
int x = 15;
// 15, ...0000'0000'0000'1111
int y = ~x;
// -16, ...1111'1111'1111'0000
๐ซ ๋นํธ ์ํํธ ์ฐ์ฐ์
- ์ฃผ์ ํ ์
- ๋นํธ ์ํํธ ์ฐ์ฐ์๋ก ์ํ๋ ๋ณํ์ ์ค๋ฒํ๋ก, ์ธ๋ํ๋ก ์กฐ๊ฑด์ ์ง์ํ์ง ์์.
- ๋๋ฌธ์ ์ฐ์ฐ ๊ฒฐ๊ณผ๊ฐ ์ฒซ ๋ฒ์งธ ํผ์ฐ์ฐ์ ํ์์ผ๋ก ํํํ ์ ์๋ ๊ฒฝ์ฐ,
- ์ค๋ฅ๊ฐ ๋ฐ์ํ์ง ์์ผ๋ฉฐ, ์ ๋ณด๊ฐ ์์ค๋ ์ ์์.
- ๋นํธ ์ํํธ ์ฐ์ฐ์๋ก ์ํ๋ ๋ณํ์ ์ค๋ฒํ๋ก, ์ธ๋ํ๋ก ์กฐ๊ฑด์ ์ง์ํ์ง ์์.
๐ซง ยซ
- ์ฒซ ๋ฒ์งธ ํผ์ฐ์ฐ์๋ฅผ ๋ ๋ฒ์งธ ํผ์ฐ์ฐ์ ๋งํผ ์ผ์ชฝ์ผ๋ก ์ด๋.
- ๊ณ์ฐ์ ์ค๋ฒํ๋ก๊ฐ ์๋ ๊ฒฝ์ฐ, ์ฒซ ๋ฒ์งธ ํผ์ฐ์ฐ์์ 2๋ ๋ฒ์งธ ํผ์ฐ์ฐ์ ๋ฅผ ๊ณฑํ ๊ฐ๊ณผ ๊ฐ์.
- ์ํํธ ์ดํ ๋น์์ง ๋นํธ๋ 0 ์ผ๋ก ์ค์ ๋จ.
1
2
3
4
5
int x = 15;
// 15, ...0000'0000'0000'1111
int y = x << 4;
// 240, ...0000'0000'1111'0000
// 240 = 15 * 2^4
๐ซงย ยป
- ์ฒซ ๋ฒ์งธ ํผ์ฐ์ฐ์๋ฅผ ๋ ๋ฒ์งธ ํผ์ฐ์ฐ์ ๋งํผ ์ค๋ฅธ์ชฝ์ผ๋ก ์ด๋.
- ์ฒซ ๋ฒ์งธ ํผ์ฐ์ฐ์๊ฐ ๋ถํธ๊ฐ ์๊ฑฐ๋, ์์๊ฐ ์๋ ๊ฒฝ์ฐ, 2๋ ๋ฒ์งธ ํผ์ฐ์ฐ์ ๋ก ๋๋ ๊ฐ๊ณผ ๊ฐ์.
- ์ํํธ ์ดํ ๋น์์ง ๋นํธ๋ ์ฒซ ๋ฒ์งธ ํผ์ฐ์ฐ์์ ํ์์ ๋ฐ๋ผ ์ฑ์์ง.
- ๋ถํธ ์๋
unsigned
ํ์์ด๋ฉด, 0์ผ๋ก ์ฑ์์ง (์ต์์ ๋นํธ ์ค์ ํด์ ) - ๋ถํธ ์๋ ํ์์ด๋ผ๋ฉด ๋ถํธ ๋นํธ๊ฐ ๋ณต์ฌ๋์ฌ ์ฑ์์ง. ์์ 0, ์์ 1 (์ต์์ ๋นํธ ์ค์ ๋ ์ฑ ์ ์ง)
- ๋ถํธ ์๋
1
2
3
4
5
int x = 240;
// 240, ...0000'0000'1111'0000
int y = x >> 4;
// 15, ...0000'0000'0000'1111
// 15 = 240 / 2^4
- ์์ ๊ฐ์ ์ค๋ฅธ์ชฝ์ผ๋ก ์ด๋ํ๋ฉด ์๋ ๊ฐ์ ๋ฐ์ ์ ์๋ก ๋ด๋ฆผํ ๊ฐ์ด ์์ฑ๋จ.
- -253 (11111111 00000011) ์ ์ค๋ฅธ์ชฝ์ผ๋ก 1๋นํธ ์ด๋ํ๋ฉด,
- -127 (11111111 10000001) ์ด ์์ฑ๋จ.
- 253 (00000000 11111101) ์ ์ค๋ฅธ์ชฝ์ผ๋ก 1๋นํธ ์ด๋ํ๋ฉด,
- 126 (00000000 01111110) ์ด ์์ฑ๋จ.
๐ซ ํ ๋น ์ฐ์ฐ์
- ๋ค๋ฅธ ์ฐ์ฐ์๋ค๊ณผ ๋ง์ฐฌ๊ฐ์ง๋ก ํ ๋น ์ฐ์ฐ์๋ฅผ ํตํด ๊ฐ ๋ณํ๊ณผ ํ ๋น์ ๋์์ ํ ์ ์์.
&=
^=
|=
~
๋ ๋จํญ ์ฐ์ ์ฐ์ฐ์๋ผ ํ ๋น ์ฐ์ฐ์๊ฐ ์กด์ฌํ์ง ์์.<<=
>>=
๐ซ ์ฐธ๊ณ
๋นํธ ๋ง์คํฌ
& = ?
์น์์ ๊ณ์ฐ๊ธฐ ๋ง๋ค๊ธฐ
1
2
3
(value >> 16) & byte.MaxValue
(value >> 8) & byte.MaxValue
(value >> 0) & byte.MaxValue
์ด ๊ธฐ์ฌ๋ ์ ์๊ถ์์ CC BY 4.0 ๋ผ์ด์ผ์ค๋ฅผ ๋ฐ๋ฆ
๋๋ค.