17. Initializer and Deinitializer

Initializer and Deinitializer

인스턴스의 생성과 해제를 담당하는 코드를 구현하는 방법에 대해 공부

Initializers

생성자와 인스턴스 초기화에 대해 공부

Default Initializer

생성자
새로운 인스턴스를 생성하는 생성자

// 선언과 동시에 기본 값 저장
class Position {
    var x = 0.0
    var y = 0.0
    var z: Double? = nil          // 옵셔널은 기본값을 저장하지 않으면 자동으로 nil
    
//    init() {        // 초기화
//        y = 0.0
//    }
}

let p = Position()

Initializer Syntax

init(parameters) {
	initialization
}

---

TypeName(parameters)

class SizeObj {
    var width = 0.0
    var height = 0.0
    
    init(width: Double, height: Double) {
        self.width = width
        self.height = height
        
    }
    
    // convenience 이니셜라이져
    convenience init(value: Double) {
//        width = value
//        height = value
        self.init(width: value, height: value)
    }
}

Memberwise Initializer

struct SizeValue {
    var width = 0.0
    var height = 0.0
    
}

let s = SizeValue()
SizeValue(width: 1.2, height: 3.4)

Memberwise Initializer

구조체가 제공하는 Memberwise Initializer에 대해 공부

struct First {
    let a: Int
    let b: Int
    let c: Int
}

let f = First(a: 1, b: 2, c: 3)     // 어떤 값이 초기화하는지 알 수 있음

struct Second {
    let a: Int = 0
    let b: Int = 1
    let c: Int
}

let s = Second(c: 2)

struct Third {
    var a: Int = 0
    var b: Int = 1
    var c: Int

//    init(value: Int) {
//        a = value
//        b = value
//        c = value
//    }
}

extension Third {       // extension 아직은 이해 안감
    init(value: Int) {
        a = value
        b = value
        c = value
    }
}

// 저장 속성
let t = Third(a: 1, b: 2, c: 3)     // 속성이 var, let, 기본값 으로 되어있는 것마다 다 다름

Class Initializers

클래스에서 구현하는 특별한 생성자에 대해 공부

Designated Initializer

지정 생성자

init(parameters) {
	initialization
}

Convenience Initializer

간편 생성자

convenience init(parameters) {
	initialization
}

// Designated Initializer - 모든 속성 초기화
class Position {
    var x: Double
    var y: Double
    
    init(x: Double, y: Double) {
        self.x = x
        self.y = y
    }
}

// Convenience Initializer - 특정 초기화
class Position1 {
    var x: Double
    var y: Double
    
    init(x: Double, y: Double) {
        self.x = x
        self.y = y
    }
    
    convenience init(x: Double) {       // 신기
        self.init(x: x, y: 0.0)
    }
}

Initializer Inheritance

class Figure {
    var name: String

    init(name: String) {
        self.name = name
   }

    func draw() {
        print("draw \(name)")
   }
    convenience init() {
        self.init(name: "unknown")
    }
}

class Rectangle: Figure {
    var width: Double = 0.0
    var height: Double = 0.0
    
    init(name: String, width: Double, height: Double) {
        
        self.width = width
        self.height = height
        super.init(name: name)
    }
    
    override init(name: String) {
        width = 0
        height = 0
        super.init(name: name)
    }
    
    convenience init() {
        self.init(name: "unknown")
    }
}

Required Initializer

모든 서브클래스에서 구현해야 하는 필수 생성자에 대해 공부

필수생성자

required init(parameters) {
	initialization
}

class Figure {
    var name: String

    required init(name: String) {
        self.name = name
   }

    func draw() {
        print("draw \(name)")
   }
}

class Rectangle: Figure {
    var width = 0.0
    var height = 0.0
    
    init() {
        width = 0.0
        height = 0.0
        super.init(name: "unknow")
    }
    
    // 슈퍼클래스랑 동일하게 구현해줘야 됨
    required init(name: String) {
        width = 0.0
        height = 0.0
        super.init(name: name)
    }
}

Initializer Delegation

생성자 델리게이션을 통해 인스턴스가 초기화 되는 과정을 공부
Initializer Delegation은 초기화 코드에서 중복을 최대한 제거하고 모든 속성을 효율적으로 초기화 하기 위해 사용

Value Type

// 가평식 - 상속 불가
struct Size {
   var width: Double
   var height: Double

   init(w: Double, h: Double) {
      width = w
      height = h
   }

   init(value: Double) {
    self.init(w: value, h: value)
   }
}

Class

1. Delegation의 Initializer는 반드시 super 클래스의 Delegation Initializer를 호출해야한다. = Delegate Up
2. Convenience Initializer는 동일한 클래스에 있는 다른 Initializer를 호출해야한다. = Delegate Across
3. Convenience Initializer를 호출했을때 최종적으로 동일한 클래스에 있는 Delegation Initializer가 호출되어야한다.

class Figure {
    let name: String
    
    init(name: String) {
        self.name = name
    }
    
    convenience init() {
        self.init(name: "unknown")
    }
}

class Rectangle: Figure {
    var width = 0.0
    var height = 0.0
    
    
    // Delegate Up = super 클래스를 호출
    init(n: String, w: Double, h: Double) {
        width = w
        height = h
        super.init(name: n)     // 상위구현 호출
    }
    
    // 동일한 글래스 호출
    convenience init(value: Double) {
        self.init(n: "rect", w: value, h: value)
    }
}

// 3번 째 규칙 사용 중
class Square: Rectangle{
    convenience init(value: Double){
        self.init(n: "square", w: value, h: value)
    }
    convenience init() {
        self.init(value: 0.0)
    }
}

Failable Initializer

초기화 실패를 옵셔널로 처리하는 방법을 공부

init?(parameters) {
	initialization
}
init!(parameters) {
	initialization
}

// 초기화에 실패하면 nil을 리턴
struct Position {
    let x: Double
    let y: Double
    
    init?(x: Double, y: Double) {
        guard  x >= 0.0, y >= 0.0 else {
            return nil
        }
        self.x = x
        self.y = y
    }
    init!(value: Double) {
        guard value >= 0.0 else {return nil}
        
//        self.x = value
//        self.y = value
        
        // 위와 같은 형식
        self.init(x: value, y: value)
        
    }
//    init(value: Int) {
//        self.x = value
//        self.y = value
//        self.in
//    }
}

var a = Position(x: 12, y: 34)

a = Position(x: -12, y: 0)

var b: Position = Position(value: 12)
b

// b = Position(value: -12)
// 초기화 실패 에러발생

Deinitializer

인스턴스가 해제되기 전에 호출되는 소멸자에 대해 공부

deinit {
	Deinitialization
}

// 소멸자
// 디버깅 용도
class Size {
   var width = 0.0
   var height = 0.0
}

class Position {
   var x = 0.0
   var y = 0.0
}

class Rect {
   var origin = Position()
   var size = Size()
    deinit {
        print("deinit \(self)")
    }
}

var r: Rect? = Rect()
r = nil
// 실행 - 호출