[Swift🦩] #14 초기화

• 초기화 (Initialization) : 클래스, 구조체, 열거형 인스턴스를 사용하기 위해 준비하는 단계. (초기값을 설정해서 메모리에 할당하고...)
  • initializer 를 정의하여 구현할 수 있다.
  • 값을 반환하지 않음.
• 초기화와 반대로, 값과 자원의 해지를 위해 deinitializer 도 사용할 수 있다.

1. 저장 프로퍼티의 초기값 설정

-> 사실 상 아래 내용들은, 저장 프로퍼티를 초기화하는 순서나... 타입에 따라 초기화 방법 / 프로세스의 차이를 나타내는 것이고 핵심은 여기.

• 인스턴스의 저장 프로퍼티는 사용하기 전에 반드시 특정 값으로 초기화 되어야 한다.
• initializer 에서 프로퍼티에 값을 설정하면, 프로퍼티 옵저버가 호출되지 않는다. 개발할 때 생각 필요

initializer

init() {
    // 가장 간단한 형태. 파라미터 X, init 키워드 사용.
}

struct Fahrenheit {
    var temperature: Double
    init() {
        temperature = 32.0
    }
}
var f = Fahrenheit()
print("기본 온도는 \(f.temperature)°F 입니다.")
// Prints "기본 온도는 32.0°F 입니다."

Default Property Values

위의 예시처럼 항상 같은 값을 기본 값으로 가지는 경우,
선언과 동시에 값을 할당하는 방식으로 초기값을 설정할 수 있다.

struct Fahrenheit {
    var temperature = 32.0
}

2. Customizing Initializer ⭐️⭐️

• 초기값을 함수처럼 입력 파라미터를 받아서 커스터마이징 할 수 있다.
• 외부 이름, 내부 이름 사용 가능.

초기화 파라미터

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 boilingPointOfWater = Celsius(fromFahrenheit: 212.0) // 100.0
let freezingPointOfWater = Celsius(fromKelvin: 273.15) // 0.0

파라미터 이름과 인자 레이블 ~= 오버로딩

• 함수처럼 메서드 이름은 사용하지 않고 init 으로 사용하기 때문에,
• 여러 init 을 구별하는데 있어서 인자 이름과 개수가 중요한 역할을 한다. (함수의 오버로딩처럼)
• 초기화 시 인자 이름을 안넣고 싶다면? 함수처럼 _ 사용하자!

struct Color {
    let red, green, blue: Double
    // 인자 3개인 init
    init(red: Double, green: Double, blue: Double) {
        self.red   = red
        self.green = green
        self.blue  = blue
    }
    // 인자 1개인 init
    init(white: Double) {
        red   = white
        green = white
        blue  = white
    }
    // 인자 1개인 init 이나 위와 다름.
    // 인자 이름이 다르니까!!
    init(red: Double) {
        self.red   = red
        green = 0
        blue  = 0
    }
}

Optinal Property Types

• 만약 초기화가 끝났을 때, 값이 비어있을 수 있는 상황이라면 optional 로 선언하자. 자동으로 nil 이 할당된다.

class SurveyQuestion {
    let text: String
    var response: String?
    init(text: String) {
        self.text = text
    }
    func ask() {
        print(text)
    }
}
let beetsQuestion = SurveyQuestion(text: "How about beets?")
beetsQuestion.ask()
// Prints "How about beets?"
beetsQuestion.response = "I also like beets. (But not with cheese.)"

• let 으로 선언되면, 초기화 과정에서는 값을 할당할 수 있지만, 초기화 된 후에는 수정할 수 없다.
• 클래스 인스턴스에 있는 var 의 경우 언제든지 수정할 수 있지만, 하위 클래스에서는 수정할 수 없다.

3. Default Inititalizer

• init 을 정의하지 않아도 기본적으로 하나 제공해 준다.
• 단, 모든 프로퍼티에 기본값이 설정된 경우에만 제공!
  • 파라미터가 없는 형태가 제공됨.

class Album {
    let titleSong: String = "INVU"
    var hotSong: String? // 기본적으로 nil 이 제공됨.
    var top100: Bool = true
}

var third = Album()
third.hotSong = "그런 밤"

구조체 타입에 대한 멤버별 초기화 구문

• 구조체 타입은 init을 정의하지 않으면, 자동적으로 전체 멤버에 대한 init 이 주어진다.
• 기본 값이 정해져 있는 경우 생략이 가능하다.

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

