[Swift] 공식 문서 정리 (14) - Initailization (생성자, 초기자, init이란?)

안녕하세요, 감자입니다. Swift 스터디를 진행하면서 4일간 공부했던.. 생성자 챕터를 업로드해볼게요. 정말 길고 길어서 지루했어요.. 근데도 완전한 이해는 아직 못했다는 것이 함정!! 빠르게 훑고 지나가는게 목표였어서 완전한 이해는 힘들었지만, 아 생성자는 이럴때 사용하는구나 이럴때 안되는구나! 이런 기본적인 개념을 다지는 시간이었어요. 앞으로 생성자에대해서 다시한번 정독하면서 궁금한 점에 대해서 포스팅하도록 해야겠어요. 

Swift Document chap.14 initialization 바로가기

Initialization — The Swift Programming Language (Swift 5.6)

 

---

 

Initialization (생성자)

Initialization(생성자)는 클래스, 구조체, 열거형에서 인스턴스를 준비하기 위한 과정이다. 이러한 과정은 인스턴스의 프로퍼티들마다 초기값을 설정해주고 새 인스턴스를 사용하기 전에 필요한 설정과 초기화를 수행하는 과정이 포함된다.

각각의 타입에서 새로운 인스턴스를 만들 수 있는 특수한 메서드와 같은 역할을 하는 생성자를 정의하여 사용할 수 있다. Swift에서의 생성자는 값을 반환하지 않는다. 생성자의 가장 중요한 역할은 새로운 인스턴스가 처음 사용되기 전에 올바르게 초기화 되는 것을 보장하는 것이다. 클래스 인스턴스는 인스턴스를 메모리에서 제거하는 deinitializer(소멸자)도 지원한다.

---

 

저장 프로퍼티를 위한 초기값 설정

인스턴스의 저장 프로퍼티는 사용하기 전에 반드시 특정 값으로 초기화 되어야 한다. 이 값으로 기본값을 설정할 수 있고, 특정 값을 설정할 수도 있다.

Initializer에서 저장 프로퍼티에 값을 직접 설정하면 프로퍼티 옵저버가 호출되지 않고 값 할당이 수행된다.

이니셜라이저 (Initializers)

이니셜라이저는 특정 타입의 인스턴스를 생성한다. 이니셜라이저의 가장 간단한 형태는 파라미터가 없고 init 키워드를 사용하는 것이다.

init() {
    // perform some initialization here
}

예제를 살펴보자. 화씨 온도 구조체를 만들어 온도라는 프로퍼티를 선언하고, 이니셜라이저에서 초기화하는 구문이다.

struct Fahrenheit {
    var temperature: Double
    init() {
        temperature = 32.0
    }
}
var f = Fahrenheit()
print("The default temperature is \\(f.temperature)° Fahrenheit")
// Prints "The default temperature is 32.0° Fahrenheit"

 

기본 프로퍼티 (Defalut Property Values)

프로퍼티 선언과 동시에 값을 할당하면 그 값을 초기 값으로 사용할 수 있다.

▷ note

항상 초기값을 갖는다면 기본 프로퍼티를 사용하는 것이 좋다. 프로퍼티에 타입을 선언하지 않아도 컴파일러는 초기 값을 참조해서 타입을 추론할 수 있다. 이 기본값은 상속시 함께 상속된다.

struct Fahrenheit {
    var temperature = 32.0
}

위 코드는 프로퍼티 선언과 동시에 초기값을 할당한 예제이다.

---

 

Customizing Initialization

생성자가 수행되는 것을 매개변수, 옵셔널 프로퍼티, 초기화 중 상수 프로퍼티를 지정하여 생성자를 원하는대로 정의할 수 있다.

 

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
    }
}
let boilingPointOfWater = Celsius(fromFahrenheit: 212.0)
// boilingPointOfWater.temperatureInCelsius is 100.0

let freezingPointOfWater = Celsius(fromKelvin: 273.15)
// freezingPointOfWater.temperatureInCelsius is 0.0

▷ 코드 설명

• Celsius 구조체에는 생성자가 두 개
• 두 개의 생성자는 서로 다른 생성자 매개변수를 가지고 있는데, 해당 생성자에 맞게 인스턴스를 생성하면 해당 생성자가 호출

 

Parameter Names and Argument Labels

함수와 메서드의 매개변수와 같이 생성자 내부에서 사용될 매개변수도 이름과 생성자를 호출할 때 사용될 Argument Label (인수 레이블) 을 가질 수 있다. 하지만 생성자는 이름이 없기 때문에 매개변수의 이름과 타입은 생성자를 구분하는데 중요한 역할을 한다. 이러한 이유로 Swift 생성자는 개발자가 따로 인수 레이블을 생성하지 않으면 자동적으로 모든 매개변수에 대해 인수 레이블을 제공한다.

 

다음 코드는 초기화 때 파라미터를 3개 입력받는 이니셜라이저와 하나만 입력받는 이니셜라이저의 예제이다.

struct Color {
    let red, green, blue: Double
    init(red: Double, green: Double, blue: Double) {
        self.red   = red
        self.green = green
        self.blue  = blue
    }
    init(white: Double) {
        red   = white
        green = white
        blue  = white
    }
}

