๋ณธ๋ฌธ ๋ฐ”๋กœ๊ฐ€๊ธฐ
๐Ÿ“Œ Language/Javascript

[Swift] ๊ณ ๊ธ‰ ์—ฐ์‚ฐ์ž(Advanced Operator)๋ž€? (feat. ๋น„ํŠธ์—ฐ์‚ฐ์ž)

by Fomagran ๐Ÿ’ป 2022. 2. 26.
728x90
๋ฐ˜์‘ํ˜•

 

์•ˆ๋…•ํ•˜์„ธ์š” Foma ๐Ÿ’ป ์ž…๋‹ˆ๋‹ค!

 

์˜ค๋Š˜์€ ์šฐ์—ฐํžˆ ์•Œ๊ณ ๋ฆฌ์ฆ˜ ๋ฌธ์ œ๋ฅผ ํ’€๋‹ค๊ฐ€ '^=' ์™€ ๊ฐ™์€ ์—ฐ์‚ฐ์ž๋ฅผ ๋ฐœ๊ฒฌํ–ˆ๋Š”๋ฐ, ์ •ํ™•ํžˆ ์–ด๋–ค๊ฑด์ง€ ๋ชจ๋ฅด๊ฒ ๋”๋ผ๊ตฌ์š”.

 

์ฐพ์•„๋ณด๋‹ˆ ํ•ด๋‹น ์—ฐ์‚ฐ์ž๋Š” Swift์—์„œ ๊ณ ๊ธ‰ ์—ฐ์‚ฐ์ž๋กœ ๋ถ„๋ฅ˜ํ•ด ๋†“์•˜๋”๋ผ๊ตฌ์š”.

 

๊ทธ๋ž˜์„œ ์˜ค๋Š˜์€ Swift์˜ ๊ณ ๊ธ‰ ์—ฐ์‚ฐ์ž์— ๋Œ€ํ•ด์„œ ์•Œ์•„๋ณด๋ ค๊ณ  ํ•ฉ๋‹ˆ๋‹ค.

 

๋ฐ”๋กœ ์‹œ์ž‘ํ• ๊ฒŒ์š”~!


UInt

 

์šฐ์„  ๋“ค์–ด๊ฐ€๊ธฐ ์ „์— UInt์— ๋Œ€ํ•œ ์ดํ•ด๊ฐ€ ํ•„์š”ํ•ด์š”.

 

์›๋ž˜ Int๋Š” ์ •์ˆ˜ ์ฆ‰, ์Œ์ˆ˜์™€ ์–‘์ˆ˜๋ฅผ ๋ชจ๋‘ ๊ฐ€์งˆ ์ˆ˜ ์žˆ์—ˆ์ฃ ?

 

UInt๋Š” ์ด ์ค‘์—์„œ ์–‘์ˆ˜๋งŒ ๊ฐ€์งˆ ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค. (์Œ์ˆ˜๋ฅผ ๋„ฃ์œผ๋ฉด ์ปดํŒŒ์ผ ์—๋Ÿฌ ๋ฐœ์ƒ)

 

๋ฒ”์œ„๋กœ ๋ณด๋ฉด  Int8 = -128...127 ์ด๊ณ , UInt8 = 0...256,

 

Int16 = -322768...322767์ด๊ณ  UInt16 = 0...65535 ์ž…๋‹ˆ๋‹ค.


์ •์ˆ˜ํ˜• ๋ณ€์ˆ˜์— ๋น„ํŠธ๊ฐ’ ์ž…๋ ฅํ•˜๋Š” ๋ฒ•

 

๋ณดํ†ต ์ •์ˆ˜ํ˜• ๋ณ€์ˆ˜์— ๊ฐ’์„ ์„ค์ •ํ•  ๋•Œ ์•„๋ž˜์™€ ๊ฐ™์ด ์ •์ˆ˜๋ฅผ ๋„ฃ์ž–์•„์š”?

 

var number:Int = 4

 

ํ•˜์ง€๋งŒ ๋น„ํŠธ๊ฐ’์„ ๋„ฃ์–ด๋„ ๊ฐ’์„ ์„ค์ •ํ•  ์ˆ˜ ์žˆ๋Š”๋ฐ์š”.

 