// 아래 3 라인은 모두 같은 뜻.
let twoByTwo = Size(width: 2.0, height: 2.0)
let twoByTwo = Size(width: 2.0)
let twoByTwo = Size()

4. 값 타입에서 초기화 위임(init delegation)

• 같은 값 타입 내의 초기화 구문을 self.init 으로 다른 초기화 구문에서 부를 수 있다.
• 값 타입에서 초기화 구문을 하나 정의하면, 기본으로 제공되는 기본 초기화 구문 / 멤버별 초기화 구문에 접근할 수 없다.
• 만약 기본, 멤버별, 커스텀 초기화 구문에 전부 접근하고 싶다면, 커스텀 init 을 extension 에 작성하면 된다.

struct Size {
    var width = 0.0, height = 0.0
}
struct Point {
    var x = 0.0, y = 0.0
}

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)

        // 하나의 init 에서 다른 init 호출 가능.
        self.init(origin: Point(x: originX, y: originY), size: size)
    }
}

5. 클래스 상속과 초기화

• 모든 저장 프로퍼티(상속된거 포함)는 초기화 중에 반드시 초기값이 할당 되어야 한다.
• 초기화를 위해서, designated init, convenience init 을 정의할 수 있다.

1. Designated init

• 클래스의 주 초기화 구문
• 해당 클래스에 있는 모든 프로퍼티를 초기화
• 상위 클래스 초기화를 호출하여 상위 클래스 체인을 쭉~ 타고 초기화 진행
  • 초기화 프로세스의 최상위 클래스(더이상 올라갈 곳이 없는) 를 funel 지점이라고 한다.

-> 클래스에 거의 존재하지 않고(기본 init 이용), 있으면 하나만 있다.

// 저장 프로퍼티에 대한 초기화를 모두 해두고,
class ViewModel {
    var title: String = "title"
    var content: String = "content"
    var author: String?
}
// 기본 init 사용
let vm = ViewModel()

• 클래스는 적어도 하나의 designated init 을 가져야 한다.
  • 상위 클래스에서 designated init 을 상속하는 것도 가능.

init(parameters) {
    //statements
}

2. Convenience init

• 보조 초기화 구문
• designated init 의 파라미터를 기본값으로 설정하여, 동일한 클래스의 designated init 를 호출하도록 정의한다.
• 특정 케이스나 입력 값 타입에 대한 클래스 인스턴스를 생성하기 위해 사용하기도 한다.

-> 대체로 제공하지 않고, 시간이 절약되거나 더 명확한 의미를 지닐때만 만든다.

convenience init(author: String) {
    self.init() // 같은 계층 내의 desinated init 을 부른다.
    self.author = author
}

let vm = ViewModel(author: "익명의 코끼리")

convenience init(parameters) {
    // statements
}

3. Initializer Delegation for Class Types ⭐️

1. designated init 은 상위 클래스의 designated init 을 항상 불러야 함. (Base Class 라면 예외)
2. convenience init 은 같은 클래스 내의 다른 init 을 항상 불러야 함.
3. convenience init 은 궁극적으로 같은 클래스 내의 다른 designated init 을 항상 불러야 함.

결론 : desinated init 은 상위 클래스로, convenience 는 같은 클래스로 init 을 위임한다.

4. 2단계 초기화 ⭐️

• 초기화를 안전하게 수행하고, 클래스에 유연성을 제공하기 위해 수행한다.
  • 프로퍼티 값이 초기화 되기 전에 프로퍼티에 접근하는 것을 막고,
  • 다른 초기화 구문이 예상치 못한 다른 값을 설정하는 것을 막는다.

단계

1. 각 stored property 가 해당 프로퍼티를 가지고 있는 클래스에 의해 초기값 할당
2. (모든 저장 프로퍼티의 값이 결정되면) 각 클래스에 저장된 프로퍼티를 추가로 커스텀할 수 있음.

NOTE

• Obj-c 의 경우는 모든 프로퍼티에 0 or null 을 넣고 / 커스텀 하는 것에 반해
• Swift 는 모든 프로퍼티에 사용자 정의 초기값을 설정할 수 있어서, 0 or nil 을 가지지 않는 타입에 대처할 수 있다.

안전 점검