let magenta = Color(red: 1.0, green: 0.0, blue: 1.0)
let halfGray = Color(white: 0.5)

let veryGreen = Color(0.0, 1.0, 0.0)
// ERROR!!!! - 인자이름 안써서 에러가 남
// this reports a compile-time error - argument labels are required

위에서 정의한대로 Color인스턴스를 인자값 3개 혹은 하나를 이용해 생성할 수 있다. 코드 마지막줄에서는, 인자이름을 작성하지 않아서 에러가 발생한다.

 

Initializer Parameters Without Argument Labels

코드를 작성할 때 인자 레이블을 생략하는 것이 더 명료한 경우 _ 기호를 사용해 이니셜라이저에서 인자 레이블을 생략할 수 있다. 마지막에 상수를 선언하는 라인을 보면 인자레이블 없이 인스턴스를 초기화 한 것을 볼 수 있다.

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 bodyTemperature = Celsius(37.0)
// bodyTemperature.temperatureInCelsius is 37.0

 

옵셔널 프로퍼티 타입

프로퍼티 최초 값이 없고 나중에 추가될 수 있는 값을 옵셔널로 선언해 사용할 수 있다. 옵셔널 프로퍼티는 자동으로 nil로 초기화 된다.

class SurveyQuestion {
    var text: String
    **var response: String?**
    init(text: String) {
        self.text = text
    }
    func ask() {
        print(text)
    }
}
let cheeseQuestion = SurveyQuestion(text: "Do you like cheese?")
cheeseQuestion.ask()
// Prints "Do you like cheese?"
cheeseQuestion.response = "Yes, I do like cheese."

 

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

이니셜라이저에서는 상수 프로퍼티에 값을 할당하는 것도 가능하다. (👉🏻클래스 인스턴스에서 상수 프로퍼티는 초기화 중 그 클래스 안에서만 변경이 가능하고 서브클래스에서는 변경이 불가능하다)

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으로 선언해서 이 프로퍼티는 처음에 초기화 되면 변경되지 않는 프로퍼티라는 것을 표현할 수 있다.

let으로 선언되었기 때문에 변경이 불가능하다는 에러가 발생한다.

---

 

Default Initializers (기본 이니셜라이저)

만약 모든 프로퍼티의 초기값이 설정돼 있고, 하나의 초기자도 정의하지 않았다면, Swift는 모든 프로퍼티를 기본 값으로 초기화하는 기본 생성자를 제공한다.

아래 코드는 이니셜라이저를 정의하지 않았다면 Swift가 제공하는 기본 이니셜라이저 ShoppingListItem()를 사용할 수 있음을 보여주는 예제이다.

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

 

구조체 타입의 멤버 별 생성자 (memberwise initializer)

구조체는 생성자를 정의하지 않으면 memberwise initializer(멤버 별 생성자)를 자동으로 받는다. Default 생성자와는 다르게 저장 프로퍼티에 default 값이 없을 때, memberwise initializer 를 받게된다. memberwise initializer는 새로운 구조체 인스턴스의 프로퍼티를 초기화 하는 간단한 방법이다. 새로운 인스턴스의 프로퍼티에 대한 초기 값은, 이름으로 memberwise intitializer에 전달한다.

struct Size {
    var width = 0.0, height = 0.0
}
let twoByTwo = Size(width: 2.0, height: 2.0)

---

 

값 타입을 위한 Initializer Delegation

생성자는 다른 생성자를 호출하여 인스턴스 초기화의 일부를 수행할 수 있다. Initializer Delegation (생성자 위임)이라고 하는 이러한 과정은 생성자에서 코드가 중복되는 것을 방지한다.

값타입인지 참조타입인지에 따라서 Initialzier Delegation 의 작동 방법이 달라진다. 값타입 즉 구조체나 열거형에서는 상속을 지원하지 않는다. 따라서 이들의 Initializer delegation은 자신이 제공하는 생성자에게만 위임할 수 있기 때문에 구조가 간단하다. 하지만 클래스는 상속할 수 있기 때문에 상속하는 모든 저장 프로퍼티가 초기화 중에 적절한 값이 할당되도록 해야한다.

값 타입에서는 self.init으로 새로운 생성자를 정의할 때 다른 생성자를 참조할 수 있다. self.init은 생성자를 작성할 때만 호출할 수 있다. 값타입, 즉 구조체나 열거형에서 사용자 정의 생성자를 정의하면 default생성자를 더이상 접근할 수 없다. 이러한 제약은 생성자를 만들어뒀지만 누군가가 사용할 때 이를 사용하지 않고 기본적으로 제공되는 생성자를 사용하여 발생하게 되는 오류를 방지할 수 있다. 이러한 제약이 싫고 default 생성자도 사용하고 사용자 정의 생성자도 사용하고 싶다면 사용자 정의 생성자를 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)
        self.init(origin: Point(x: originX, y: originY), size: size)
    }
}