๋ฐฉ๋ฒ•์€ ์•ž์— 0b๋ฅผ ๋ถ™์—ฌ์ฃผ๊ณ  ๋น„ํŠธ๊ฐ’์„ ๋„ฃ์–ด์ฃผ๋ฉด ๋ฉ๋‹ˆ๋‹ค.

 

์•„๋ž˜์™€ ๊ฐ™์ด 4์˜ 2์ง„์ˆ˜๋Š” 100 ์ด๋ฏ€๋กœ 0b100์œผ๋กœ ์„ค์ •ํ•ด์ฃผ์‹œ๋ฉด ๋ฉ๋‹ˆ๋‹ค

 

 

var binaryNum:Int8 = 0b100
print(binaryNum) //4

๋น„ํŠธ ์—ฐ์‚ฐ์ž NOT (Bitwise NOT Operator)

 

๋น„ํŠธ๊ฐ’(2์ง„์ˆ˜)๋ฅผ ๋ฐ˜๋Œ€๋กœ ๋ฐ”๊ฟ”์ค€๋‹ค๊ณ  ์ƒ๊ฐํ•˜๋ฉด ๋ฉ๋‹ˆ๋‹ค. (0์€ 1์œผ๋กœ 1์€ 0์œผ๋กœ)

 

๊ธฐํ˜ธ๋Š” '~'๋ฅผ ์‚ฌ์šฉํ•˜๋ฉด ๋ฉ๋‹ˆ๋‹ค.

 

ex) ~00001111 -> 11110000

 

 

let binaryNum:UInt8 = 0b00001111
let notBinaryNum:UInt8 = ~binaryNum //11110000
print(binaryNum,notBinaryNum) //15 240

 

UInt๊ฐ€ ์•„๋‹Œ Int๋ฅผ ์‚ฌ์šฉํ•  ๊ฒฝ์šฐ x = (-x)-1์˜ ๊ณต์‹์œผ๋กœ ๋ณ€ํ™˜๋œ๋‹ค.

 

var number = 4
print(~number) //-5 (-4)-1

๋น„ํŠธ ์—ฐ์‚ฐ์ž AND (Bitwise AND Operator)

 

๋‘ ๋น„ํŠธ๊ฐ’์„ ์„œ๋กœ ๋น„๊ตํ•ด ๊ฐ™๋‹ค๋ฉด 1 ์•„๋‹ˆ๋ฉด 0์œผ๋กœ ๋ฐ”๊ฟ”์ค๋‹ˆ๋‹ค.

 

๊ธฐํ˜ธ๋Š” '&' ๋ฅผ ์‚ฌ์šฉํ•ด ์ค๋‹ˆ๋‹ค.

 

ex) 11111100 & 00111100 -> 00111111

 

 

let binaryNum1: UInt8 = 0b11111100
let binaryNum2: UInt8  = 0b00111111
let addBinaryByAndOperator = binaryNum1 & binaryNum2
print(addBinaryByAndOperator) //60 00111100

๋น„ํŠธ ์—ฐ์‚ฐ์ž OR (Bitwise OR Operator)

 

๋‘ ๋น„ํŠธ๊ฐ’์„ ๋น„๊ตํ•ด ํ•˜๋‚˜๋ผ๋„ 1์ด๋ฉด 1์ด ๋˜๊ณ  ๋‘˜ ๋‹ค 0์ผ ๋•Œ 0์œผ๋กœ ๋ฐ”๊ฟ”์ค๋‹ˆ๋‹ค.

 

๊ธฐํ˜ธ๋Š” '|' ๋ฅผ ์‚ฌ์šฉํ•ด ์ค๋‹ˆ๋‹ค.

 

ex) 10110010 | 11111110 -> 0101110

 

 

let binaryNum1: UInt8 = 0b10110010
let binaryNum2: UInt8 = 0b01011110
let addBinaryByOrOperator = binaryNum1 | binaryNum2
print(addBinaryByOrOperator) //254 01011110

๋น„ํŠธ ์—ฐ์‚ฐ์ž XOR (Bitwise XOR Operator)

 

