[Swift🦩] #28 고급 연산자

• 기본 연산자 외에도 비트 연산자 같은 고급 연산자가 제공된다.
• Swift 의 연산자는 오버플로우가 없다!!! 그래서 오버플로우가 되는 연산자는 따로 있음.
• 사용자가 직접 중위, 접두사, 접미사, 할당 연산자를 자유롭게 정의할 수 있다. 해당 연산자 지원을 위해 extension 을 사용할 수 있음!!
• 여기 에 더 많은 연산자에 대한 설명이 있다.

1. 비트 연산자

• 데이터 비트를 조작.
• low-level 프로그래밍
• 데이터 인코딩, 디코딩 등을 할 때 사용하기도 한다.

Bitwise NOT Operator ~

• 모든 비트를 반전한다.

let initialBits: UInt8 = 0b00001111
let invertedBits = ~initialBits  // equals 11110000 240

Bitwise AND Operator &

• 두 숫자의 비트를 결합한다.
• 둘 다 1이면 1, 아니면 0

let firstSixBits: UInt8 = 0b11111100
let lastSixBits: UInt8  = 0b00111111
let middleFourBits = firstSixBits & lastSixBits  // equals 00111100

Bitwise OR Operator |

let someBits: UInt8 = 0b10110010
let moreBits: UInt8 = 0b01011110
let combinedbits = someBits | moreBits  // equals 11111110

Bitwise XOR Opertor ^

• 비트가 같으면 0, 다르면 1 반환

let firstBits: UInt8 = 0b00010100
let otherBits: UInt8 = 0b00000101
let outputBits = firstBits ^ otherBits  // equals 00010001

Bitwise Shift Operators << >>

• << : 왼쪽으로 뒤의 숫자 비트만큼 이동. ( * 2 ^ (숫자개수) ) 와 같음
• >> : 오른쪽으로 뒤의 숫자 비트만큼 이동. ( / 2 ^ (숫자개수) ) 와 같음

부호 없는 정수에서 Shift - 논리적 이동

1. 기존 비트는 요청된 숫자만큼 오른쪽/왼쪽으로 이동.
2. 정수 저장범위를 넘은 비트는 삭제됨.
3. 원래 비트가 왼쪽/오른쪽으로 이동한 후 빈 자리에는 0이 들어감.

let shiftBits: UInt8 = 4   // 00000100 in binary
shiftBits << 1             // 00001000
shiftBits << 2             // 00010000
shiftBits << 5             // 10000000
shiftBits << 6             // 00000000
shiftBits >> 2             // 00000001

색상값을 저장하기 위해 인코딩, 디코딩 하는 예제.

let pink: UInt32 = 0xCC6699
let redComponent = (pink & 0xFF0000) >> 16    // redComponent is 0xCC, or 204
let greenComponent = (pink & 0x00FF00) >> 8   // greenComponent is 0x66, or 102
let blueComponent = pink & 0x0000FF           // blueComponent is 0x99, or 153

부호 있는 정수에서 Shift

• 맨 앞 비트가 부호를 표시하는 비트라서 복잡하다.
• 맨 앞 비트는 부호, 그 뒤의 7자리가 실제 숫자를 표현하는 부분이다.
• 음수는 2의 보수로 나타낸다.
  • 1의 보수 -> 전부 반전한 후
  • 2의 보수 -> 1 더함.

• ex) 4 = 00000100 -> 1의 보수 11111011 -> +1 11111100 -> -4

장점
1. 부호비트는 그냥 두고 나머지 자리로 이진 덧셈을 하고, int 크기를 벗어나는 것 자르면 됨.
2. 비트를 왼쪽 오른쪽으로 이동할 수 있다.
하지만, 왼쪽에 비어있는 모든 비트에 0이 아니라 해당 부호 비트를 채우게 된다. -> 부호를 유지하면서 연산.

2. 오버플로우 연산자

• Swift 에서는 허용 범위를 넘어가면 에러를 내서 안정성을 제공.
• 하지만 사용 가능 비트를 잘라서 쓰려고 오버플로우를 하고 싶다면?

• &+ &- &* 를 이용하자.

값 오버플로우

• 부호 없는 정수에서는 -1 과 양수 마지막 값에서,

var unsignedOverflow = UInt8.min
// unsignedOverflow equals 0, which is the minimum value a UInt8 can hold
unsignedOverflow = unsignedOverflow &- 1
// unsignedOverflow is now equal to 255

• 부호 있는 정수에서는 음수 마지막 값, 양수 마지막 값을 오갈 때 오버플로우가 발생한다.

var signedOverflow = Int8.min
// signedOverflow equals -128, which is the minimum value an Int8 can hold
signedOverflow = signedOverflow &- 1
// signedOverflow is now equal to 127