위 코드에서 Rect 구조체에는 세 개의 사용자 정의 생성자가 존재한다. 그리고 두 개의 프로퍼티인 orgin, size 는 다른 구조체 인스턴스 타입인데 이 프로퍼티를 초기화 하는 생성자의 매개변수에 해당하는 Size, Point 구조체는 모두 default 값이 있기 때문에 다음과 같이 세 가지 방법으로 Rect 구조체의 인스턴스를 생성할 수 있다.

 

let basicRect = Rect()
// basicRect's origin is (0.0, 0.0) and its size is (0.0, 0.0)

let originRect = Rect(origin: Point(x: 2.0, y: 2.0),
                      size: Size(width: 5.0, height: 5.0))
// originRect's origin is (2.0, 2.0) and its size is (5.0, 5.0)

첫번째의 Rect() 경우, init() 생성자를 사용한 경우이다. default 생성자를 사용하는 경우와 기능적으로 동일하다.

두번째 Rect(origin: Point: (x, y), size: Size(width, height))의 경우 init(origin: size:) 생성자를 사용한 경우이고, Rect(center: Point(x, y), size: Size(width, height))는 init(center: size) 생성자를 사용한 경우이다.

---

 

클래스 상속과 생성자

모든 클래스의 저장 프로퍼티와 superclass로부터 상속받은 모든 프로퍼티는 초기화 단계에서 반드시 초기값이 할당되어야 한다. Swift에서는 클래스 타입에서 모든 프로퍼티가 초기 값을 갖는 것을 보장하기 위해 2가지 방법을 지원한다.

 

지정 생성자와 편의 생성자 (Designated Initializers and Convenience Initializers)

Designated Initializers(지정 생성자)는 클래스의 기본적인 생성자이다. 지정 생성자는 클래스의 모든 프로퍼티를 초기화하고 적절한 슈퍼 클래스의 생성자도 호출하여 슈퍼 클래스의 프로퍼티들도 초기화한다. 클래스에는 하나의 지정 생성자가 있는 것이 일반적이다. 지정 생성자가 호출되는 지점은 "funnel"지점으로 초기화 프로세스가 슈퍼 클래스 체인을 계속하는 지점이다.

모든 클래스는 적어도 하나의 지정 생성자가 있어야한다. 이러한 요구 사항은 곧 나올 Automatic Initializer Inheritance에 설명된 대로 슈퍼 클래스에서 하나 이상의 지정 생성자를 상속하여 충족된다.

Convenience Initializers(편의 생성자)는 클래스의 생성자를 보조하는 역할을 한다. 클래스의 특수한 인스턴스를 만들 때 사용하기 위해 편의 초기화를 정의할 수도 있다. 만약 이러한 편의 생성자가 필요하지 않을 경우 굳이 제공할 필요는 없다.

 

지정 생성자와 편의 생성자의 문법

클래스의 지정 생성자의 문법은 값 타입 생성자와 같다.

init(parameters) {
    statements
}

편의생성자는 기본 생성자와 문법이 같지만 init앞에 convenience 키워드를 붙인다.

convenience init(parameters) {
    statements
}

 

클래스 타입을 위한 생성자 위임 (Initializer Delegation)

지정 생성자와 편의 생성자의 관계를 간단하게 하기 위해 Swift는 생성자의 delegation에 다음 세 가지 규칙을 적용한다.

• RULE 1) 지정 생성자는 호출 즉시 슈퍼 클래스의 지정 생성자를 호출한다.
• RULE 2) 편의 생성자는 같은 클래스 내의 다른 생성자를 호출해야 한다.
• RULE 3) 편의 생성자는 지정 생성자를 호출해야만 한다.

즉, designated initializer는 항상 delegate UP 해야하고, Convenience initializer는 항상 delegate across 해야한다.

위 그림에서 슈퍼클래스는 하나의 지정 생성자와 두 개의 편의 생성자를 가지고 있다. 하나의 편의 생성자는 다른 편의 생성자를 호출하고, 다시 하나의 지정 생정자를 호출한다. 이는 위의 규칙 2, 3을 만족한다. 슈퍼클래스 자체에는 추가 슈퍼 클래스가 없기 때문에 규칙 1은 적용되지 않는다.

위의 그림에서 서브클래스는 두 개의 지정 생성자와 하나의 편의 생성자가 있다. 편의 생성자는 동일한 클래스 생성자만 호출 할 수 있기 때문에, 지정 생성자만 호출 가능하다. 남은 지정 생성자들은 규칙 1에 의해 슈퍼클래스의 지정 생성자를 호출해야 하기 때문에 그렇게 호출하고 있음을 볼 수 있다. 이렇게 규칙 1,2,3 을 모두 준수하고 있다.

이러한 규칙은 클래스를 사용할 때 클래스의 인스턴스를 만드는 방법에는 영향을 끼치지 않는다. 오로지 클래스의 생성자 구현을 작성하는 방법에만 영향을 주는 규칙들이다.

다음은 좀 더 복잡한 생성자 위임의 형태이다.

• 위 그림에서는 모든 서브클래스의 designated initializer가 모두 슈퍼클래스의 designated initalizer 를 호출하고 있음을 볼 수 있다. (delegate UP)
• 또 모든 Convenience initializer는 다른 initializer를 호출하고 있음을 볼 수 있다. (delegate Across)

 

