인스턴스 생성 및 소멸

- 클래스 인스턴스의 소멸 시점 : ARC에 의해 결정된다

 

  • 이니셜라이저
    • 저장 프로퍼티의 초깃값 설정
    • 옵셔널 프로퍼티는 제외
  • 프로퍼티의 기본값
    • var num = 100
  • 상수 프로퍼티의 초기화
    • lazy var 얘기할 때 한번 언급한 것 같은데
    • let(상수) 프로퍼티는 초기화 과정에서만 값을 할당할 수 있다
  • 실패 가능한 이니셜라이저
    • init?(...)
    • 대표적으로 이니셜라이저의 전달인자로 잘못된 값이 전달되었을 때, 초기화 실패할 수 있다
    • 실패를 염두한 이니셜라이저
  • 함수를 사용한 프로퍼티 기본값 설정
    • iOS에서 UI 컴포넌트를 클래스의 프로퍼티로 구현하고, UI 컴포넌트의 생성과 동시에 Constraint등의 설정할 때 용이함
  • 인스턴스 소멸
    • deinit은 클래스에서만 구현이 가능함

이번달 내로 2020년 회고 쓸건데 이거 언제 다하고 쓰지...

 

프로퍼티와 메서드

  • 프로퍼티
    • 저장 프로퍼티
      • 변수 or 상수
      • 클래스와 구조체에 포함
    • 연산 프로퍼티
      • 연산을 실행한 결괏값
      • 실제로 데이터 값을 갖지 않음
      • 클래스, 구조체, 열거형에 포함
      • getter/setter가 존재
      • 왜 사용하는가?
        • 메서드로 구현시, get/set Method 2개를 구현해야 하는데, 보다 훨씬 간편함
    • 타입 프로퍼티
      • 특정 타입에 사용
      • static 키워드 사용
    • 지연 저장 프로퍼티
      • 처음으로 호출될 때, 초기화를 진행한다 
      • lazy var 키워드 사용
      • lazy let은 사용할 수 없다 -> (let은 생성될 때, 초기화된 후로 변경될 수 없기 때문이 아닐까?)
      • 여러 쓰레드가 동시에 접근 시, 여러번 초기화 가능성이 있다. -> Non-Thread-Safe
//연산 프로퍼티
struct Point{
	var x: Float
    var y: Float
	var oppositePoint: Self{
    	get{
        	return Point(x: -x, y: -y)
        }
        //set은 생략가능 -> 읽기전용 프로퍼티로 선언/사용 가능
        set(opposite){
        	x = -opposite.x
            y = -opposite.y
        }
    }
}

 

프로퍼티 감시자

- 값이 새로 할당될 때마다 호출

- 저장/연산 프로퍼티에 사용 가능

- willset/didset 구현

- 현재 값과 같더라도 실행된다

- 오버라이드가 가능하다

class Account{
	var credit: Int = 0{
    	willSet{
        	print("잔액이 \(credit)에서 \(newValue)로 변경될 것입니다")
        }
        didSet{
        	print("잔액이 \(oldValue)에서 \(credit)으로 변경되었습니다")
        }
    }
}

 

타입 프로퍼티

- 인스턴스가 아닌 각각의 타입 다체에 속하는 프로퍼티

- static let, static var 사용 가능하지만, 연산 프로퍼티는 var로만 선언 가능

- 반드시 초깃값을 설정해야 하며, 지연 연산된다

- 지연 저장 프로퍼티(lazy var)와는 다르게 다중 쓰레드 환경에서도 단 한번만 초기화 된다


메서드

  • 인스턴스 메서드
    • 인스턴스가 존재할 때만 사용 가능
    • 구조체/열거형에서 인스턴스 내부 값(프로퍼티)을 변경하기 위해서는 mutating func로 선언
  • 타입 메서드
    • static func / class func 가 존재한다
      • 둘다 같은 타입 메서드지만, static은 상속 불가, class는 상속 가능 타입 메서드이다
    • 여기서의 Self는 인스턴스가 아닌 타입 자신을 의미한다

 

하... 이제 옵셔널이다

 

옵셔널

- 사실 옵셔널에는 내용이 굉장히 적다.

- B.U.T. 어느 문법이던 중요하겠지만 Swift에서도 굉장히 중요한 표현이다

- 안드로이드 개발을 진행할 때는, 옵셔널이라는 명칭보다는 nullable이라는 단어를 사용했다.

- 스위프트의 특징인 안전성을 담보로 사용할 수 있는 기능이다