3. 우선순위와 연관성

• 연산자 우선순위.
• 왼쪽에 있는 표현 관련인지 오른쪽에 있는 표현 관련인지를 따져서 왼쪽에서 그룹화하거나 오른쪽에서 그룹화한다.

2 + 3 % 4 * 5 // this equals 17
2 + ((3 % 4) * 5)

NOTE : C언어 우선순위와 완벽하게 일치하진 않을 수도 있으므로 포팅 시 주의하자.

4. 연산자 메서드

• 기존 연산자의 자체 구현을 제공할 수 있다.
• 연산자 오버로딩

// 벡터의 덧셈 연산자 오버로딩
struct Vector2D {
    var x = 0.0, y = 0.0
}

extension Vector2D {
    static func + (left: Vector2D, right: Vector2D) -> Vector2D {
        return Vector2D(x: left.x + right.x, y: left.y + right.y)
    }
}

let vector = Vector2D(x: 3.0, y: 1.0)
let anotherVector = Vector2D(x: 2.0, y: 4.0)
let combinedVector = vector + anotherVector
// combinedVector is a Vector2D instance with values of (5.0, 5.0)

Prefix and Postfix Operators

• 연산자가 앞에 오면 접두사 연산자 -3 +3
• 뒤에 오면 접미사 연산자 b!

extension Vector2D {
    static prefix func - (vector: Vector2D) -> Vector2D {
        return Vector2D(x: -vector.x, y: -vector.y)
    }
}

let positive = Vector2D(x: 3.0, y: 4.0)
let negative = -positive
// negative is a Vector2D instance with values of (-3.0, -4.0)
let alsoPositive = -negative
// alsoPositive is a Vector2D instance with values of (3.0, 4.0)

복합 할당 연산자

• 연산 하고 할당까지 하는 것!
• 할당해야 하므로 왼쪽 연산자는 inout 파라미터로 설정한다.

extension Vector2D {
    static func += (left: inout Vector2D, right: Vector2D) {
        left = left + right
    }
}

var original = Vector2D(x: 1.0, y: 2.0)
let vectorToAdd = Vector2D(x: 3.0, y: 4.0)
original += vectorToAdd
// original now has values of (4.0, 6.0)

NOTE : = 과 삼항연산자는 오버로딩 불가능.

등가 연산자

• 사용자 정의 클래스에서 == != 를 정의할 수 있다.
• Equatable 프로토콜을 준수하게 해야한다.

extension Vector2D: Equatable {
    static func == (left: Vector2D, right: Vector2D) -> Bool {
        return (left.x == right.x) && (left.y == right.y)
    }
}

let twoThree = Vector2D(x: 2.0, y: 3.0)
let anotherTwoThree = Vector2D(x: 2.0, y: 3.0)
if twoThree == anotherTwoThree {
    print("These two vectors are equivalent.")
}
// Prints "These two vectors are equivalent."

5. Custom Operators

• 사용자가 직접 정의할 수 있다.

prefix operator +++

extension Vector2D {
    static prefix func +++ (vector: inout Vector2D) -> Vector2D {
        vector += vector
        return vector
    }
}

var toBeDoubled = Vector2D(x: 1.0, y: 4.0)
let afterDoubling = +++toBeDoubled
// toBeDoubled now has values of (2.0, 8.0)
// afterDoubling also has values of (2.0, 8.0)

📕 prefix, infix, postfix 키워드 사용

• infix 의 경우 precedencegroup 키워드로 우선순위 그룹을 지정할 수 있다.
• 명시 안하면 DefaultPrecedence 를 가짐.
• 해당 그룹에는 higerThan, lowerThan (우선순위 관련)
• associativity (결합 방향 left, right, none)
• assignment (옵셔널 체이닝 시, 어느 쪽 부터 체이닝을 하는지 - true : associativity 와 동일한 방향 / false, 명시 안함 : 왼쪽부터 옵셔널 체이닝)

prefix operator **

prefix func ** (value: Int) -> Int {
    return value * value
}

**5 // 25

• 보통은 이런 광범위한 숫자 연산자보다, 클래스나 구조체 안에 static func 로 구현하여, 해당 클래스끼리, 구조체끼리 연산할 수 있게 커스텀 한다.

Custom Infix Operator 의 우선순위

• 사용자가 정의한 중위 연산자는 각 우선순위 그룹에 속해있다.
• 해당 연산에서 제공하는 상대적인 우선순위와 연산자와의 연관성을 지정한다.
• 우선순위 그룹에 명시되지 않았다면 삼항 조건 연산자보다 하나 높은 우선수누이가 제공된다.