Two-Phase Initialization (2단계 생성자)

Swift에서 클래스 초기화는 2단계에 거쳐 진행된다. 첫번째 단계에서는 저장 프로퍼티에 클래스에 의한 초기값이 할당된다. 모든 저장 프로퍼티에 초기 값이 결정되면 두 번째 단계가 시작되는데, 이 단계에서는 새로운 인스턴스가 생성되기 전에 저장 프로퍼티의 값을 바꿀 수 있는 기회가 주어진다. 이러한 두 단계에 걸친 프로세스를 사용하면 클래스 계층 구조의 각 클래스는 완전한 유연성을 갖게 된다. 이러한 단계는 프로퍼티에 값이 할당되기 전에는 프로퍼티 값에 접근하지 못하게 하고 다른 생성자가 프로퍼티 값을 다른 값으로 설정하지 못하게 한다.

Swift 컴파일러는 네 가지의 안전 점검을 수행하여 2단계 초기화가 완료되었는지 확인한다.

• 안전점검 1) Designated 생성자는 슈퍼 클래스의 생성자가 실행되기 전에 해당 클래스의 모든 프로퍼티에 값을 할당해야 한다. 객체의 메모리는 모든 프로퍼티에 값이 있을 때만 완전히 초기화 된 것으로 간주한다. 이러한 규칙을 만족하려면 수퍼 클래스의 생성자가 실행되기 전에 현재 생성 중인 클래스의 모든 프로퍼티에 값을 할당해야한다.
• 안전 점검 2) Designated 생성자는 상속된 프로퍼티에 값을 할당하고 싶다면 슈퍼 클래스의 생성자를 실행한 뒤에 값을 할당해야한다. 그렇지 않으면 수퍼 클래스의 생성자에 의해 값이 덮어씌워진다.
• 안전 점검 3) Convenience 생성자는 프로퍼티에 값을 할당하기 전에 다른 생성자를 실행해야 한다. 그렇지 않으면 자체 클래스의 생성자에 의해 값이 덮어씌워진다.
• 안전 점검 4) 생성자는 초기화의 첫 번째 단계가 완료될 때까지 인스턴스 메서드, 인스턴스 프로퍼티, self를 사용할 수 없다.

클래스의 인스턴스는 첫 번째 단계가 끝날 때까지는 유효한 개체가 아니다. 즉 첫 번째 단계를 완료해야지 프로퍼티에 접근하거나 메서드를 호출할 수 있다. 위의 네 가지 안전 점검에 의해 2 단계 초기화가 수행되는 방식은 다음과 같다.

• 1 단계
  • 클래스에서 Designated, convenience 생성자를 호출한다.
  • 클래스의 새 인스턴스에 메모리가 할당된다. 하지만 아직 메모리가 초기화된 것은 아니다.
  • Designated 생성자는 해당 클래스에 대한 모든 프로퍼티에 값이 있음을 확인한다. 이젠 저장 프로퍼티에 메모리가 초기화되었다.
  • 슈퍼 클래스의 생성자를 실행한다.
  • 최상위 클래스에 도달할 때 까지 계속한다.
  • 최상위 클래스에 도달한 뒤 최상위 클래스의 모든 프로퍼티에 값이 있는지 확인하면 인스턴스의 메모리가 완전히 초기화된 것으로 보고 1단계를 종료한다.
• 2단계
  • 최상위 클래스에서 다시 내려가면서 클래스에 정의된 designated 생성자는 인스턴스의 값을 다시 지정할 수 있는 옵션이 있다. 이러한 생성자는 이제 자신의 프로퍼티에 접근이 가능하며 인스턴스 메서드도 호출할 수 있다. 또한 클래스들의 conveniecne 생성자는 인스턴스를 커스터마이징하고 자체적으로 작업을 수행할 수 있다.

위 그림은 1단계에서 서브클래스 및 슈퍼클래스의 생성자를 찾는 방법이다.

초기화는 서브클래스의 convenience 생성자의 호출에서 시작된다. 아직 convenience 생성자는 프로퍼티를 수정할 수 없으므로 동일한 클래스의 designated 생성자를 실행시킨다. Designated 생성자는 안전점검 1 에 따라 서브클래스의 프로퍼티에 값이 있는지 확인한 뒤 슈퍼클래스의 designated 생성자를 호출한다. 슈퍼클래스의 designated 생성자는 슈퍼클래스의 프로퍼티에 값이 있는지 확인하고 더 이상의 슈퍼클래스가 없기 때문에 메모리는 완전히 초기화 된 것으로 간주되고 1단계가 종료된다.

위 그림은 초기화의 2단계 이다.

이제 슈퍼클래스의 designated 생성자는 인스턴스를 커스터마이징 할 수 있다. 슈퍼클래스의 designated 생성자가 완료되면 서브클래스의 designated 생성자가 커스터마이징을 수행하고 그 후엔 convenience 생성자가 추가적인 커스터마이징을 수행할 수 있게 된다.

 

이니셜라이저의 상속과 오버라이딩