1. designated init 은 상위 클래스의 init 에 위임하기 전에, 클래스에 추가된 모든 프로퍼티가 초기화 되었는지 확인.
2. designated init 은 상속된 프로퍼티에 값을 할당하기 전에, 상위 클래스 초기화 구문에 위임. 안그러면 부모의 값에 덮어쓰임
3. convenience init 은 모든 프로퍼티에 값을 할당하기 전에 다른 초기화 구문에 위임. 안그럼 designated 에 덮어쓰여짐.
4. 초기화 구문은 첫번째 초기화가 완료되기 전까지 인스턴스 메서드 호출, 프로퍼티 값 읽거나, self 값을 참조할 수 없다.

init() {
    // 상속되지 않은 모든 프로퍼티 초기화
    
    super.init() // 상속된 값 설정됨
    
    // 상속받은 모든 프로퍼티 초기화
}

convenience init() {
    self.init() // designated init
    
    // 초기화 하고 싶은 값 초기화.
}

1 단계

1. class 에서 designated / convenience init 호출
2. class 에 새로운 인스턴스에 대한 메모리 할당. (아직 초기화는 X)
3. designated init 이 모든 stored property 가 값을 가지고 있는지 확인 -> stored property 에 대한 메모리 초기화
4. designated init 은 상위 클래스 초기화 구문에 초기화 위임.
5. 계속 위임해서 최상위 체인까지 올라감.
6. 최상위 체인에서 모든 stored property 가 값을 가지고 있다고 확인하면, 인스턴스의 메모리가 완벽하게 초기화 된 것으로 간주.

2 단계

1. 체인의 최상위에서 하나씩 아래로 내려가면, designated init 에서 추가로 사용자가 원하는 대로 인스턴스에 값을 지정할 수 있다. self 로 접근하여 프로퍼티를 수정할 수 있고, 인스턴스 메서드를 호출할 수 있음.
2. 체인에 모든 convenience init 은 사용자가 원하는 대로 인스턴스에 값을 지정하고, self 로 작업할 수 있게 됨.

여기부터 내일!!

Override init

• Swift 는 기본적으로 상위 클래스의 init 을 안전하고 적절한 경우에만 상속하기 때문에, (부모 클래스의 간단한 init 이 하위 클래스의 모든 인자를 포함하지 않을 수 있으니까.)
• override init 으로 직접 상위 클래스의 designated init 을 오버라이딩할 수 있다.
• 상위 클래스의 convenience init 은 하위 클래스에서 호출될 수 없음. 같은 것을 하위클래스에서 구현하도라도 override를 쓸 필요가 없다.
• 상위 클래스의 자동으로 제공되는 init 을 사용할 때도 override 를 사용해야 함.
• 메서드, 서브스크립트와 동일하게 상위 클래스의 것을 확인.

class Vehicle {
    var numberOfWheels = 0 // stored property 에 대한 기본 init 제공
    var description: String {
        return "\(numberOfWheels) wheel(s)"
    }
}

class Bicycle: Vehicle {
    // Vehicle 의 기본 init 과 같기 때문에,
    // override 를 붙여야 한다.
    override init() {
        super.init() // 부모꺼 먼저 세팅하고,
        numberOfWheels = 2 // 자식껄 세팅해야 덮어쓰이지 않는다.
    }
}


class Hoverboard: Vehicle {
    var color: String
    
    // 초기화 구문에서, color 라는 이 클래스에 존재하는 property 만 초기화하고,
    // 상속 받은 numberOfWheels 는 Vehicle 것을 따라갈 것임.
    // 그렇다면, super.init() 은 자동으로 호출됨.
    init(color: String) {
        self.color = color
        // super.init() implicitly called here
    }
    override var description: String {
        return "\(super.description) in a beautiful \(color)"
    }
}

Automatic init 상속

• 하위 클래스는 기본적으로 상위 클래스의 init 을 상속하지 않지만,
• 특정 조건을 만족하면 상속한다.
  • 1. 하위 클래스가 designated init 을 정의하지 않은 경우
       상위 클래스에 지정된 모든 designated init 상속
  • 2. 하위 클래스가 상위(super) 클래스의 designated init 을 모두 구현한 경우 (== 규칙 1)
       자동으로 수퍼클래스의 convenience init을 추가합니다

상위 클래스의 designated init 을 override 하여 하위 클래스의 convenience init 으로 사용할 수 있다. (이렇게 구현해도 부모의 designated init 을 모두 구현한 것이므로 규칙 2를 만족)

