Swift 공식 문서 정리 - 고급 연산자 (Advanced Operators)

안녕하세요. 오늘은 Swift의 고급 연산자에 대해 알아보겠습니다. 기본 연산자보다 더 복잡한 값을 조작할 수 있는 비트 연산자, 사용자 정의 연산자, 그리고 결과 빌더까지 Swift가 제공하는 다양한 고급 기능을 살펴보겠습니다.

📌 비트 연산자 (Bitwise Operators)

비트 연산자는 데이터 구조 내의 개별 비트를 직접 조작할 수 있게 해주는 도구입니다. 저수준 프로그래밍, 그래픽 작업, 디바이스 드라이버 개발 등에 특히 유용합니다.

비트 NOT 연산자 (~)

비트 NOT 연산자는 모든 비트를 반전시킵니다. 0은 1로, 1은 0으로 바꿉니다.

let initialBits: UInt8 = 0b00001111  // 이진수로 00001111 (십진수 15)
let invertedBits = ~initialBits      // 이진수로 11110000 (십진수 240)

비트 AND 연산자 (&)

비트 AND 연산자는 두 숫자를 비교해 두 비트가 모두 1일 때만 결과 비트를 1로 설정합니다.

let firstSixBits: UInt8 = 0b11111100
let lastSixBits: UInt8  = 0b00111111
let middleFourBits = firstSixBits & lastSixBits  // 0b00111100 (십진수 60)

비트 OR 연산자 (|)

비트 OR 연산자는 두 숫자를 비교해 어느 한쪽의 비트라도 1이면 결과 비트를 1로 설정합니다.

let someBits: UInt8 = 0b10110010
let moreBits: UInt8 = 0b01011110
let combinedBits = someBits | moreBits  // 0b11111110 (십진수 254)

비트 XOR 연산자 (^)

비트 XOR 연산자(배타적 OR)는 두 숫자를 비교해 두 비트가 다를 때만 결과 비트를 1로 설정합니다.

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

비트 이동 연산자 (<<  및  >>)

비트 이동 연산자는 모든 비트를 지정된 수만큼 왼쪽이나 오른쪽으로 이동시킵니다.

부호 없는 정수의 이동

let shiftBits: UInt8 = 4   // 0b00000100
shiftBits << 1             // 0b00001000 (8)
shiftBits << 2             // 0b00010000 (16)
shiftBits << 5             // 0b10000000 (128)
shiftBits << 6             // 0b00000000 (0, 오버플로우됨)
shiftBits >> 2             // 0b00000001 (1)

비트 이동은 색상 값 처리 같은 작업에 매우 유용합니다:

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

부호 있는 정수의 이동

부호 있는 정수는 2의 보수 표현을 사용하기 때문에 이동 동작이 조금 다릅니다. 오른쪽 이동 시 빈 공간에 부호 비트가 채워집니다(산술 이동).

📌 오버플로우 연산자 (Overflow Operators)

Swift에서는 기본적으로 값이 타입의 범위를 벗어나면 오류가 발생합니다. 하지만 오버플로우를 허용하는 특수 연산자를 제공합니다:

• 오버플로우 덧셈 (&+)
• 오버플로우 뺄셈 (&-)
• 오버플로우 곱셈 (&*)

 

var unsignedOverflow = UInt8.max        // 255
unsignedOverflow = unsignedOverflow &+ 1 // 0 (255를 넘어서 0으로 순환)

var unsignedOverflow2 = UInt8.min       // 0
unsignedOverflow2 = unsignedOverflow2 &- 1 // 255 (0에서 아래로 내려가 255로 순환)

부호 있는 정수에서도 오버플로우가 발생할 수 있습니다:

var signedOverflow = Int8.min            // -128
signedOverflow = signedOverflow &- 1     // 127 (오버플로우로 최대값으로 순환)

📌 우선순위와 연관성 (Precedence and Associativity)

연산자 우선순위는 어떤 연산자가 먼저 계산되는지를 결정합니다. 연관성은 같은 우선순위의 연산자들이 어떤 순서로 계산되는지(왼쪽에서 오른쪽, 또는 오른쪽에서 왼쪽)를 결정합니다.

2 + 3 % 4 * 5  // 17

// 우선순위에 따라 다음과 같이 계산됩니다:
// 1. 3 % 4 = 3 (% 연산이 + 보다 우선순위가 높음)
// 2. 3 * 5 = 15 (% 와 *는 같은 우선순위이며 왼쪽에서 오른쪽으로 연관)
// 3. 2 + 15 = 17

📌 연산자 메서드 (Operator Methods)

Swift에서는 클래스와 구조체가 기존 연산자의 동작을 자신만의 방식으로 구현할 수 있습니다. 이를 "연산자 오버로딩"이라고 합니다.

이항 연산자 구현

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는 (5.0, 5.0) 값을 가집니다

접두사 및 접미사 연산자 구현

단항 연산자(하나의 피연산자에만 적용되는 연산자)를 구현할 때는 prefix 또는 postfix 수식어를 사용합니다:

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  // (-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)
original += Vector2D(x: 3.0, y: 4.0)
// original은 이제 (4.0, 6.0) 값을 가집니다

등가 연산자 구현

등가 연산자(==, !=)를 구현하려면 Equatable 프로토콜을 준수해야 합니다:

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

// 이제 벡터 비교가 가능합니다
if twoThree == anotherTwoThree {
    print("두 벡터는 같습니다.")
}

📌 사용자 정의 연산자 (Custom Operators)

Swift에서는 완전히 새로운 연산자를 정의할 수도 있습니다:

// 새로운 접두사 연산자 정의
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와 afterDoubling 모두 (2.0, 8.0) 값을 가집니다

사용자 정의 중위 연산자의 우선순위

중위 연산자(두 피연산자 사이에 위치하는 연산자)를 정의할 때는 우선순위 그룹을 지정할 수 있습니다:

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는 (4.0, -2.0) 값을 가집니다

📌 결과 빌더 (Result Builders)

결과 빌더는 중첩된 데이터 구조(리스트, 트리 등)를 선언적인 방식으로 생성할 수 있게 해주는 Swift의 강력한 기능입니다.

결과 빌더 예제

다음은 별과 텍스트를 사용하여 그래픽을 구성하는 결과 빌더 예제입니다:

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") + "!")),
    Stars(length: 2),
])
print(manualDrawing.draw())
// 출력: "***Hello RAVI PATEL!**"

결과 빌더를 사용하면 이 코드를 더 선언적으로 작성할 수 있습니다:

@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
    }
}

// 결과 빌더를 사용하는 함수
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 personalGreeting = makeGreeting(for: "Ravi Patel")
print(personalGreeting.draw())
// 출력: "***Hello RAVI PATEL!**"

결과 빌더는 반복문도 지원할 수 있습니다:

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)
    }
}
// 출력: "Stars: * ** ***"

📌 정리

Swift의 고급 연산자와 결과 빌더는 코드의 표현력을 크게 향상시키는 강력한 기능입니다:

• 비트 연산자는 개별 비트를 조작하여 저수준 프로그래밍에 유용합니다.
• 오버플로우 연산자는 값이 타입의 범위를 벗어날 때의 동작을 제어합니다.
• 연산자 오버로딩을 통해 기존 연산자를 자신의 타입에 맞게 재정의할 수 있습니다.
• 사용자 정의 연산자로 완전히 새로운 연산자를 만들 수 있습니다.
• 결과 빌더는 중첩된 데이터 구조를 선언적으로 구성할 수 있게 해줍니다.