Swift 서브클래스는 기본적으로 슈퍼클래스의 생성자를 상속하지 않는다. 이유는 슈퍼클래스의 이니셜라이저가 무분별하게 상속되어 복잡하게 돼 서브클래스에서 이것들이 잘못 초기화 되는 것을 막기 위함이다. 슈퍼클래스의 이니셜라이저는 안전하고 적당한 특정 환경에서 상속된다.

만약 클래스에서 모든 프로퍼티의 초기 값이 지정돼 있고, 아무런 커스텀 생성자를 선언하지 않는다면, 기본 생성자 init()을 사용할 수 있다.

슈퍼클래스의 생성자를 오버라이드 하기 위해서는 서브클래스에서 그 생성자에 override 키워드를 붙이고 재정의한다.

다음 예제는 클래스를 생성하고 그것의 서브클래스에서 생성자를 오버라이드 해 사용한 예제이다.

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

let vehicle = Vehicle()
print("Vehicle: \\(vehicle.description)")
// Vehicle: 0 wheel(s)

위 코드는 Vehicle클래스를 정의하고 numberOfWheels 라는 저장 프로퍼티를 선언했다. 이는 description 이라는 계산 프로퍼티에서 문자열을 만드는데 사용된다. 여기서 Vehicle클래스는 저장 프로퍼티에 default 값을 할당했고, 따로 생성자를 생성하지 않았다. 결과적으로 이는 default 생성자를 사용하게 되어 이러한 default 생성자는 클래스에서 항상 designated 생성자이다.

class Bicycle: Vehicle {
    override init() {
        super.init()
        numberOfWheels = 2
    }
}

let bicycle = Bicycle()
print("Bicycle: \\(bicycle.description)")
// Bicycle: 2 wheel(s)

이번에는 Vehicle 클래스를 상속받는 Bicycle 클래스를 정의했다. Bicycle 클래스에는 designated 생성자인 init()을 정의해주었다. 이 생성자는 슈퍼클래스인 Vehicle에도 있으므로 override 키워드를 앞에 써서 서브클래스에서 오버라이드 했다는 것을 꼭 명시해야 한다.

그럼 이제 Bicycle의 init()을 살펴보자. 이 생성자는 super.init(), 즉 Vehicle의 생성자를 호출하고 있다. Vehicle의 생성자는 numberOfWheels 프로퍼티의 값을 0으로 초기화하는 생성자였지만, Bicycle 클래스의 init()에서 다시 이를 2로 바꾸어 주게 된다. 만약 이러한 동작에서 서브클래스의 생성자가 초기화 프로세스의 2단계에서 커스텀 생성자가 없고, 슈퍼 클래스의 designated 생성자에 매개변수가 없을 땐 서브 클래스의 저장 프로퍼티에 값을 할당한 후에 super.init()호출을 생략할 수도 있다.

class Hoverboard: Vehicle {
    var color: String
    init(color: String) {
        self.color = color
        // super.init() implicitly called here
    }
    override var description: String {
        return "\\(super.description) in a beautiful \\(color)"
    }
}

let hoverboard = Hoverboard(color: "silver")
print("Hoverboard: \\(hoverboard.description)")
// Hoverboard: 0 wheel(s) in a beautiful silver

위 코드는 Hoverboard라는 새로운 Vehicle의 서브클래스를 정의한 것이다. Hoverboard 클래스의 생성자는 color 프로퍼티만 초기화한다. 이 생성자는 super.init()을 암시적으로 호출하여 초기화 프로세스를 완료한다. 하나 덧 붙이자면 서브 클래스는 상속된 변수 프로퍼티의 값은 수정할 수 있지만 상속된 상수 프로퍼티의 값은 수정할 수 없다.

 

자동 생성자 인스턴스

위에서 언급했듯이, 서브클래스는 기본적으로 슈퍼클래스의 생성자를 상속하지 않는다. 하지만 특정 조건에서는 슈퍼클래스의 생성자가 자동으로 상속된다. 이러한 기능은 특정 조건에서 슈퍼 클래스의 생성자를 상속할 수 있다는 것을 의미한다.

서브클래스에 정의한 새로운 프로퍼티에 default 값을 제공한다고 가정하면 다음 두 가지의 규칙이 적용된다.

• Rule 1
  • 서브 클래스가 designated 생성자를 정의하지 않으면 자동적으로 슈퍼 클래스의 designated 생성자를 모두 상속받는다.
• Rule 2
  • 서브 클래스가 Rule 1에 따라 상속하거나 슈퍼 클래스의 모든 designated 생성자를 오버라이드 해서 구현하면 슈퍼 클래스의 convenience 생성자도 자동으로 상속받는다. 이러한 규칙은 서브 클래스에 convenience 생성자를 추가하는 경우에도 적용된다.

 

지정 생성자(Designated)와 편의 생성자의(convenience) 사용

그럼 designated 생성자, Convenience 생성자, Automatic 생성자의 상속이 동작하는 모습을 살펴보자.

class Food {
    var name: String
    init(name: String) {
        self.name = name
    }
    convenience init() {
        self.init(name: "[Unnamed]")
    }
}