๋‘ ๋น„ํŠธ๊ฐ’์„ ๋น„๊ตํ•ด ๋‘ ๋น„ํŠธ๊ฐ€ ๋‹ค๋ฅด๋ฉด 1 ๊ฐ™์œผ๋ฉด 0์ด ๋ฉ๋‹ˆ๋‹ค.

 

ex) 00010100 ^ 00010001 -> 00000101


์–‘์ˆ˜(UInt)์˜ ์‹œํ”„ํŒ… (Shifting Behavior for Unsigned Integers)

 

์›ํ•˜๋Š” ๋งŒํผ ์™ผ์ชฝ์ด๋‚˜ ์˜ค๋ฅธ์ชฝ์œผ๋กœ ๋น„ํŠธ๊ฐ’์„ ์ด๋™ํ•œ๋‹ค๊ณ  ๋ณด๋ฉด ๋ฉ๋‹ˆ๋‹ค.

 

๋‹จ, ์˜ค๋ฅธ์ชฝ์ด๋‚˜ ์™ผ์ชฝ์œผ๋กœ ๋ฒ”์œ„๊ฐ€ ๋„˜์–ด๊ฐ€๋ฉด 0์œผ๋กœ ๋Œ€์ฒด๋ฉ๋‹ˆ๋‹ค.

 

๊ธฐํ˜ธ๋Š” ์™ผ์ชฝ์œผ๋กœ ์ด๋™ํ•  ๋• '<<' ์˜ค๋ฅธ์ชฝ์œผ๋กœ ์ด๋™ํ•  ๋• '>>' ์„ ์‚ฌ์šฉํ•ฉ๋‹ˆ๋‹ค.

 

ex) 11111111 << 1 -> 11111110, 11111111 >> 1 -> 01111111

 

 

let binaryNum: UInt8 = 0b00000100
print(binaryNum << 1)// 8 00001000
print(binaryNum << 2)// 16 00010000
print(binaryNum << 5)// 128 10000000
print(binaryNum << 6)// 0 00000000
print(binaryNum >> 2)// 1 00000001

์ •์ˆ˜์˜ ๋น„ํŠธ๊ฐ’

 

์ •์ˆ˜ํ˜•์œผ๋กœ ์„ ์–ธํ•˜๊ฒŒ ๋˜๋ฉด ์Œ์ˆ˜๋ฅผ ํฌํ•จํ•˜๋Š” ๊ฒƒ์ด๊ธฐ ๋•Œ๋ฌธ์— ์œ„์—์„œ ๋น„ํŠธ๊ฐ’๊ณผ ์•ฝ๊ฐ„ ๋‹ค๋ฅด๊ฒŒ ๋ฐ”๋€๋‹ค.

 

๋งจ ์•ž์ž๋ฆฌ๊ฐ€ 0์ด๋ผ๋ฉด ์–‘์ˆ˜๋ฅผ ๋œปํ•˜๊ณ  1์ด๋ผ๋ฉด ์Œ์ˆ˜๋ฅผ ๋œปํ•˜๋ฉฐ 1์ž๋ฆฌ๊ฐ€ ์ค„๊ฒŒ ๋œ๋‹ค.

 

์˜ˆ๋ฅผ ๋“ค์–ด 00000100์ด ์žˆ๋‹ค๋ฉด ๋งจ ์•ž์ž๋ฆฌ๊ฐ€ 1์ด๋ฏ€๋กœ ์œผ๋ฌด๋ฅผ ๋œปํ•˜๊ณ  ์‹ค์ œ ๊ฐ’์€ ๋งจ ์•ž์ž๋ฆฌ๋ฅผ ๋บ€ 0000100์ด ๋œ๋‹ค.

 

 

๊ทธ๋ ‡๋‹ค๋ฉด 10000100์€ ๋งจ ์•ž์ž๋ฆฌ๊ฐ€ 1์ด๋ฏ€๋กœ ์Œ์ˆ˜์ด๊ณ  0000100์€ 4์ด๊ธฐ ๋•Œ๋ฌธ์— -4๋ฅผ ์˜๋ฏธํ•˜๋Š” ๊ฒƒ์ผ๊นŒ?

 