- 옵셔널과 옵셔널이 아닌 값은 철저히 다른 타입으로 인식하기 때문에, 컴파일 시점에서 오류를 걸러낸다.

 

그렇다면 왜 옵셔널을 사용하는가?

  • 함수의 전달인자의 값이 잘못된 값일 때
  • 매개변수를 굳이 넘기지 않아도 될 때
  • 열거형을 불러올 때, case에 존재하지 않을 때

앞에서 enum에서 알아봤 듯이, 옵셔널은 열거형이다

 

옵셔널 추출

  • 옵셔널 바인딩
    • if 사용 - if블록 내에서만 사용 가능
    • guard 사용 - 블록외의 블록에서 사용 가능
  • 암시적 추출
    • ! 사용 - 위험한 방법
struct Person{
	var name: String?
}

var person: Person = Person(name: "tree")

//if 사용
if let name = person.name{
	print(name) // tree
}

//guard 사용
guard let name = person.name else { ... }

print(name) // tree

//암시적 추출 사용(1)
let name = person.name!
print(name) // tree

var person2 = Person()
let name2 = person2.name! // 런타임 에러 발생

 

정리하려고 맘 먹고 작성 중인데... 잘못 먹은 것 같다..

함수

  • 앞서 말했 듯, Swift에서의 함수는 일급 시민이다

함수 vs 메서드

  • 메서드 : 구조체, 클래스, 열거형 등 특정 타입에 연관되어 사용하는 함수
  • 함수 : 모듈 전체에서 전역적으로 사용하는 함수
    • 개발자들끼리 약속된 것 같다. 누구는 클래스의 메소드를 메소드라하고, 누구는 함수라 하고, 누구는 펑션이라 한다면 의사소통이 비효율적일 것이기 때문에, 약속(?)한 것이 아닐까
    • 나도 이때부터 확실히 머리속에 박아두고 설명할 때는 인지하며 말하는 편이다.
//매개변수가 없는 함수
func sayHello(){
	print("Hello, My name is tree")
}

//매개변수가 있는 함수
func sayHello(name: String){
	print("Hello, My name is \(name)")
}

//매개변수의 기본값이 있는 함수
func sayHello(name: String = "tree"){
	print("Hello, My name is \(name)")
}

//반환 타입이 있는 함수
func sayHello(name: String) -> String{
	return "Hello, My name is \(name)"
}

+ 매개변수의 기본값이 있는 매개변수는 뒤로 보내야 한다.

 

입출력 매개변수 사용

  • 순서
    • 전달인자 값 복사
    • 함수 내부에서 값 변경
    • 반환 시점에 변경된 값을 매개변수에 할당
  • inout을 사용하면 값 타입도 참조 타입처럼 사용할 수 있다
  • B.U.T. 메모리 관점에서 안전하지 않기 때문에 사용을 지양한다. -> 이에 대해서도 이후에 작성할 것이다
//보통은 값을 복사하여 매개변수로 전달한다

var arr: [Int] = [1,2,3,4,5]

func abc(_ arr: [Int]){
	arr[0] = 100
}

abc(arr)
print(arr[0]) // 1

//입출력 매개변수 사용
func abc(_ arr: inout [Int]){
	arr[0] = 100
}

abc(&arr)
print(arr[0]) // 100

함수를 데이터 타입으로

- 앞서서 여러 차례 말했 듯이 함수는 일급 시민으로써 사용된다

var someFunction: (Int, Int) -> Int

func addInts(_ a: Int, _ b: Int) -> Int{
	return a+b
}

someFunction = addInts

print(someFunction(1,2)) // 3

someFunction이라는 변수에 addInts라는 함수를 지정하여 사용할 수 있다

B.U.T. 타입이 같아야한다.

 

중첩 함수

말 그대로 함수 내에 함수가 존재하는 것이다.

func function1(_ bool: Bool) -> (Int) -> Int{
	func plus(_ i: Int) -> Int{
    	return i+1
    }
    func minus(_ i: Int) -> Int{
    	return i-1
    }
    
    //삼항 연산자
    // ? 앞의 식이 true면 plus를 false면 minus를 return한다
    return bool ? plus: minus
}

var num: (Int) -> Int = func(true) //plus함수 할당
print(num(1)) // 2

 

이외에도 다양한 함수들이 존재한다

  • 종료되지 않는 함수
    • 반환 타입을 Never로 선언
  • 반환값을 무시 가능한 함수
    • @discardableResult 어노테이션 사용

+ Recent posts