편의초기자 convenience.init() 에서 지정초기자 init(name: String)이 호출되는 형태이다.

우선 슈퍼클래스 Food 라는 클래스를 정의했다. 이는 식품의 흐름을 캡슐화하는 클래스이고, 2개의 생성자가 존재한다.

위 그림은 Food 클래스의 생성자의 관계를 나타낸 것이다. Food 클래스에는 default memberwise 생성자가 없기 때문에 designated 생성자인 init(name: )를 제공한다.

let namedMeat = Food(name: "Bacon")
// namedMeat's name is "Bacon"

let mysteryMeat = Food()
// mysteryMeat's name is "[Unnamed]"

init(name: )생성자를 사용해서 Food 클래스의 새로운 인스턴스를 생성할 수 있다. Food에는 인수 없이 사용가능한 생성자인 init() 도 정의되어 있고, 이를 통해서도 새로운 인스턴스를 만들 수 있다.

그럼 이제 Food 의 서브클래스를 정의해보자.

class RecipeIngredient: Food {
    var quantity: Int
    init(name: String, quantity: Int) {
        self.quantity = quantity
        super.init(name: name)
    }
    override convenience init(name: String) {
        self.init(name: name, quantity: 1)
    }
}

let oneMysteryItem = RecipeIngredient()
let oneBacon = RecipeIngredient(name: "Bacon")
let sixEggs = RecipeIngredient(name: "Eggs", quantity: 6)

RecipeIngredient 클래스라는 서브클래스를 만들었다. 이는 quantity라는 저장프로퍼티가 새로 정의되어있고, 생성자도 2개가 존재한다.

위의 그림은 RecipeIngredient 클래스의 생성자들의 관계를 나타낸 그림이다. RecipeIngredient 클래스에는 init(name: quantity:)라는 designated 생성자가 있고 이 생성자에 의해 새로 정의된 프로퍼티에 값을 할당한다.

그리고 super.init(name:)을 호출하게 되며 2단계 초기화의 안전점검 1을 만족하게 된다. RecipeIngredient 클래스는 convenience 생성자인 init(name:String)로 정의되어있는데 이를 통해 인스턴스를 더 쉽게 만들 수 있게 된다. 하지만 이 생성자는 슈퍼 클래스인 Food에서도 동일한 매개변수를 갖는 생성자가 정의되어 있기 때문에 override를 앞에 써줘야 한다.

RecipeIngredient는 convenience 생성자로 init(name:)을 제공하지만 슈퍼클래스의 designated 생성자를 모두 제공했으므로 Food 클래스의 convenience 생성자도 모두 상속받게 된다. 즉 Food의 init() 생성자를 상속받게 되는 것이다.

class ShoppingListItem: RecipeIngredient {
    var purchased = false
    var description: String {
        var output = "\\(quantity) x \\(name)"
        output += purchased ? " ✔" : " ✘"
        return output
    }
}

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 ✘

이번엔 RecipeIngredient 클래스를 상속받는 ShoppingListItem 클래스를 정의해보았다. 이 클래스에는 저장 프로퍼티 purchased와 계산 프로퍼티인 description이 정의되어있다. 모든 프로퍼티에 값이 할당되어 있기 때문에 따로 생성자를 정의하지 않아도 문제가 없는 것을 알 수 있다. ShoppingListItem 클래스는 모든 프로퍼티에 값을 제공하고 생성자 자체를 정의하지 않았기 때문에 슈퍼클래스에서 정의된 모든 생성자를 상속받는다. 따라서 위의 코드처럼 ShoppingListItem의 인스턴스들을 만들 수 있다.

위 그림은 지금까지 정의 세 클래스의 생성자 관계를 보여준다.

---

 

Failable Initializers (실패 가능한 생성자)

초기화 과정 중에 실패할 가능성이 있는 생성자를 init 뒤에 물음표(?) 를 사용해 실패 가능한 생성자라고 표현할 수 있다.

생성자는 이름이 따로 있는 것이 아니라 파라미터로 구분하기 때문에 실패가능한 생성자와 실패 불가능한 생성자를 같은 파라미터 타입과 이름으로 동시에 사용할 수 없다. 실패 가능한 생성자는 반환값으로 옵셔널 값을 생성한다. 초기화에 실패하는 부분에서 nil을 반환하는 코드를 작성해 초기화가 실패했다는 것을 나타낼 수 있다.

엄연히 말하면 생성자 init은 값을 반환하지 않는다. 그래서 비록 nil을 반환하는 return nil 코드에는 사용하지만 init이 사용하는 경우 return 키워드를 사용하지 않는다.

다음 코드는 숫자형을 위해 정의돼 있는 실패 가능한 생성자 Int(exactly: )를 사용한 예제이다.

let wholeNumber: Double = 12345.0
let pi = 3.14159

if let valueMaintained = Int(exactly: wholeNumber) {
    print("\\(wholeNumber) conversion to Int maintains value of \\(valueMaintained)")
}
// Prints "12345.0 conversion to Int maintains value of 12345"

let valueChanged = Int(exactly: pi)
// valueChanged is of type Int?, not Int