Designated, Convenience init 의 동작

Food > RecipeIngredient > ShoppingListItem 으로 상속되는 클래스의 예시를 볼 것임.

class Food {
    var name: String
    
    // 클래스는 memberwise init 이 기본으로 제공되지 않으므로,
    // designated init 을 구현한다.
    // 부모 클래스가 없으므로, super.init() 은 구현할 필요가 없음.
    init(name: String) {
        self.name = name
    }
    // convenience init -> designated init
    convenience init() {
        self.init(name: "[Unnamed]")
    }
}

let meat = Food(name: "Bacon")
let mystery = Food()

// Food 를 상속.
class RecipeIngredient: Food {
    var quantity: Int
    
    // designated init
    init(name: String, quantity: Int) {
        // 안전 점검 1 충족.
        self.quantity = quantity // 자식에만 있는 것을 먼저 초기화하고
        super.init(name: name) // 부모 초기자 호출.
    }
    // convenience init. 
    // Food 의 designated init 과 같은 파라미터. == override
    override convenience init(name: String) {
        self.init(name: name, quantity: 1)
    }
}

// 부모의 convenience init (부모의 모든 designated init 구현해서 자동 상속)
let oneMysteryItem = RecipeIngredient() 

// 부모의 designated init 을 override 하여 convenience init 으로 구현함.
let oneBacon = RecipeIngredient(name: "Bacon") 

// 자식의 designated init
let sixEggs = RecipeIngredient(name: "Eggs", quantity: 6)

class ShoppingListItem: RecipeIngredient {
    var purchased = false // 초기화 구문 대신 초기값을 넣음.
    var description: String {
        var output = "\(quantity) x \(name)"
        output += purchased ? " ✔" : " ✘"
        return output
    }
    
    // 초기화 구문이 아예 없기 때문에,
    // 상위 클래스의 모든 designated init, convenience init 을 상속.
}

// 상속받은 3가지 init 을 모두 사용가능.
var breakfastList = [
    ShoppingListItem(),
    ShoppingListItem(name: "Bacon"),
    ShoppingListItem(name: "Eggs", quantity: 6),
]

breakfastList[0].name = "Orange juice"
breakfastList[0].purchased = true
for item in breakfastList {
    print(item.description)
}

// 1 x Orange juice ✔
// 1 x Bacon ✘
// 6 x Eggs ✘

6. Failable init ⭐️

• 실패할 수 있는 init init?
• 유효하지 않은 파라미터 값, 외부 리소스 부재, ... 에 의해 실패할 수 있다.
• 동일한 이름과 파라미터로 실패 가능, 실패 불가능 초기화를 작성할 순 없다.
• 이 구문이 실패하면 해당 인스턴스가 nil 이 된다.

struct Animal {
    let species: String
    init?(species: String) {
        // 초기화가 실패하는 순간에 return nil 을 하면 된다.
        // 진짜로 init 구문이 nil 을 반환하는 것은 아니고,
        // 이 구문이 실패하면 해당 인스턴스가 nil 이 된다.
        if species.isEmpty { return nil }
        self.species = species
    }
}

let anonymousCreature = Animal(species: "")
// anonymousCreature is of type Animal?, not Animal

if anonymousCreature == nil {
    print("The anonymous creature could not be initialized")
}
// Prints "The anonymous creature could not be initialized"

Failable init for Enum

enum 에서도 failable init 을 사용할 수 있다.

enum TemperatureUnit {
    case kelvin, celsius, fahrenheit
    init?(symbol: Character) {
        switch symbol {
        case "K":
            self = .kelvin
        case "C":
            self = .celsius
        case "F":
            self = .fahrenheit
        default:
            return nil
        }
    }
}

Failable init for Enum with Raw Values

• 원시값이 있는 enum 은 적절한 원시값 타입의 rawValue 라는 파라미터로,
• 일치하는 원시값의 케이스가 있으면 해당 케이스를 선택, 없으면 nil 이 되는 기본 failable init 을 가진다.

enum TemperatureUnit: Character {
    case kelvin = "K", celsius = "C", fahrenheit = "F"
}

let fahrenheitUnit = TemperatureUnit(rawValue: "F") // .kelvin
let unknownUnit = TemperatureUnit(rawValue: "X") // nil

Propagation of Initialization Failure

