Swift 공식 문서 정리 - 프로토콜 (Protocols)

안녕하세요. 오늘은 Swift의 '프로토콜(Protocols)'에 대해 알아보겠습니다.

📌 프로토콜이란?

프로토콜은 특정 작업이나 기능에 필요한 메서드, 프로퍼티, 기타 요구사항의 청사진을 정의합니다. 클래스, 구조체, 열거형은 이러한 프로토콜을 '채택(adopt)'하여 요구사항을 '준수(conform)'할 수 있습니다.

프로토콜은 무엇을 해야 하는지만 정의하고, 어떻게 구현해야 하는지는 각 타입에 맡깁니다. 이를 통해 서로 다른 타입들이 공통된 기능을 제공하면서도 각자의, 이를 유연하게 구현할 수 있는 다형성을 제공합니다.

📌 프로토콜 구문 (Protocol Syntax)

프로토콜은 다음과 같이 정의합니다:

protocol SomeProtocol {
    // 프로토콜 요구사항 정의
}

타입이 프로토콜을 채택할 때는 타입 이름 뒤에 콜론(:)을 붙이고 프로토콜 이름을 명시합니다:

struct SomeStructure: SomeProtocol {
    // 구조체 정의
}

// 여러 프로토콜 채택 시 콤마로 구분
struct AnotherStructure: FirstProtocol, AnotherProtocol {
    // 구조체 정의
}

// 클래스가 상위 클래스를 가진 경우, 상위 클래스를 먼저 명시
class SomeClass: SomeSuperclass, FirstProtocol, AnotherProtocol {
    // 클래스 정의
}

참고: 프로토콜 이름은 다른 Swift 타입처럼 대문자로 시작합니다(예: Equatable, Hashable).

📌 프로퍼티 요구사항 (Property Requirements)

프로토콜은 특정 이름과 타입의 프로퍼티를 요구할 수 있으며, 해당 프로퍼티가 저장 프로퍼티인지 계산 프로퍼티인지는 지정하지 않습니다. 단, 프로퍼티가 읽기 전용인지(gettable) 또는 읽기-쓰기 가능한지(gettable & settable)는 명시해야 합니다.

protocol SomeProtocol {
    var mustBeSettable: Int { get set }  // 읽기-쓰기 가능
    var doesNotNeedToBeSettable: Int { get }  // 읽기 전용
    static var someTypeProperty: Int { get set }  // 타입 프로퍼티
}

예제: 프로퍼티 요구사항 구현

protocol FullyNamed {
    var fullName: String { get }
}

// 구조체로 구현
struct Person: FullyNamed {
    var fullName: String
}

// 클래스로 구현 (계산 프로퍼티 사용)
class Starship: FullyNamed {
    var prefix: String?
    var name: String
    
    init(name: String, prefix: String? = nil) {
        self.name = name
        self.prefix = prefix
    }
    
    var fullName: String {
        return (prefix != nil ? prefix! + " " : "") + name
    }
}

let ncc1701 = Starship(name: "Enterprise", prefix: "USS")
print(ncc1701.fullName)  // "USS Enterprise" 출력

중요: 읽기-쓰기 요구사항(get set)이 있는 프로퍼티는 상수 저장 프로퍼티나 읽기 전용 계산 프로퍼티로 구현할 수 없습니다.

📌 메서드 요구사항 (Method Requirements)

프로토콜은 특정 인스턴스 메서드와 타입 메서드 구현을 요구할 수 있습니다:

protocol RandomNumberGenerator {
    func random() -> Double
}

변경 메서드 요구사항 (Mutating Method Requirements)

구조체나 열거형의 메서드가 인스턴스 자체를 수정해야 하는 경우, mutating 키워드를 사용합니다:

protocol Togglable {
    mutating func toggle()
}

enum OnOffSwitch: Togglable {
    case off, on
    
    mutating func toggle() {
        switch self {
        case .off:
            self = .on
        case .on:
            self = .off
        }
    }
}

참고: 클래스 메서드는 항상 인스턴스를 수정할 수 있으므로 클래스 구현에서는 mutating 키워드를 명시하지 않습니다.

📌 초기화 구문 요구사항 (Initializer Requirements)

프로토콜은 특정 초기화 구문을 요구할 수 있습니다:

protocol SomeProtocol {
    init(someParameter: Int)
}

클래스의 초기화 구문 구현

클래스가 프로토콜의 초기화 구문 요구사항을 구현할 때는 required 키워드를 사용해야 합니다:

class SomeClass: SomeProtocol {
    required init(someParameter: Int) {
        // 초기화 구현
    }
}

참고: final 클래스는 상속될 수 없으므로 required 키워드가 필요 없습니다.

상위 클래스의 지정 초기화 구문을 재정의하고 동시에 프로토콜 요구사항을 충족하는 경우, required와 override 키워드를 모두 사용합니다:

protocol SomeProtocol {
    init()
}

class SomeSuperClass {
    init() {
        // 초기화 구현
    }
}

class SomeSubClass: SomeSuperClass, SomeProtocol {
    // "required"는 SomeProtocol 준수를 위해, "override"는 SomeSuperClass에서 상속
    required override init() {
        // 초기화 구현
    }
}

📌 타입으로서의 프로토콜 (Protocols as Types)

프로토콜은 다음과 같은 상황에서 타입으로 사용될 수 있습니다:

• 함수, 메서드, 초기화 구문의 매개변수 타입 또는 반환 타입
• 상수, 변수, 프로퍼티의 타입
• 배열, 딕셔너리 등 컬렉션의 요소 타입

 

protocol TextRepresentable {
    var textualDescription: String { get }
}

// 프로토콜 타입의 배열
let textRepresentableThings: [TextRepresentable] = [someTextRepresentableInstance, anotherTextRepresentableInstance]

// 프로토콜 타입을 매개변수로 받는 함수
func printDescription(_ thing: TextRepresentable) {
    print(thing.textualDescription)
}

📌 위임 (Delegation)

위임은 클래스나 구조체가 책임의 일부를 다른 타입(대리자)에게 넘기는 디자인 패턴으로, 프로토콜을 통해 쉽게 구현할 수 있습니다:

protocol DiceGameDelegate: AnyObject {
    func gameDidStart(_ game: DiceGame)
    func game(_ game: DiceGame, didEndRound round: Int, winner: Int?)
    func gameDidEnd(_ game: DiceGame)
}

class DiceGame {
    weak var delegate: DiceGameDelegate?
    
    func play() {
        delegate?.gameDidStart(self)
        // 게임 로직...
        delegate?.gameDidEnd(self)
    }
}

// 위임 패턴 구현
class DiceGameTracker: DiceGameDelegate {
    func gameDidStart(_ game: DiceGame) {
        print("게임이 시작되었습니다")
    }
    
    func game(_ game: DiceGame, didEndRound round: Int, winner: Int?) {
        // 라운드 종료 처리
    }
    
    func gameDidEnd(_ game: DiceGame) {
        print("게임이 종료되었습니다")
    }
}

참고: 메모리 누수(강한 참조 순환)를 방지하기 위해 대리자 프로퍼티는 보통 weak 참조로 선언합니다.

📌 확장을 통한 프로토콜 채택 (Adding Protocol Conformance with Extensions)

이미 존재하는 타입에 프로토콜을 채택하기 위해 확장(extension)을 사용할 수 있습니다:

protocol TextRepresentable {
    var textualDescription: String { get }
}

// 기존 타입에 프로토콜 채택 추가
extension Dice: TextRepresentable {
    var textualDescription: String {
        return "A \(sides)-sided dice"
    }
}

조건부 프로토콜 준수 (Conditional Conformance)

특정 조건에서만 프로토콜을 준수하도록 만들 수 있습니다:

extension Array: TextRepresentable where Element: TextRepresentable {
    var textualDescription: String {
        let itemsAsText = self.map { $0.textualDescription }
        return "[" + itemsAsText.joined(separator: ", ") + "]"
    }
}

위 예제에서는 배열의 요소가 TextRepresentable을 준수할 때만 배열도 TextRepresentable을 준수합니다.

📌 프로토콜 상속 (Protocol Inheritance)

프로토콜은 하나 이상의 다른 프로토콜을 상속할 수 있습니다:

protocol InheritingProtocol: SomeProtocol, AnotherProtocol {
    // 추가 요구사항
}

예를 들어:

protocol PrettyTextRepresentable: TextRepresentable {
    var prettyTextualDescription: String { get }
}

PrettyTextRepresentable을 채택하는 타입은 TextRepresentable의 요구사항과 PrettyTextRepresentable의 추가 요구사항을 모두 충족해야 합니다.

📌 클래스 전용 프로토콜 (Class-Only Protocols)

프로토콜이 클래스에만 채택되도록 제한하려면 AnyObject 프로토콜을 상속합니다:

protocol SomeClassOnlyProtocol: AnyObject {
    // 클래스 전용 프로토콜 정의
}