if valueChanged == nil {
    print("\\(pi) conversion to Int does not maintain value")
}
// Prints "3.14159 conversion to Int does not maintain value"

위 코드와 같이 숫자 타입 간 변환에서 값을 정확하게 유지하려면 init(exactly: ) 생성자를 사용하면 된다. 만약 변환 후 값을 유지할 수 없다면, 생성자가 실패하게 된다. 즉 위으 코드에서 12345.0을 Int로 변환해도 값이 유지되기 때문에 이땐 값이 유지되기 때문에 이땐 값이 잘 초기화 되지만, 3.14159를 Int 로 변환하면 3인데 이는 값이 유지되지 않으므로 초기화에 실패하게 된다.

struct Animal {
    let species: String
    init?(species: String) {
        if species.isEmpty { return nil }
        self.species = species
    }
}

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

if let giraffe = someCreature {
    print("An animal was initialized with a species of \\(giraffe.species)")
}
// Prints "An animal was initialized with a species of Giraffe"

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

if anonymousCreature == nil {
    print("The anonymous creature couldn't be initialized")
}
// Prints "The anonymous creature couldn't be initialized"

위 코드에서는 Animal 구조체를 정의하고 init? 이라는 실패가능한 생성자를 정의했다.이 생성자는 만약 빈 문자열이 매개변수로 들어오면 초기화를 실패하게 되도록 정의되어 있다. 실제로 인스턴스를 만들어보면 빈 문자열을 생성자의 매개변수로 입력하게 되면 초기화에 실패하게 된다.

 

열거형에서 사용하는 Failable 생성자

열거형에서도 실패가능한 생성자를 사용할 수 있다. 예제를 보자.

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

let fahrenheitUnit = TemperatureUnit(symbol: "F")
if fahrenheitUnit != nil {
    print("This is a defined temperature unit, so initialization succeeded.")
}
// Prints "This is a defined temperature unit, so initialization succeeded."

let unknownUnit = TemperatureUnit(symbol: "X")
if unknownUnit == nil {
    print("This is not a defined temperature unit, so initialization failed.")
}
// Prints "This is not a defined temperature unit, so initialization failed."

위 코드에서는 초기화 시 지정된 특정 온도 표시 단위가 아닌 경우 초기화 결과로 nil을 반환한다. Temperatureunit(symbol: “F”) 에서 F는 TempertureUnit 열거형에서 사전에 정의되어 있는 단위여서 초기화가 정상적으로 동작한다.

하지만 TemperatureUnit(symbol: "X")에서 X는 정의되지 않은 단위여서 초기화에 실패하게 되는 것을 볼 수 있다.

 

Raw 값을 사용하는 열거형에서의 Failable 생성자

열거형의 각 케이스에 지정돼 있는 Raw 값을 생성자 인자로 넣어 초기화에 사용할 수 있다.

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

let fahrenheitUnit = TemperatureUnit(rawValue: "F")
if fahrenheitUnit != nil {
    print("This is a defined temperature unit, so initialization succeeded.")
}
// Prints "This is a defined temperature unit, so initialization succeeded."

let unknownUnit = TemperatureUnit(rawValue: "X")
if unknownUnit == nil {
    print("This is not a defined temperature unit, so initialization failed.")
}
// Prints "This is not a defined temperature unit, so initialization failed."

동작은 앞서 TempertureUnit 과 같다. 하지만 TempertureUnit에서의 생성자 구현이 훨씬 간단해졌다.

위의 코드는 원시 값을 갖는 TemperatureUnit 열거형을 정의한 것이다. 따로 생성자를 정의하지 않았지만 자동적으로 init?(rawValue:)가 생성되어 사용할 수 있는 것을 볼 수 있다.

 

생성자 실패 전달(위임)

클래스, 구조체, 열거형의 실패가능한 생성자는 같은 클래스, 구조체, 열거형의 실패가능한 생성자에 위임할 수 있다. 비슷하게 서브클래스와 실패가능한 생성자는 슈퍼클래스의 실패가능한 생성자를 위임할 수 있다. 이러한 경우에 생성자가 실패하게 되면 전체 생성자 프로세스가 실패하고 더 이상 코드가 실행되지 않는다.

실패가능한 생성자는 실패할 수 없는 생성자를 위임할 수 있다. 이런 경우에는 다음과 같은 방법을 사용하면 된다.

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

위 코드는 Product 클래스와 이를 상속받는 CartItem 클래스를 정의한 코드이다. 두 클래스에는 모두 실패가능한 생성자가 정의되어있다. CartItem클래스의 생성자는 매개변수로 받는 quantity의 값이 1보다 작으면 초기화에 실패하게 된어 더 이상 코드가 실행되지 않는다. 마찬가지로 Product 클래스의 생성자도 name에 빈 문자열이 입력된다면 모든 초기화 프로세스가 실패하게 된다.

if let twoSocks = CartItem(name: "sock", quantity: 2) {
    print("Item: \\(twoSocks.name), quantity: \\(twoSocks.quantity)")
}
// Prints "Item: sock, quantity: 2"

위 코드는 name도 있고 , quantity도 1이상이므로 인스턴스 생성에 성공한다.