// +- 는 +  -  를 쓰니까 그것과 같은 우선순위를 가진다.
infix operator +-: AdditionPrecedence
extension Vector2D {
    static func +- (left: Vector2D, right: Vector2D) -> Vector2D {
        return Vector2D(x: left.x + right.x, y: left.y - right.y)
    }
}
let firstVector = Vector2D(x: 1.0, y: 2.0)
let secondVector = Vector2D(x: 3.0, y: 4.0)
let plusMinusVector = firstVector +- secondVector
// plusMinusVector is a Vector2D instance with values of (4.0, -2.0)

NOTE : 접두사, 접미사 연산자는 우선순위를 지정하진 않지만, 같은 피연산자에 접두 접미가 다 붙으면 접미사가 먼저 적용된다.

6. 결과 빌더

• 리스트나 트리 같은 중첩된 데이터를 선언형으로 생성하기 위해 구문을 추가한다.
• if for 같은 구문을 추가할 수 있다.

protocol Drawable {
    func draw() -> String
}
struct Line: Drawable {
    var elements: [Drawable]
    func draw() -> String {
        return elements.map { $0.draw() }.joined(separator: "")
    }
}
struct Text: Drawable {
    var content: String
    init(_ content: String) { self.content = content }
    func draw() -> String { return content }
}
struct Space: Drawable {
    func draw() -> String { return " " }
}
struct Stars: Drawable {
    var length: Int
    func draw() -> String { return String(repeating: "*", count: length) }
}
struct AllCaps: Drawable {
    var content: Drawable
    func draw() -> String { return content.draw().uppercased() }
}


let name: String? = "Ravi Patel"
let manualDrawing = Line(elements: [
    Stars(length: 3),
    Text("Hello"),
    Space(),
    AllCaps(content: Text((name ?? "World") + "!")), // 어우 복잡해... ResultBuilder 를 사용하자.
    Stars(length: 2),
    ])
print(manualDrawing.draw())
// Prints "***Hello RAVI PATEL!**"

@resultBuilder 라는 키워드를 붙여서 구조체를 선언한다.

@resultBuilder
struct DrawingBuilder {
    static func buildBlock(_ components: Drawable...) -> Drawable {
        return Line(elements: components)
    }
    static func buildEither(first: Drawable) -> Drawable {
        return first
    }
    static func buildEither(second: Drawable) -> Drawable {
        return second
    }
}

• DrawingBuilder 라는 빌더로 클로저 인자를 넘겨주어서, 해당 클로저 (() -> Drawable)를 실행해서 Drawable 을 return 하는 함수를 만든다.
• 이제 실행할 때, Drawable 을 반환하는 클로저를 넘겨서 Drawable 을 생성할 수 있게 되었다.

func draw(@DrawingBuilder content: () -> Drawable) -> Drawable {
    return content()
}
func caps(@DrawingBuilder content: () -> Drawable) -> Drawable {
    return AllCaps(content: content())
}

func makeGreeting(for name: String? = nil) -> Drawable {
    let greeting = draw {
        Stars(length: 3)
        Text("Hello")
        Space()
        caps {
            if let name = name {
                Text(name + "!")
            } else {
                Text("World!")
            }
        }
        Stars(length: 2)
    }
    return greeting
}
let genericGreeting = makeGreeting()
print(genericGreeting.draw())
// Prints "***Hello WORLD!**"

let personalGreeting = makeGreeting(for: "Ravi Patel")
print(personalGreeting.draw())
// Prints "***Hello RAVI PATEL!**"

if-else 에서 각각 DrawingBuilder 의 메서드를 호출할 수도 있다.

let capsDrawing = caps {
    let partialDrawing: Drawable
    if let name = name {
        let text = Text(name + "!")
        partialDrawing = DrawingBuilder.buildEither(first: text)
    } else {
        let text = Text("World!")
        partialDrawing = DrawingBuilder.buildEither(second: text)
    }
    return partialDrawing
}

extension DrawingBuilder {
    static func buildArray(_ components: [Drawable]) -> Drawable {
        return Line(elements: components)
    }
}
let manyStars = draw {
    Text("Stars:")
    for length in 1...3 {
        Space()
        Stars(length: length)
    }
}

for 문 지원도 가능하다.

extension DrawingBuilder {
    static func buildArray(_ components: [Drawable]) -> Drawable {
        return Line(elements: components)
    }
}
let manyStars = draw {
    Text("Stars:")
    for length in 1...3 {
        Space()
        Stars(length: length)
    }
}

어떻게 변환되는지는 여기

참고
https://bbiguduk.gitbook.io/swift/language-guide-1/advanced-operators