1์ผ ๋•Œ๋Š” ์Œ์ˆ˜์ธ ๊ฒƒ์„ ํ‘œํ˜„ํ•˜๋Š” ๊ฑด ๋งž์ง€๋งŒ ๊ณ„์‚ฐํ•˜๋Š” ๋ฐฉ๋ฒ•์ด ์กฐ๊ธˆ ๋‹ค๋ฅด๋‹ค.

 

์•„๋ž˜์™€ ๊ฐ™์ด 11111100์ด -4๋ฅผ ๋œปํ•˜๊ฒŒ ๋œ๋‹ค. 

 

๋งจ ์•ž์ž๋ฆฌ๋ฅผ ๋นผ๋ฉด 1111100์ด ๋˜๊ณ  ์ด๊ฒƒ์€ 124๋ฅผ ๋œปํ•˜๋Š”๋ฐ ์™œ -124๊ฐ€ ์•„๋‹Œ -4์ผ๊นŒ?

 

๊ทธ ์ด์œ ๋Š” ์Œ์ˆ˜์ผ ๋• ๋น„ํŠธ๊ฐ’์—์„œ ์ž๋ฆฟ์ˆ˜๋งŒํผ 2์˜ ์ œ๊ณฑ์˜ ๊ฐ’์„ ๋บ€ ๊ฐ’์ด ํ•ด๋‹น ๊ฐ’์ด ๋œ๋‹ค.

 

์œ„์˜ 11111100์—์„œ ๋งจ ์•ž์ž๋ฆฌ๋Š” ์Œ์ˆ˜์™€ ์–‘์ˆ˜๋ฅผ ํ‘œํ˜„ํ•˜๋ฏ€๋กœ ์ œ์™ธํ•œ๋‹ค.

 

๊ทธ๋Ÿผ 1111100์œผ๋กœ 124๊ฐ€ ๋˜๊ณ , ์ด๊ฒƒ์€ 7์ž๋ฆฌ์ด๋ฏ€๋กœ 2^7 = 128์ด ๋œ๋‹ค.

 

์ฆ‰, 124์—์„œ 128์„ ๋บ€ ๊ฐ’์ธ -4๊ฐ€ ๋˜๋Š” ๊ฒƒ์ด๋‹ค.


์ •์ˆ˜(Int)์˜ ์‹œํ”„ํŒ… (Shifting Behavior for Unsigned Integers)

 

์–‘์ˆ˜์ธ์ง€ ์ •์ˆ˜์ธ์ง€๋ฅผ ๋œปํ•˜๋Š” ๋งจ ์ฒซ๋ฒˆ์งธ๊ฐ’์ด ์œ ์ง€๋˜๊ณ  ์˜ค๋ฅธ์ชฝ์ด๋‚˜ ์™ผ์ชฝ์œผ๋กœ ์ด๋™ํ•˜๊ฒŒ ๋œ๋‹ค.

 

 

 

let binaryNum: Int8 = 0b00000100
print(binaryNum << 1)// 8 00001000
print(binaryNum << 2)// 16 00010000
print(binaryNum << 5)// -128 <= 0-128 10000000
print(binaryNum << 6)// 0 00000000
print(binaryNum >> 2)// 1 00000001

์˜ค๋ฒ„ํ”Œ๋กœ์šฐ ์—ฐ์‚ฐ์ž (Overflow Operators)

 

์•„๋ž˜์™€ ๊ฐ™์ด ๋ฒ”์œ„๋ฅผ ๋„˜์–ด์„œ๊ฒŒ ๋˜๋ฉด overflow ์—๋Ÿฌ๊ฐ€ ๋ฐœ์ƒํ•˜๊ฒŒ ๋œ๋‹ค.

 

 

 

์—๋Ÿฌ๊ฐ€ ์ƒ๊ธฐ์ง€ ์•Š๊ณ  ๊ทธ๋ƒฅ ์ˆœํ™˜์„ ํ•˜๊ฒŒ ํ•˜๋ฉด ์•ˆ๋ ๊นŒ?

 

 

 

๊ทธ ๋ฐฉ๋ฒ•์ด ๋ฐ”๋กœ ์˜ค๋ฒ„ํ”Œ๋กœ์šฐ ์—ฐ์‚ฐ์ž์ธ '&'์„ ์“ฐ๋Š” ๊ฒƒ์ด๋‹ค.

 