if let zeroShirts = CartItem(name: "shirt", quantity: 0) {
    print("Item: \\(zeroShirts.name), quantity: \\(zeroShirts.quantity)")
} else {
    print("Unable to initialize zero shirts")
}
// Prints "Unable to initialize zero shirts"

위 코드는 인스턴스 생성시 quantity가 0이므로 인스턴스 초기화에 실패한다.

if let oneUnnamed = CartItem(name: "", quantity: 1) {
    print("Item: \\(oneUnnamed.name), quantity: \\(oneUnnamed.quantity)")
} else {
    print("Unable to initialize one unnamed product")
}
// Prints "Unable to initialize one unnamed product"

위 코드는 quantity는 1 이상이지만, name이 비어있기 때문에 초기화에 실패한다.

 

Failable 생성자의 오버라이딩

슈퍼클래스의 실패가능한 생성자를 서브클래스에서 실패불가능한 생성자로 오버라이딩 할 수 있다. 이 방법을 이용해 실패불가능한 생성자를 생성 가능하다.

실패가능한 생성자를 실패불가능한 생성자에서 오버라이드 할 수 있지만, 그 반대는 불가능 하다.

아래 Document 클래스는 초기화를 할 때, name 값으로 특정 String을 지정하거나 nil을 지정할 수 있다. 하지만 name이 비어있는 경우에는 초기화 실패를 나타내는 nil을 반환한다.

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

Document를 서브클래싱한 AutomaticNamedDocument 클래스에서는 기본 생성자와 지정 생성자를 오버라이딩해서 실패가능한 생성자를 실패불가능한 생성자로 만들었다. 초기값이 없는 경우에는 name에 기본값으로 **[Untitled]**를 넣도록 했다.

class AutomaticallyNamedDocument: Document {
    override init() {
        super.init()
        self.name = "[Untitled]"
    }
    override init(name: String) {
        super.init()
        if name.isEmpty {
            self.name = "[Untitled]"
        } else {
            self.name = name
        }
    }
}

Document를 서브클래싱한 또 다른 클래스 UntitledDocument 에서는 기본 생성자를 오버라이딩 해서 생성자를 구현했고, 그 값이 옵셔널 값을 갖지 않도록 느낌표(!)를 사용하여 강제 언래핑 해주었다. super.init(name: “[Untitled]”)!

class UntitledDocument: Document {
    override init() {
        super.init(name: "[Untitled]")!
    }
}

 

Failable init! 생성자

실패가능한 생성자를 init? 키워드로 만들지만, 옵셔널 타입이 아닌 인스턴스를 만드는 실패가능한 생성자를 만들고 싶다면 init! 을 사용하면 된다. init!생성자를 위임할 때는 init! 생성자로 인해 실패할 수 있기 때문에 주의해야한다.

---

 

필수 생성자 (Required Initializers)

모든 서브클래스에서 반드시 구현해야 하는 생성자는 아래 예제와 같이 required 키워드를 붙여준다.

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

필수 생성자는 상속받은 서브클래스에서도 반드시 required 키워드를 붙여서 다른 서브클래스에게도 필수 생성자임을 명확하게 알려야한다.

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

---

 

클로저나 함수를 사용하여 기본 프로퍼티 값 설정하기

기본 값 설정이 단순히 값을 할당하는 것이 아니라 다소 복잡한 계산을 필요하다면 클로저나 함수를 이용해 값을 초기화 하는데 이용할 수 있다. 기본값을 지정하기 위해 클로저를 사용하는 형태의 코드는 보통 다음과 같다.

class SomeClass {
    let someProperty: SomeType = {
        // create a default value for someProperty inside this closure
        // someValue must be of the same type as SomeType
        return someValue
    }()
}

someProperty는 클로저가 실행된 이후 반환 타입이 SomeType인 SomeValue를 기본값으로 갖게 된다.

클로저를 초기자에서 사용하면 클로저 안에 self나 다른 프로퍼티를 사용할 수 없다. 그 이유는 클로저가 실행될 시점에 다른 프로퍼티는 초기화가 다 끝난 것이 아니기 때문이다.

struct Chessboard {
    let boardColors: [Bool] = {
        var temporaryBoard = [Bool]()
        var isBlack = false
        for i in 1...8 {
            for j in 1...8 {
                temporaryBoard.append(isBlack)
                isBlack = !isBlack
            }
            isBlack = !isBlack
        }
        return temporaryBoard
    }()
    func squareIsBlackAt(row: Int, column: Int) -> Bool {
        return boardColors[(row * 8) + column]
    }
}

Chessboard에서 boardColors 클로저를 이용해 8x8 보드 색을 갖는 Bool 배열로 초기화 된다. 보드이 특정 행-열이 어떤 색인지 확인하는 함수 squarelsBlackAt(row: Int, column: Int)가 제공된다.

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

Chessboard() 수행으로 8x8 보드 인스턴스가 생성되었다. 생성된 보드에서 특정 행-열이 어떤 색인지 알아보기 위해 squareIsBlackAt(row: Int, column: Int) 함수를 호출했다.