• 실패 가능한 초기화 역시 다른 실패 가능한 초기화에 위임 가능.
• 하위 클래스의 것도 상위 클래스로 위임 가능.
• 실패되면 초기화 프로세스 전체가 실패되고 더이상 초기화 코드가 실행되지 않는다.

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

// quantity 가 1 미만이거나 name 이 빈 것을 넣고 초기화하면 실패.

Overriding a Failable Initializer

• 실패 가능한 초기자도 하위 클래스에서 오버라이딩이 가능하다.
• 실패 가능한 초기자를 언래핑하여 실패 불가능한 초기자로 재정의 할 수 있음. 반대는 안됨.

class Document {
    var name: String?
    // this initializer creates a document with a nil name value
    init() {}
    // this initializer creates a document with a nonempty name value
    init?(name: String) {
        if name.isEmpty { return nil }
        self.name = name
    }
}

class UntitledDocument: Document {
    override init() {
        // "" 으로 호출되지 않을 것임이 보장됨 -> !
        super.init(name: "[Untitled]")!
    }
}

init!

• 암시적으로 언래핑된 Optional 인스턴스를 생성하는 failable init.
• init? <-> init! 서로서로 위임, 오버라이드가 가능하다.
• 하지만 init -> init! 에 위임하면 초기화가 실패한다.

7. Required init

• 모든 하위 클래스가 구현해야하는 초기화 구문.
• 하위 클래스에서 override 키워드 쓸 필요 없다.
• 상속된 초기화 구문으로 요구사항 충족이 가능하다면, 명시적으로 구현하지 않아도 된다.

class SomeClass {
    required init() {
        // initializer implementation goes here
    }
}

class SomeSubclass: SomeClass {
    required init() {
        // subclass implementation of the required initializer goes here
    }
}

8. 클로저를 사용해서 기본 프로퍼티 값 설정 ⭐️

• 기본 값을 설정할 때, 클로저나 전역 함수를 사용할 수 있다.
• 인스턴스가 초기화 될 때, 클로저/함수가 호출되고, 반환 값이 프로퍼티의 기본 값으로 할당된다.

class VC: UIViewController {
    let label: UILabel = {
        let l = UILabel()
        l.text= "text"
        l.textColor = .blue
        return l
    }()
}

요약

• struct, enum, class 의 초기화에서 중요한 것은
• 해당 타입이 가지고 있는 모든 stored property (상속된 것 포함) 에 초기값이 들어갔는가?

-> 그것을 사용자가 직접 하기 위해서 initializer를 제공하는데...

• desingated init / convenience init 으로 이루어져있고,
• 아래처럼 convenience init 은 같은 class 의 desingated init 으로 이어져야하고,
• designated init 은 상위 클래스의 desingated init 을 호출한다.

• 이 때, 안전하게 초기화를 하기 위해 2단계 초기화를 수행하게 되고,
  • 1. 모든 stored property 가 해당 프로퍼티를 가지고 있는 class에 의해 초기화 되고,
  • 2. 각 클래스에 저장된 property 를 custom

• 이 두 단계에서 안전성을 확보하기 위해 안정성 검사를 하게 된다.
  아래처럼만 작성해주면 문제 X!!
  

init() {
    // 상속되지 않은 모든 프로퍼티 초기화
    
    super.init() // 상속된 값 설정됨
    
    // 상속받은 모든 프로퍼티 초기화
}

convenience init() {
    self.init() // designated init
    
    // 초기화 하고 싶은 값 초기화.
}

질문

Convinience init에 대해 설명하시오.

• Convinience init 은 편리한 초기화로, 같은 클래스 내에 정의된 designated init 을 호출한 후, 초기화 하고 싶은 값을 초기화 하는 구문을 작성하여 구현한다.
  • 모든 초기화 구문을 여기서 쓰는 것이 아니라, 다른 init 을 빌려서 이용.
• Convinience init 은 같은 클래스 내 다른 Convinience init 이나 Designated init 을 호출하며, 궁극적으로는 꼭 Designated init 을 호출해야 한다.
• 만약, 클래스에 designated init 이 없거나, 상위 클래스의 designated init 을 모두 구현해서 암묵적으로 상위 클래스의 init 이 모두 상속되는 경우에, 상위 클래스의 designated init 을 하위 클래스의 convenience init 으로 override 할 수도 있다.

참고

https://bbiguduk.gitbook.io/swift/language-guide-1/initialization