사용 시기: 참조 의미론(reference semantics)이 필요한 경우나 약한 참조(weak reference)가 필요한 경우에 클래스 전용 프로토콜을 사용합니다.

📌 프로토콜 합성 (Protocol Composition)

하나의 타입이 여러 프로토콜을 동시에 준수하도록 요구할 수 있습니다:

protocol Named {
    var name: String { get }
}

protocol Aged {
    var age: Int { get }
}

// Named와 Aged 프로토콜을 모두 준수하는 타입만 허용
func wishHappyBirthday(to celebrator: Named & Aged) {
    print("생일 축하합니다, \(celebrator.name)님! 당신은 \(celebrator.age)살이 되었군요!")
}

클래스 타입과 프로토콜도 함께 조합할 수 있습니다:

func beginConcert(in location: Location & Named) {
    // Location의 하위 클래스이면서 Named 프로토콜을 준수하는 타입만 허용
}

📌 프로토콜 준수성 검사 (Checking Protocol Conformance)

타입이 특정 프로토콜을 준수하는지 확인하기 위해 is 및 as 연산자를 사용할 수 있습니다:

if someObject is HasArea {
    // someObject는 HasArea 프로토콜을 준수함
}

// 다운캐스팅 (안전한 방식)
if let objectWithArea = someObject as? HasArea {
    print("면적은 \(objectWithArea.area)입니다")
}

📌 옵셔널 프로토콜 요구사항 (Optional Protocol Requirements)

프로토콜의 일부 요구사항을 선택적으로 구현할 수 있게 하려면 @objc 속성과 optional 키워드를 사용합니다:

@objc protocol CounterDataSource {
    @objc optional func increment(forCount count: Int) -> Int
    @objc optional var fixedIncrement: Int { get }
}

옵셔널 요구사항을 가진 프로토콜은 Objective-C 클래스나 @objc 속성이 표시된 클래스에서만 채택할 수 있습니다.

옵셔널 요구사항을 사용할 때는 옵셔널 체이닝을 통해 안전하게 접근합니다:

if let amount = dataSource?.increment?(forCount: count) {
    count += amount
}

📌 프로토콜 확장 (Protocol Extensions)

프로토콜에 기본 구현을 제공하기 위해 확장을 사용할 수 있습니다:

extension RandomNumberGenerator {
    func randomBool() -> Bool {
        return random() > 0.5
    }
}

이제 RandomNumberGenerator 프로토콜을 준수하는, 모든 타입은 자동으로 randomBool() 메서드를 사용할 수 있습니다.

제약 조건이 있는 프로토콜 확장

특정 조건을 만족하는 경우에만 프로토콜 확장을 적용할 수 있습니다:

extension Collection where Element: Equatable {
    func allEqual() -> Bool {
        for element in self {
            if element != self.first {
                return false
            }
        }
        return true
    }
}

// 사용 예
let equalNumbers = [100, 100, 100, 100]
print(equalNumbers.allEqual())  // true

위 예제에서는 Collection의 요소가 Equatable을 준수할 때만 allEqual() 메서드를 사용할 수 있습니다.

📌 프로토콜과 자동 합성 (Synthesized Implementations)

Swift는 특정 프로토콜에 대해 자동으로 구현을 제공합니다:

• Equatable: 저장 프로퍼티만 있는 구조체나 열거형
• Hashable: 저장 프로퍼티만 있는 구조체나 열거형
• Comparable: 원시값이 없는 열거형

 

struct Vector3D: Equatable {
    var x = 0.0, y = 0.0, z = 0.0
    // == 연산자가 자동으로 합성됨
}

enum SkillLevel: Comparable {
    case beginner
    case intermediate
    case expert(stars: Int)
    // <, >, <=, >= 연산자가 자동으로 합성됨
}

📌 정리

프로토콜은 Swift의 핵심 기능 중 하나로, 다양한 타입이 공통된 기능을 구현할 수 있도록 유연한 청사진을 제공합니다. 프로토콜을 통해:

1. 인터페이스 분리: 구현과 인터페이스를 분리하여 코드의 모듈성 향상
2. 다형성 제공: 서로 다른 타입이 공통된 동작을 구현
3. 코드 재사용: 프로토콜 확장을 통한 기본 구현 제공
4. 테스트 용이성: 모의 객체(mock)를 쉽게 만들어 테스트 가능

프로토콜은 객체 지향 프로그래밍과 함수형 프로그래밍의 장점을 결합한 프로토콜 지향 프로그래밍(Protocol-Oriented Programming)의 기반이 됩니다.