Swift 공식 문서 정리 - 초기화 (Initialization)

안녕하세요. 오늘은 Swift '초기화(Initialization)'에 대해 알아보겠습니다. 초기화는 클래스, 구조체, 열거형의 인스턴스를 사용 가능한 상태로 준비하는 과정으로, Swift의 타입 안전성과 객체 지향 설계의 핵심입니다.

📌 초기화란? (Initialization)

초기화는 새로운 인스턴스가 사용되기 전에 필요한 준비 과정을 수행합니다. 이 과정에서는:

• 모든 저장 프로퍼티에 초기값 설정
• 기타 설정 및 준비 작업 수행

Swift에서는 init 키워드를 사용하여 초기화 구문(initializer)을 정의합니다:

struct Fahrenheit {
    var temperature: Double
    
    init() {
        temperature = 32.0  // 물이 얼어버리는 화씨 온도
    }
}

var f = Fahrenheit()
print("기본 온도는 \(f.temperature)° 화씨입니다")
// 출력: "기본 온도는 32.0° 화씨입니다"

 

초기화 구문(Initializer): 새 인스턴스를 생성하기 위해 호출되는 특수 메서드로, 객체가 사용되기 전에 모든 프로퍼티가 적절히 초기화되도록 보장합니다.

📌 저장 프로퍼티의 초기값 설정 방법

Swift에서는 모든 저장 프로퍼티에 반드시 초기값을 설정해야 합니다. 이를 위한 두 가지 방법이 있습니다:

1. 기본 프로퍼티 값 설정

프로퍼티를 선언할 때 직접 초기값을 할당합니다:

struct Fahrenheit {
    var temperature = 32.0  // 선언과 동시에 기본값 설정
}

기본 프로퍼티 값(Default Property Value): 프로퍼티 선언 시 직접 값을 할당하는 방식으로, 코드를 더 간결하게 만들고 초기화 의도를 명확하게 합니다.

2. 초기화 구문 내에서 설정

struct Celsius {
    var temperatureInCelsius: Double
    
    init(fromFahrenheit fahrenheit: Double) {
        temperatureInCelsius = (fahrenheit - 32.0) / 1.8
    }
    
    init(fromKelvin kelvin: Double) {
        temperatureInCelsius = kelvin - 273.15
    }
}

주의: 초기화 구문에서 저장 프로퍼티에 값을 설정할 때는 프로퍼티 관찰자가 호출되지 않습니다.

📌 초기화 구문 커스터마이징

Swift는 다양한 방식으로 초기화 과정을 커스터마이징할 수 있는 유연성을 제공합니다.

초기화 파라미터 (Initialization Parameters)

struct Celsius {
    var temperatureInCelsius: Double
    
    init(fromFahrenheit fahrenheit: Double) {
        temperatureInCelsius = (fahrenheit - 32.0) / 1.8
    }
    
    init(fromKelvin kelvin: Double) {
        temperatureInCelsius = kelvin - 273.15
    }
    
    init(_ celsius: Double) {  // 인수 레이블 없는 초기화 구문
        temperatureInCelsius = celsius
    }
}

let bodyTemp = Celsius(37.0)  // 인수 레이블 없이 호출
let boilingPoint = Celsius(fromFahrenheit: 212.0)  // 인수 레이블과 함께 호출

파라미터 이름과 인수 레이블: 함수나 메서드처럼 초기화 구문도 내부에서 사용할 파라미터 이름과 호출 시 사용할 인수 레이블을 가질 수 있습니다.

언더스코어(_): 인수 레이블을 생략하고 싶을 때 사용합니다.

옵셔널 프로퍼티 타입

값이 없을 수도 있는 프로퍼티는 옵셔널 타입으로 선언할 수 있습니다:

class SurveyQuestion {
    let text: String
    var response: String?  // 옵셔널 문자열 - 초기값은 자동으로 nil
    
    init(text: String) {
        self.text = text
    }
    
    func ask() {
        print(text)
    }
}

let question = SurveyQuestion(text: "치즈를 좋아하나요?")
question.ask()  // "치즈를 좋아하나요?" 출력
question.response = "네, 치즈를 좋아합니다."

옵셔널 프로퍼티(Optional Property): 값이 없을 수도 있음을 나타내는 프로퍼티로, 초기화 시 자동으로 nil로 설정됩니다.

초기화 중 상수 프로퍼티 할당

class SurveyQuestion {
    let text: String  // 상수 프로퍼티
    var response: String?
    
    init(text: String) {
        self.text = text  // 초기화 중에 상수 값 설정
    }
}

상수 프로퍼티(Constant Property): let으로 선언된 프로퍼티로, 초기화 과정에서는 값을 할당할 수 있지만 그 이후에는 변경할 수 없습니다.

📌 기본 초기화 구문과 멤버별 초기화 구문

Swift는 특정 조건에서 자동으로 초기화 구문을 제공합니다.

기본 초기화 구문 (Default Initializers)

모든 프로퍼티가 기본값을 가지고 있고, 사용자 정의 초기화 구문이 없는 클래스나 구조체는 자동으로 기본 초기화 구문을 받습니다:

class ShoppingListItem {
    var name: String?
    var quantity = 1
    var purchased = false
}

var item = ShoppingListItem()  // 기본 초기화 구문 사용

기본 초기화 구문(Default Initializer): 모든 프로퍼티를 기본값으로 초기화하는 파라미터 없는 초기화 구문입니다.

구조체의 멤버별 초기화 구문 (Memberwise Initializers)

사용자 정의 초기화 구문이 없는 구조체는 자동으로 멤버별 초기화 구문을 받습니다:

struct Size {
    var width = 0.0, height = 0.0
}

let twoByTwo = Size(width: 2.0, height: 2.0)  // 멤버별 초기화 구문
let zeroByTwo = Size(height: 2.0)  // width는 기본값 사용
let zeroByZero = Size()  // 모든 프로퍼티 기본값 사용

멤버별 초기화 구문(Memberwise Initializer): 구조체의 각 프로퍼티를 초기화할 수 있는 파라미터를 가진 초기화 구문입니다.

📌 초기화 구문 위임 (Initializer Delegation)

초기화 구문은 다른 초기화 구문을 호출하여 일부 초기화 작업을 위임할 수 있습니다. 이를 통해 코드 중복을 방지합니다.

값 타입의 초기화 구문 위임

값 타입(구조체와 열거형)에서는 self.init을 사용하여 다른 초기화 구문에 위임합니다:

struct Rect {
    var origin = Point()
    var size = Size()
    
    init() {}  // 기본 초기화 구문과 동일
    
    init(origin: Point, size: Size) {
        self.origin = origin
        self.size = size
    }
    
    init(center: Point, size: Size) {
        let originX = center.x - (size.width / 2)
        let originY = center.y - (size.height / 2)
        self.init(origin: Point(x: originX, y: originY), size: size)  // 다른 초기화 구문에 위임
    }
}

초기화 구문 위임(Initializer Delegation): 한 초기화 구문에서 다른 초기화 구문을 호출하여 중복 코드를 줄이는 기법입니다.

클래스의 초기화 구문 위임 규칙

클래스는 상속을 지원하기 때문에 더 복잡한 초기화 구문 위임 규칙을 가집니다:

1. 지정 초기화 구문(Designated Initializers):
   • 클래스의 모든 프로퍼티를 초기화
   • 상위 클래스의 적절한 초기화 구문 호출
   • 주 초기화 경로로 작동
2. 편의 초기화 구문(Convenience Initializers):
   • 동일한 클래스의 다른 초기화 구문 호출
   • 일반적인 초기화 패턴에 대한 shortcut 제공

 

class Vehicle {
    var numberOfWheels = 0
    var description: String {
        return "\(numberOfWheels) wheel(s)"
    }
}

class Bicycle: Vehicle {
    override init() {
        super.init()  // 상위 클래스 초기화 구문 호출
        numberOfWheels = 2
    }
}

초기화 구문 위임 규칙:

1. 지정 초기화 구문은 반드시 상위 클래스의 지정 초기화 구문을 호출해야 함
2. 편의 초기화 구문은 반드시 같은 클래스의 다른 초기화 구문을 호출해야 함
3. 편의 초기화 구문은 궁극적으로 지정 초기화 구문을 호출해야 함

간단히 기억하는 방법:

• 지정 초기화 구문은 항상 위로 위임합니다.
• 편의 초기화 구문은 항상 옆으로 위임합니다.

📌 클래스 상속과 초기화 (2단계 초기화)

Swift의 클래스 초기화는 안전성을 보장하기 위해 2단계로 이루어집니다:

1단계

• 클래스에 도입된 모든 저장 프로퍼티에 초기값 지정
• 상위 클래스 체인을 따라 올라가며 각 클래스가 자신의 프로퍼티 초기화
• 모든 저장 프로퍼티가 초기값을 가지면 1단계 완료

2단계

• 최상위에서 최하위로 내려오면서 인스턴스를 추가로 커스터마이징
• self를 참조하고, 인스턴스 메서드 호출, 프로퍼티 수정 등이 가능

 

class Food {
    var name: String
    
    init(name: String) {
        self.name = name  // 1단계: 자신의 프로퍼티 초기화
    }
}

class RecipeIngredient: Food {
    var quantity: Int
    
    init(name: String, quantity: Int) {
        self.quantity = quantity  // 1단계: 자신의 프로퍼티 초기화
        super.init(name: name)    // 1단계: 상위 클래스 초기화 구문 호출
    }
    
    override convenience init(name: String) {
        self.init(name: name, quantity: 1)  // 다른 초기화 구문에 위임
    }
}

2단계 초기화(Two-Phase Initialization): Swift의 클래스 초기화 안전성을 보장하는 프로세스로, 모든 프로퍼티가 초기화된 후에만 self를 참조할 수 있도록 합니다.

📌 초기화 구문 상속과 재정의

초기화 구문 재정의

하위 클래스는 상위 클래스의 초기화 구문을 재정의할 수 있습니다:

class Vehicle {
    var numberOfWheels = 0
    
    init() {
        // 기본 초기화
    }
}

class Bicycle: Vehicle {
    override init() {
        super.init()  // 반드시 상위 클래스 초기화 구문 호출
        numberOfWheels = 2
    }
}

override: 상위 클래스의 초기화 구문을 재정의할 때 사용하는 키워드입니다.

자동 초기화 구문 상속

특정 조건에서는 하위 클래스가 상위 클래스의 초기화 구문을 자동으로 상속받을 수 있습니다:

1. 하위 클래스가 지정 초기화 구문을 정의하지 않으면, 상위 클래스의 모든 지정 초기화 구문을 상속
2. 하위 클래스가 상위 클래스의 모든 지정 초기화 구문을 구현하면, 상위 클래스의 모든 편의 초기화 구문도 자동 상속

 

class ShoppingListItem: RecipeIngredient {
    var purchased = false  // 모든 새 프로퍼티에 기본값 제공
    
    // 상위 클래스의 모든 초기화 구문 자동 상속
}

📌 실패 가능한 초기화 구문 (Failable Initializers)

초기화가 실패할 수 있는 경우를 처리하기 위해 Swift는 실패 가능한 초기화 구문을 제공합니다:

struct Animal {
    let species: String
    
    init?(species: String) {  // 실패 가능한 초기화 구문
        if species.isEmpty { return nil }
        self.species = species
    }
}

let someCreature = Animal(species: "기린")  // Optional<Animal> 타입
if let giraffe = someCreature {
    print("동물이 \(giraffe.species) 종으로 초기화되었습니다")
}

let emptyAnimal = Animal(species: "")  // nil 반환

실패 가능한 초기화 구문(Failable Initializer): init? 형태로 선언되며, 조건에 따라 초기화를 실패시키고 nil을 반환할 수 있습니다.

열거형의 실패 가능한 초기화 구문

enum TemperatureUnit: Character {
    case kelvin = "K", celsius = "C", fahrenheit = "F"
    
    // 원시값을 가진 열거형은 자동으로 init?(rawValue:)를 제공받습니다
}

if let fahrenheitUnit = TemperatureUnit(rawValue: "F") {
    print("화씨 단위가 정의되어 있습니다")
}

초기화 실패 전파

class Product {
    let name: String
    
    init?(name: String) {
        if name.isEmpty { return nil }
        self.name = name
    }
}

class CartItem: Product {
    let quantity: Int
    
    init?(name: String, quantity: Int) {
        if quantity < 1 { return nil }  // 자체 검증 실패
        self.quantity = quantity
        super.init(name: name)  // 상위 클래스 초기화도 실패 가능
    }
}

📌 필수 초기화 구문 (Required Initializers)

모든 하위 클래스가 반드시 구현해야 하는 초기화 구문을 지정할 수 있습니다:

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

class SomeSubclass: SomeClass {
    required init() {  // 반드시 구현해야 함
        // 하위 클래스 구현
    }
}

required: 하위 클래스가 반드시 해당 초기화 구문을 구현해야 함을 나타내는 키워드입니다.

📌 클로저를 사용한 기본 프로퍼티 값 설정

복잡한 초기화 로직이 필요한 경우, 클로저를 사용하여 기본 프로퍼티 값을 설정할 수 있습니다:

struct Chessboard {
    let boardColors: [Bool] = {
        var board = [Bool]()
        var isBlack = false
        
        for i in 1...8 {
            for j in 1...8 {
                board.append(isBlack)
                isBlack = !isBlack
            }
            isBlack = !isBlack
        }
        
        return board
    }()  // 클로저를 즉시 실행
    
    func squareIsBlackAt(row: Int, column: Int) -> Bool {
        return boardColors[(row * 8) + column]
    }
}

let board = Chessboard()
print(board.squareIsBlackAt(row: 0, column: 1))  // true

클로저를 사용한 프로퍼티 초기화: 복잡한 계산이 필요한 프로퍼티의 초기값을 설정할 때 유용합니다. 클로저 뒤의 ()는 클로저를 즉시 실행하라는 의미입니다.

📌 정리

Swift의 초기화 시스템은 안전하고 유연한 객체 생성을 보장합니다. 주요 특징을 요약하면:

1. 모든 저장 프로퍼티는 반드시 초기값을 가져야 함
2. 초기화 구문은 클래스/구조체의 모든 프로퍼티를 완전히 초기화해야 함
3. 클래스는 지정 초기화 구문과 편의 초기화 구문을 통해 초기화 계층을 형성
4. 2단계 초기화 프로세스는 클래스 초기화의 안전성 보장
5. 실패 가능한 초기화 구문은 초기화 실패 처리를 지원
6. 클로저는 복잡한 프로퍼티 초기화에 활용 가능

Swift의 초기화 시스템을 이해하면 안전하고 효율적인 객체 생성 코드를 작성할 수 있으며, 특히 클래스 계층 구조에서 발생할 수 있는 많은 문제를 예방할 수 있습니다.