์ฆ‰, ์ตœ๋Œ“๊ฐ’์ด ๋„˜์–ด์„œ๊ฒŒ ๋˜๋ฉด ์ตœ์†Ÿ๊ฐ’์— ์ด์–ด์„œ ์ถ”๊ฐ€๊ฐ€ ๋˜๊ณ  ์ตœ์†Ÿ๊ฐ’๋ณด๋‹ค ๋” ์ž‘์•„์ง€๋ฉด ์ตœ๋Œ“๊ฐ’์— ์ด์–ด์„œ ๋นผ๋Š” ๊ฒƒ์ด๋‹ค.

 

Int8์˜ ๋ฒ”์œ„๋Š” -128...127์ด๋‹ค.

 

์ตœ๋Œ“๊ฐ’์ธ 127์— ์˜ค๋ฒ„ํ”Œ๋กœ์šฐ ์—ฐ์‚ฐ์ž๋ฅผ ์‚ฌ์šฉํ•ด์„œ +1์„ ํ•˜๊ฒŒ ๋˜๋ฉด ์ตœ์†Ÿ๊ฐ’์ธ -128์ด ๋˜๊ณ 

 

var number:Int8 = 127
number &+= 1
print(number) //-128

 

์ตœ์†Ÿ๊ฐ’์ธ -128์— ์˜ค๋ฒ„ํ”Œ๋กœ์šฐ ์—ฐ์‚ฐ์ž๋ฅผ ์‚ฌ์šฉํ•ด์„œ -1์„ ํ•˜๊ฒŒ ๋˜๋ฉด ์ตœ๋Œ“๊ฐ’์ธ 127์ด ๋œ๋‹ค.


์˜ค๋Š˜์€ ์ด๋ ‡๊ฒŒ Swift์˜ ๊ณ ๊ธ‰ ์—ฐ์‚ฐ์ž๋ฅผ ์•Œ์•„๋ณด์•˜๋Š”๋ฐ์š”.

 

๋น„ํŠธ์™€์ด์ฆˆ ์—ฐ์‚ฐ์ž๋ฅผ ์ด์šฉํ•˜๋ฉด ๊ธฐ์กด์˜ ์•Œ๊ณ ๋ฆฌ์ฆ˜์„ ํ•ด๊ฒฐํ•  ๋•Œ ๊ณต๊ฐ„ ๋ณต์žก๋„๋‚˜ ์‹œ๊ฐ„ ๋ณต์žก๋„ ์ธก๋ฉด์—์„œ ๊ฝค ํšจ์œจ์ ์œผ๋กœ ์‚ฌ์šฉ๋  ๊ฑฐ๋ผ๊ณ  ์ƒ๊ฐํ–ˆ๊ณ ,

 

์˜ค๋ฒ„ํ”Œ๋กœ์šฐ ์—ฐ์‚ฐ์ž๋Š” ์ปดํŒŒ์ผ ์—๋Ÿฌ๋ฅผ ํ•ด๊ฒฐํ•˜๋Š”๋ฐ ์œ ์šฉํ•˜๊ฒŒ ์‚ฌ์šฉํ•  ๊ฒƒ ๊ฐ™์Šต๋‹ˆ๋‹ค.

 

ํ˜น์‹œ๋ผ๋„ ํ‹€๋ฆฐ ์ ์ด๋‚˜ ๊ถ๊ธˆํ•œ ์ ์ด ์žˆ๋‹ค๋ฉด ๋Œ“๊ธ€๋กœ ์•Œ๋ ค์ฃผ์„ธ์š”!


Reference

 

https://jusung.gitbook.io/the-swift-language-guide/language-guide/26-advanced-operators

 

๊ณ ๊ธ‰ ์—ฐ์‚ฐ์ž (Advanced Operators) - The Swift Language Guide (ํ•œ๊ตญ์–ด)

์ ‘๋‘, ์ ‘๋ฏธ ์—ฐ์‚ฐ์ž (Prefix and Postfix Operators)

jusung.gitbook.io

 

728x90
๋ฐ˜์‘ํ˜•

๋Œ“๊ธ€