객체지향 프로그래밍과 Swift - Struct, Class, Property, Method

기본기 보충을 위해 스위프트의 교과서라고 할 수 있는 야곰책을 다시 보는 중인데요.

기본적인 내용이지만 역시 볼 때마다 새로운 것 같네요 ㅋㅋㅎㅎ

 

작년에 원티드에서 진행했던 프리온보딩 강의를 들었을 때도 야곰님이 기초적인 개념을 매우 강조하시면서

객체지향 프로그래밍을 1차시에 소개해주셨던 것이 생각나네요.. ^^.. 

 

매달 1권씩은 꼭 책을 읽으려고 하는데,

이번 달엔 객체지향의 사실과 오해. 라는 책을 구매했습니다. 

저번 달까진 자기계발서, 인문학 도서를 한 달에 1~2권 정도 읽었는데

이번 달엔 개발 서적을 좀 읽어보려고 합니다 !

 

쨋든, 책을 읽기 전에 Swift에서의 객체지향 프로그래밍 패터다임을 활용할 수 있는 문법을 짚어보고자 복습을 하게 되었습니다 !

1탄에서는 구조체, 클래스, 프로퍼티, 메서드를 정리하려고 합니다. 사실 이전에 정리해둔 것을 조금 다듬어서 합친 것.. ㅎ..

가독성 있고 간결하게 정리한 내용은 아니라서,,, 그냥 쭉 보면서 놓쳤던 부분만 상기시키면 좋을 것 같습니다.

 

---

스위프트는 함수형 프로그래밍 패러다임을 강조하지만, 객체지향 프로그래밍 패러다임도 매우 중요합니다.

애플의 프레임워크는 대부분 객체지향 프로그래밍 패러다임에 근간을 둡니다 !

그렇기 때문에 객체지향 프로그래밍 패러다임에 대한 이해는 필수 !

 

- 구조체와 클래스

- 프로퍼티와 메서드

- 인스턴스 생성 및 소멸

- 접근제어

 

위의 4개 파트로 나누어져 있습니다.

각각의 개념에 대한 내용이 많아서 글이 길지만,

한번에 모아서 보기 위해 2파트씩 나눠서 정리했습니다.

 

 

---

 

1. 구조체와 클래스

사실 구조체와 클래스에 대한 내용은 너무 많이 봐서 지긋지긋..하네요

그래서 이전에 정리해놨던 내용을 복붙했습니다. ㅋㅋ 

 

 

구조체의 인스턴스는 값 타입

클래스의 인스턴스는 참조 타입

---

구조체 - Struct

- 구조체 정의를 마친 후 인스턴스를 생성하고 초기화하고자 할때는 기본적으로 생성되는 멤버와이즈 이니셜라이저 사용

- 멤버와이즈 이니셜라이저? 프로퍼티의 이름으로 매개변수를 갖는 이니셜라이저

- 구조체에 기본 생성된 이니셜라이저의 매개변수는 구조체의 프로퍼티 이름으로 자동 지정 

- 구조체를 var로 선언하게 될 경우 .으로 접근하여 값 변경 가능

- 사용자 정의 이니셜라이저도 구현 가능

 

클래스 - Class

- Swift 의 클래스는 부모클래스 없더라도 상속없이 단독으로 정의 가능.

- 클래스를 정의한 후, 인스턴스를 생성하고 초기화 하고자 할때는 기본적인 이니셜라이저를 사용

- 프로퍼티에 기본 값이 지정되어 있는 경우, 전달인자를 통하여 따로 초깃값을 전달해주지 않아도 된다.

- 클래스의 인스턴스 = 객체 

- 인스턴스가 생성되고 초기화된 후 프로퍼티 값에 접근하려면 마침표 사용.

- 클래스의 인스턴스는 참조 타입이므로 클래스의 인스턴스를 let으로 선언해도 내부 프로퍼티 값을 변경할 수 있다.

 

---

클래스 인스턴스의 소멸

🔥 클래스의 인스턴스는 참조타입이므로 더는 참조할 필요가 없을 때 메모리에서 해제 됩니다.

 

 

소멸되기 직전 deinit이라는 메서드(디이니셜라이저 deinitializer) 호출

- 클래스 내부에 deinit 메서드를 구현해주면, 소멸되기 직전에 호출됨

- 클래스당 하나만 구현, 매개변수와 반환값을 가질 수 없음

Class Person {
...
	deinit {
		print("인스턴스 소멸")
	}
}

var yagom: Person? = Person()
yagom = nil // Person 클래스의 인스턴스가 소멸됩니다.

→ 보통 deinit 메서드에는 인스턴스가 메모리에서 해제되기 직전에 처리할 코드를 넣어줍니다. 예를 들어 인스턴스 소멸 전에 데이터를 저장한다거나 다른 객체에 인스턴스 소멸을 알려야할 때는 특히 deinit 메서드를 구현해야 합니다.

 

최근에 개발을 하면서 메모리에서 인스턴스가 해제되었는지 확인하기 위해 deinit 호출을 확인했던 기억이납니다.

deinit 메서드의 호출을 통해서도 메모리 릭을 잡아낼 수 있었습니다 :)

---

값 타입과 참조 타입 ??

값 타입과 참조 타입의 가장 큰 차이는 ?? → 무엇이 전달되느냐??

- 어떤 함수의 전달 인자로 값 타입의 값을 넘긴다면 전달될 값이 복사되어 전달됩니다.

- 그러나 참조 타입이 전달인자로 전달될때는 값을 복사하지 않고 참조(주소)가 전달됩니다.

- 함수의 전달인자로 넘길때도 참조가 전달되며 다른 변수 또는 상수에 할당될 때도 마찬가지로 참조가 할당된다 !

 

값 타입

struct BasicInformation {
	let name: String
	var age: Int
}

var yagomInfo: BasicInformation = BasicInformation(name: "yagom", age: 99)
yagomInfo.age = 100

//friendInfo 에 yagomInfo 의 값을 "복사"하여 할당 (extra memory)
var friendInfo: BasicInformation = yagomInfo

print("yagom's age: \\(yagomInfo.age)")
print("friend's age: \\(friendInfo.age)")

friendInfo.age = 25
//friendInfo 는 별도의 메모리를 할당 받았기 때문에 yagomInfo.age 에는 값 변경 X

func changeBasicInfo(_ info: BasicInformation){
	var copiedInfo: BasicInformation = info
	copiedInfo.age = 1
}

changeBasicInfo(yagomInfo)
print("yagom's age: \\(yagomInfo.age)")
//call by reference 가 아닌 call by value 이기 때문에 따로 값이 변경되지 않고 그대로 100임

참조타입

class Person{
	var height: Float = 0.0
	var weight: Float = 0.0
}

var yagom: Person = Person()
var friend: Person = yagom
//yagom의 참조를 할당한다

friend.height = 182.3
print("yagom height: \\(yagom.height)")
//friend.height 을 바꿨음에도 불구하고 yagom.height 도 같이 변경된다
// 같은 메모리를 참조하기 때문

func changePersonInfo(_ info: Person){
	info.height = 155.2
}

changePersonInfo(yagom)
print("yagom height: \\(yagom.height)")
//Call by reference 이기 때문에 실제 값이 변화되어 155.2 출력

 

 

- 값 타입의 데이터를 함수의 전달인자로 전달하면 메모리에 전달인자를 위한 인스턴스가 새로 생성된다.

- 생성된 새 인스턴스에는 전달하려는 값이 복사되어 들어감.

- 반면, 참조타입의 데이터는 전달인자로 전달할 때 기존 인스턴스의 참조를 전달.

- 새로운 인스턴스가 아닌 기존의 인스턴스 참조를 전달한다.

 

🔥 식별연산자 === : 클래스의 인스턴스끼리 참조가 같은지 확인할 때 사용 !

 

 

스위프트의 기본 데이터 타입은 모두 구조체

🔥 애플의 가이드라인에서 다음 조건 중 하나 이상에 해당한다면 구조체를 사용하는 것을 권장

 

- 연관된 간단한 값의 집합을 캡슐화하는 것만이 목적일 떄

- 캡슐화한 값을 참조하는 것보다 복사하는 것이 합당할 때

- 구조체에 저장된 프로퍼티가 값타입이며, 참조하는 것 보다 복사하는 것이 합당할 때

- 다른 타입으로 부터 상속 받거나 자신을 상속할 필요가 없을 때

적절한 예로는 좌표계가 있습니다.

- 좌표를 표현하고 싶을때 Int 타입으로 x,y 프로퍼티 생성

- 대다수 사용자 정의 데이터 타입은 클래스로 구현할일이 더 많을 것 !

 

 

스위프트의 복사 처리

 

스위프트의 기본 데이터 타입이 모두 구조체라서 다수의 배열 또는 딕셔너리 등의 데이터를 복사하고 이용할 때

메모리를 비효율적으로 사용한다고 오해할 수 있음.

 

하지만, 스위프트는 꼭 필요한 경우에만 진짜복사를 합니다 !

컴파일러가 판단해서 알아서 효율적으로 처리

 

스위프트는 소스파일 하나에 여러 개의 구조체와 클래스를 정의하고 구현해도 문제없음.

중첩함수와 마찬가지로 중첩 타입의 정의 및 선언이 가능함.

 

구조체와 클래스의 차이 

공통점

1. 값을 저장하기 위해 프로퍼티를 정의할 수 있습니다.

2. 기능 실행을 위해 메서드를 정의할 수 있습니다.

3. 서브스크립트 문법을 통해 구조체 또는 클래스가 갖는 값에 접근하도록 서브스크립트를 정의할 수 있음

4. 초기화 될때의 상태를 지정하기 위해 이니셜라이저를 정의할 수 있습니다.

5. 초기구현과 더불어 새로운 기능 추가를 위해 익스텐션을 통해 확장할 수 있습니다.

6. 특정 기능을 실행하기 위해 특정 프로토콜을 준수할 수 있습니다.

 

차이점

1. 구조체는 상속할 수 없습니다. 클래스의 인스턴스에만 허용됩니다.

2. 디이니셜라이저는 클래스의 인스턴스에만 활용할 수 있습니다.

3. 참조횟수 계산은 클래스의 인스턴스에만 적용됩니다.

4. 타입캐스팅은 클래스의 인스턴스에만 허용.

5. 구조체는 생성자를 구현하지 않아도 default initalizer 를 사용할 수 있음.

6. 구조체는 let으로 선언했을 경우 프로퍼티 값이 수정 불가능. 클래스는 let으로 선언해도 수정 가능.

 

 

---

2. 프로퍼티와 메서드 

 

프로퍼티는 클래스, 구조체 또는 열거형 등에 관련된 값.

메서드는 특정 타입에 관련된 함수.

 

 

Property = 저장 프로퍼티, 연산 프로퍼티, 타입 프로퍼티

- 저장 프로퍼티 : 인스턴스의 변수 또는 상수 ( 구조체, 클래스에서만 ) 

- 연산 프로퍼티 : 값을 저장한 것이 아니라 특정 연산을 실행한 결괏값. ( 클래스, 구조체, 열거형에 쓰일 수 있다. )

- 타입 프로퍼티 : 특정 타입에 사용되는 프로퍼티

 

정리 : 인스턴스 변수 => 저장 프로퍼티로, 클래스 변수 => 타입 프로퍼티로 구분.

 

---

Property Observers : 프로퍼티의 값이 변하는 것을 감시.

- 프로퍼티의 값이 변할 때 값의 변화에 따른 특정 작업을 실행. 

- 저장 프로퍼티에 적용할 수 있으며 부모클래스로부터 상속 받을 수 있음.

 

---

1) 저장 프로퍼티 

= 클래스 또는 구조체의 인스턴스와 연관된 값을 저장하는 프로퍼티.

 

- 프로퍼티 기본값과 초깃값을 지정해줄 수 있습니다.

** 클래스의 저장 프로퍼티는 옵셔널이 아니라면 프로퍼티 기본 값을 기정해주거나

- 사용자 정의 이니셜라이저를 통해 반드시 초기화해주어야합니다. 

** 클래스 인스턴스의 상수 프로퍼티는 인스턴스가 초기화 될 때 한번만 값을 할당할 수 있음.

자식 클래스에서 이 초기화를 변경할 수 없습니다.

 

 

클래스에서는 프로퍼티 기본값을 지정해주지 않는다면 이니셜라이저를 따로 정의해주어야합니다 !

 

- 이 말은 즉, 클래스의 저장 프로퍼티에 초깃값을 지정해주면 따로 사용자 정의 이니셜라이저를 구현해줄 필요가 없다 !

- 하지만, 의도와 맞지 않게 인스턴스가 사용될 가능성이 남아있고, 인스턴스를 생성한 후에 원하는 값을 일일이 할당해야해서 불편하다는 단점이 있습니다. 또, let으로 정의해주고 싶었던 프로퍼티는 인스턴스 생성 후에 값을 할당해주는게 불가능합니다 !

 

프로퍼티가 옵셔널이 아니라면, 인스턴스를 생성할 때 이니셜라이저를 통해 초깃값을 보내주자.

 

- 인스턴스는 생성할 때 프로퍼티에 값이 꼭 있어야하는 상태이기에, 옵셔널이 아닌 값일땐 초깃값을 보내줘야합니다. 만약 옵셔널이라면, 초기값을 넣어주지 않아도 됩니다.

 

struct CoordinatePoint {
	// 위치는 x, y 값이 모두 있어야 하므로 옵셔널이면 안 됩니다.
    var x: Int
    var y: Int
}

class Position {
    // 현재 사람의 위치를 모를 수도 있습니다. - 옵셔널
    var point: CoordinatePoint?
    let name: String
    
    init(name: String) {
        self.name = name
    }
}

// 이름은 필수지만 위치는 모를 수 있습니다.
let eunseoPosition: Position = Position(name: "eunseo")

// 위치를 알게되면 그때 위치 값을 할당해줍니다.
eunseoPosition.point = CoordinatePoint(x: 3, y: 6)

-> 이렇게 옵셔널과 이니셜라이저를 적절히 사용하면 다른 프로그래머가 사용할 때, 내가 처음 의도했던 대로 구조체와 클래스를 사용할 수있도록 유도할 수 있어요 !

 

---

 

+ ) 지연 저장 프로퍼티

- 인스턴스를 생성할 때 프로퍼티에 값이 필요없다면 옵셔널로 선언해 줄 수 있다 했는데, 다른 용도로 필요할때 값이 할당되는 지연 저장 프로퍼티가 있습니다. 지연저장프로퍼티는 호출이 있어야 값을 초기화해요. lazy 키워드 사용.

---

- 상수는 인스턴스가 완전히 생성되기 전에 초기화해야하므로 var로 정의해요.

- 주로 복잡한 클래스나 구조체를 구현할 때 많이 사용됩니다.

- 클래스의 인스턴스의 저장 프로퍼티로 다른 클래스 인스턴스나 구조체 인스턴스를 할당해야될 때가 있잖아요. 이럴 때 인스턴스를 초기화하면서 저장 프로퍼티로 쓰이는 인스턴스들이 한번에 생성되어야 한다면 ? 또, 굳이 모든 저장 프로퍼티르를 사용할 필요가 없다면 ? 지연저장 프로퍼티를 사용해요.

 

=> 잘 사용하면 불필요한 성능저하나 공간 낭비를 줄일 수 있습니다.

 

struct CoordinatePoint {
    var x: Int = 0
    var y: Int = 0
}

class Position {
    lazy var point: CoordinatePoint = CoordinatePoint()
    let name: String
    
    init(name: String) {
        self.name = name
    }
}

let eunseoPosition = Position(name: "eunseo")

// 이 코드를 통해 point 프로퍼티로 처음 접근할 때
// point 프로퍼티의 CoordinatePoint가 생성됩니다.
print(eunseoPosition.point)

주의 : 다중스레드와 지연저장 프로퍼티

- 다중 스레드 환경에서 지연 저장 프로퍼티에 동시다발적으로 접근할때는 한번만 초기화 된다는 보장이 없다.

- 생성되지 않은 지연저장 프로퍼티에 많은 스레드가 비슷한 시점에 접근한다면, 여러번 초기화 될 수 있습니다 !

 

 

---

 

2) 연산 프로퍼티

= 실제 값을 저장하는 프로퍼티가 아니라 특정 상태에 따른 값을 연산하는 프로퍼티.

 

- 인스턴스 내/외부의 값을 연산하여 적절한 값을 돌려주는 접근자(getter) 역할

- 은닉화된 내부의 프로퍼티 값을 간접적으로 설정하는 설정자(setter)의 역할

 

---

굳이 메서드를 두고 왜 연산 프로퍼티를 쓸까??? 

- 인스턴스 외부에서 메서드를 통해 인스턴스 내부 값에 접근하려면 메서드를 두개 구현해야합니다 . ( getter setter )

- 이를 감수하고 메서드로 구현한다해도 두 메서드가 분산 구현되어 코드의 가독성이 나빠질 위험이 있습니다.

- 타인의 코드를 보는 프로그래머의 입장에서는 프로퍼티가 메서드 형식보다 훨씬 더 간편하고 직관적 !

 

연산 프로퍼티의 단점

- 접근자인 get 메서드만 구현해둔 것처럼 읽기 전용상태로 구현하기 쉽지만, 쓰기 전용상태로 구현할 수 없다는 단점이 있다.

- 메서드로는 설정자 메서드만 구현하여 쓰기 전용 상태로 구현할 수 있지만 연산 프로퍼티는 그것이 불가능 합니다.

 

아래는 메서드로 구현된 getter, setter 입니다.

struct CoordinatePoint {
    var x: Int // 저장 프로퍼티
    var y: Int // 저장 프로퍼티 

   // 대칭점을 구하는 메서드 - 접근자
   // Self는 타입 자기 자신을 뜻합니다.
   // Self 대신 CoordinatePont를 사용해도 됩니다.
   func oppositePoint() -> Self {
        return CoordinatePoint(x: -x, y: -y)
    }
    
    // 대칭점을 설정하는 메서드 - 설정자
    mutating func setOppositePoint(_ opposite: CoordinatePoint) {
        x = -opposite.x
        y = -opposite.y
    }
}

var yagomPosition: CoordinatePoint = CoordinatePoint(x: 10, y: 20)

yagomPosition // 현재좌표
yagomPosition.oppositePoint() // 대칭 좌표

yagomPosition.setOppositePoint(CoordinatePoint(x: 15, y:10))
yagomPosition // 대칭좌표를 15,10으로 설정하면 현재는 -15, -10 이 된다.

-> oppositePoint() 로 대칭점을 구할 수 있고, setOppositePoint()로 대칭점을 설정해줘야한다.

 

 

연산프로퍼티를 사용해서 더 간결하게 표현하자

struct CoordinatePoint {
    var x: Int
    var y: Int
    
    // 대칭좌쵸 
    var oppositePoint: CoordinatePoint {
        // 연산 프로퍼티 
        get {
            return CoordinatePoint(x: -x, y: -y)
        }
        
        set(opposite) {
            x = -opposite.x
            y = -opposite.y
        }
    }
}

- 이런식으로 연산 프로퍼티를 사용합니다. 하나의 프로퍼티에 접근자와 설정자가 모두 모여있고, 해당 프로퍼티가 어떤 역할을 하는지 좀 더 명확하게 표현이 가능합니다 ! 인스턴스를 사용하는 입장에서는 마치 저장 프로퍼티인 것처럼 편하게 사용할 수 있어요.

- 설정자의 매개변수로 원하는 이름을 소괄호에 명시해주면, set메서드 내부에서 전달받은 전달인자 사용 가능.

- 관용적인 표현으로 newValue로 매개변수 이름을 대신할 수 있어요. 그럴 경우, 매개변수는 따로 표기하지 않습니다.

- 접근자 내부의 코드가 단 한 줄 이고, 그 결과값의 타입이 프로퍼티 타입과 같으면 return 키워드를 생략해도 됩니다.

- 굳이 대칭점을 설정할 필요가 없다면, get만 구현해서 읽기 전용으로 연산 프로퍼티를 사용할 수 있어요.

 

// 읽기전용으로 구현한다면 아래와 같이 설정하는 코드는 오류가 납니다.
yagomPosition.oppositePoint = CoordinatePoint(x: 15, y: 10)

 

 

---

프로퍼티 옵저버 Property Observers

- 프로퍼티의 값이 변경됨에 따라 적절한 작업을 취할 수 있습니다. 

- 프로퍼티 옵저버는 프로퍼티의 값이 새로 할당될 때마다 호출됩니다.

- 변경되는 값이 현재와 같더라도 호출됩니다.

- 저장프로퍼티 뿐만 아니라 프로퍼티를 재정의해 상속받은 저장,연산 프로퍼티에도 적용이 가능해요.

- 상속받지 않은 연산 프로퍼티는 접근자와 설정자를 통해 프로퍼티 옵저버를 구현할 수 있어요.

- 상속 받았을 때만 프로퍼티를 재정의 해줍니다.

 

 

프로퍼티 값이 변경되기 직전 : willSet, 프로퍼티 값이 변경된 직후 : didSet

- willSet과 didSet 메서드에는 매개변수가 하나씩 있는데요.

- willSet 메서드에 전달되는 전달인자는 프로퍼티가 변경될 값이고, didSet 메서드에 전달되는 전달인자는 프로퍼티가 변경되기 전의 값입니다.

- 매개변수 이름을 따로 지정하지 않을 경우, willSet에는 newValue / didSet에는 oldValue라는 매개변수 이름이 자동으로 지정됩니다.

- 다른 이름을 사용하고 싶다면, 소괄호 안에 적어주세요.

- didSet 코드 블록 내부에서 oldValue 값을 참조하지 않거나 매개변수 목록에 명시적으로 매개변수를 적어주지 않으면 didSet 블록은 실행되지 않습니다 !

 

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

let myAccount: Account = Account()
// 잔액이 0원에서 1000원으로 변경될 예정입니다.
myAccount.credit = 1000
// 잔액이 0원에서 1000원으로 변경되었습니다.

- 클래스를 상속 받았다면 기존의 연산 프로퍼티를 재정의하여 프로퍼티 옵저버를 구현할 수도 있음.

- 연산 프로퍼티를 재정의해도 기존의 연산 프로퍼티 기능은 동작

 

dollarValue가 포함되어 있는 Account 클래스를 상속받은 ForeignAccount 클래스에서 기존 dollarValue 프로퍼티를 재정의하여 프로퍼티 감시자를 구현하는 예제

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

    var dollarValue: Double {
        get {
            return Double(credit) / 1000.0
        }
        
        set {
            credit = Int(newValue * 1000)
            print("잔액을 \(newValue)달러로 변경중")
        }
    }
}


class ForeignAccount: Account {
    override var dollarValue: Double {
        willSet {
            print("잔액이 \(dollarValue)에서 \(newValue)로 변경될 예정")
        }
        
        didSet {
            print("잔액이 \(oldValue)원에서 \(dollarValue)로 변경되었습니다.")
        }
    }
}

let myAccount: ForeignAccount = ForeignAccount()
// 잔액이 0원에서 1000원으로 변경될 예정
myAccount.credit = 1000
// 잔액이 0원에서 1000으로 변경되었습니다.

// 잔액이 1.0달러에서 2.0달러로 변경될 예정
// 잔액이 1000원에서 2000원으로 변경될 예정
// 잔액이 1000원에서 2000원으로 변경됨

myAccount.dollarValue = 2 // 잔액을 2.0달러로 변경중
//잔액이 1.0달러에서 2.0달러로 변경되었습니다.

- 만약 프로퍼티 감시자가 있는 프로퍼티를 함수의 입출력 매개변수의 전달인자로 전달한다면 항상 willSet과 didSet 감시자를 호출, 함수 내부에서 값이 변경되든 되지 않든 간에 함수가 종료되는 시점에 값을 다시 쓰기 때문 !!

---

전역변수와 지역변수

앞서 설명한 연산 프로퍼티와 프로퍼티 감시자는 전역변수와 지역변수 모두에 사용 가능합니다 !

 

- 프로퍼티에 한정하지 않고, 전역에서 쓰일 수 있는 변수와 상수에도 두 기능 사용가능

- 우리가 프로퍼티를 다루기 전에 계속해서 사용했던 변수와 상수는 모두 지역변수 상수

- 전역변수 또는 전역상수는 지연 저장 프로퍼티처럼 처음 접근할때 최초로 연산이 이루어짐

- lazy 키워드를 사용하여 연산을 늦출 필요가 없다.

- 지역변수 및 지역상수는 절대로 지연 연산되지 않는다 !

 

---

타입 프로퍼티 

- 이제까지 앞서 본 프로퍼티 개념은 모두 타입을 정의하고 해당 타입의 인스턴스가 생성되었을 때 사용할 수 있는 인스턴스 프로퍼티입니다. 인스턴스 프로퍼티는 인스턴스를 새로 생성할때마다 초깃값에 해당하는 값이 프로퍼티의 값이 되고, 인스턴스 마다 다른 값을 지닐 수 있습니다. 

 

---

각각의 인스턴스가 아닌, 타입 자체에 속하는 프로퍼티를 타입 프로퍼티라고 합니다 !

- 타입 프로퍼티는 타입 자체에 영향을 미치는 프로퍼티입니다.

- 인스턴스의 생성 여부와 상관없이 타입 프로퍼티의 값은 하나며, 그 타입의 모든 인스턴스가 공통으로 사용하는 값, 모든 인스턴스에서 공용으로 접근하고 값을 변경할 수 있는 변수 등을 정의할 때 유용해요 !

 

타입 프로퍼티는 두 가지 입니다.

1. 저장 타입 프로퍼티는 변수 또는 상수로 선언할 수 있습니다. 반드시 초깃값을 설정해야하며 지연 연산됩니다.

지연 저장 프로퍼티와는 조금 다르게 다중 스레드 환경이라고 하더라도 단 한번만 초기화된다는 보장을 받습니다.

2. 연산 타입 프로퍼티는 변수로만 선언할 수 있습니다. 

 

class AClass {
    // 저장 타입 프로퍼티
    static var typeProperty: Int = 0
    
    // 저장 인스턴스 프로퍼티 
    var instanceProperty: Int = 0 {
    	didSet {
            // Self.typeProperty는
            // AClass.typeProperty 와 같은 표현
            Self.typeProperty = instanceProperty + 100
        }
    }
    
    // 연산 타입 프로퍼티 
    static var typeComputedProperty: Int {
        get {
            return typeProperty
        }
        
        set {
            typeProperty = newValue
        }
    }
}

AClass.typeProperty = 123

let classInstance: AClass = AClass()
classInstance.instanceProperty = 100

print(AClass.typeProperty) // 200
print(AClass.typeComputedProperty) // 200

- 이처럼 타입 프로퍼티는 인스턴스를 생성하지 않고도 사용할 수 있으며 타입에 해당하는 값입니다. !

- 인스턴스 접근 필요없이 타입 이름 만으로도 프로퍼티를 사용할 수 있습니다. 

- static let dollarExchangeRate: Double = 1000.0 와 같이 타입 상수로 사용할수도 있다.

 

 

---

키 경로 Key Path

- 함수는 일급시민으로서 상수나 변수에 참조를 할당할 수 있었음

- 함수를 참조해두고 나중에 원할때 호출할 수도 있고, 다른 함수를 참조하도록 할수도 있다.

 

func someFunction(paramA: Any, paramB: Any) {
    print("어쩌구")
}

var functionReference = someFunction(paramA:paramB)
functionReference("A","B")
functionReference = anotherFunction(paramA:paramB)

프로퍼티도 이처럼 값을 바로 꺼내오는 것이 아니라, 어떤 프로퍼티의 위치만 참조하도록 할 수 있다.

 

바로 KeyPath를 활용하는 방법 !

- KeyPath를 사용해서 간접적으로 특정 타입의 어떤 프로퍼티 값을 가리켜야 할지 미리 지정해두고 사용할 수 있다.

 

KeyPath 타입은 AnyKeyPath라는 클래스로부터 파생됩니다.

 

- 제일 많이 확장된 키 경로 타입은 WritableKeyPath<Root, Value> 와 ReferenceWritableKeyPath<Root, Value> 타입

- WritableKeyPath<Root, Value> : 값 타입에 키 경로 타입으로 읽고 쓸 수 있는 경우에 적용

- ReferenceWritableKeyPath<Root, Value> : 참조타입, 즉 클래스 타입에 키 경로 타입으로 읽고 쓸 수 있는 경우에 적용

- 키경로는 역슬래시와 타입, 마침표 경로로 구성됨 => \타입이름.경로.경로.경로 (여기서 경로는 프로퍼티 이름)

 

class Person {
    var name: String
    
    init(name: String) {
        self.name = name
    }
}

struct Stuff {
    var name: String
    var owner: String
}

print(type(of: \Person.name)) // ReferenceWritableKeyPath<Person,String>
print(type(of: \Stuff.name)) // WritableKeyPath<Stuff, String>

// 기존의 키 경로에 하위 경로 덧붙이기 

let keyPath = \Stuff.owner
let nameKeyPath = keyPath.appending(path: \.name)

 

- 각 인스턴스의 KeyPath 서브스크립트 메서드에 키 경로를 전달하여 프로퍼티에 접근할 수 있다.

class Person {
    var name: String
    
    init(name: String) {
        self.name = name
    }
}

struct Stuff {
    var name: String
    var owner: String
}

let yagom = Person(name: "yagom")
let hana = Person(name: "hana")
let macbook = Stuff(name: "MacBook Pro", owner: yagom)
var iMac = Stuff(name: "iMac", owner: yagom)
let iPhone = Stuff(name: "iPhone", owner: hana)

let stuffNameKeyPath = \Stuff.name
let ownerkeyPath = \Stuff.owner

// \Stuff.owner.name 과 같은 표현
let ownerNameKeyPath = ownerkeyPath.appending(path: \.name)

// 키 경로와 서브스크립트를 이용해 프로퍼티에 접근하여 값을 가져온다.
print(macbook[keyPath: stuffNameKeyPath]) // MacBook Pro
print(iMac[keyPath: stuffNameKeyPath]) // iMac
print(iPhone[keyPath: stuffNameKeyPath]) // iPhone

print(macbook[keyPath: ownerNameKeyPath]) // yagom
print(iMac[keyPath: ownerNameKeyPath]) // yagom
print(iPhone[keyPath: ownerNameKeyPath]) // hana

//  키 경로와 서브스크립트를 이용해 프로퍼티에 접근하여 값을 변경

iMac[keyPath: stuffNameKeyPath] = "iMac Pro"

// 상수로 지정한 값 타입과 읽기 전용 프로퍼티는 키 경로 스크립트로도 값을 바꿔줄수 없다.
// macbook 의 stuffName은 위처럼 바꿀 수 없다.

- KeyPath를 잘 활용하면 프로토콜과 마찬가지로 타입 간의 의존성을 낮추는데 많은 도움을 준다고 해요! 

- 그리고, 애플의 프레임워크는 키-값 코딩 등 많은 곳에 KeyPath를 활용하므로, 잘 알아둡시다 !!

- KeyPath는 타입 외부로 공개된 인스턴스 프로퍼티 혹은 서브스크립트에 한하여 표현할 수 있습니다.

 

TIP ! ) 자신을 나타내는 KeyPath인 \.self를 사용하면 인스턴스 그 자체를 표현하는 KeyPath가 된다. 또한, 컴파일러가 타입을 유추할 수 있는 경우에는 KeyPath에서 타입 이름을 생략할 수도 있다.

 

---

Swift 5.2 ~ 

- (SomeType) -> Value 타입의 클로저를 키 경로 표현으로 대체하여 사용할 수 있다.

 

struct Person {
    let name: String
    let nickname: String?
    let age: Int
    
    var isAdult: Bool {
        return age > 18
    }
}

let yagom: Person = Person(name: "yagom", nickname: "bear", age: 100)
let hana: Person = Person(name: "hana", nickname: "na", age: 100)
let happy: Person = Person(name: "happy", nickname: nil, age: 3)

let family: [Person] = [yagom, hana, happy]
let names: [String] = family.map(\.name)
let nicknames: [String] = family.compactMap(\.nickname)
let adults: [String] = family.filter(\.isAdult).map(\.name)

- family 배열은 [Person] 타입이고, 이 타입의 map은 (Person) -> T를, compactMap은 (Person) -> T? 를, filter는 (Person) -> Bool 타입의 클로저를 매개변수를 통해 전달받을 것.

- 이에 따라, \.name 표현은 (Person) -> T 타입의 클로저를 대체하여 표현함. 이는 클로저 표현인 { $0.name } 의 표현과 같은 역할 !

- .nickname과 .isAdult 표현도 같은 방식으로 동작

 

---

메서드

- 클래스, 구조체, 열거형 등은 실행하는 기능을 캡슐화한 인스턴스 메서드를 정의할 수 있음.

- 타입 자체와 관련된 기능을 실행하는 타입 메서드 정의 가능.

- 타입 메서드는 클래스 메서드와 유사한 개념.

- 스위프트의 특이점 : 구조체와 열거형이 메서드를 가질 수 있다 !

 

 

---

 

인스턴스 메서드 = 특정 타입의 인스턴스에 속한 함수

- 인스턴스 내부의 프로퍼티 값을 변경하거나 특정 연산 결과를 반환하는 등 인스턴스와 관련된 기능을 실행

- 인스턴스 메서드는 함수와 달리 특정 타입 내부에 구현 = 인스턴스가 존재할 때만 사용.

 

// 클래스의 인스턴스 메서드
class LevelClass {
    // 현재 레벨을 저장하는 저장 프로퍼티
    var level: Int = 0 {
        // 프로퍼티 값이 변경되면 호출하는 프로퍼티 감시자 
        didSet {
            print(level)
        }
    }
    
    // 레벨이 올랐을 때 호출하 ㄹ메서드 
    func levelUp() {
        level += 1
    }
    
    // 레벨이 감소할 때 호출할 메서드
    func levelDown() {
        level -= 1
        if level < 0 {
            reset()
        }
    }
    
    // 특정 레벨로 이동할 때 호출할 메서드
    func jumpLevel(to: Int) {
        level = to
    }
    // 레벨을 초기화할 때 호출할 메서드 
    func reset() {
        level = 0
    }
}

var levelClassInstance: LevelClass = LevelClass()
levelClassInstance.levelUp()

levelClass의 인스턴스 메서드는 level 인스턴스 프로퍼티의 값을 수정하는 코드가 존재합니다.

-> 자신의 프로퍼티 값을 수정할때 클래스의 인스턴스 메서드는 크게 신경 쓸 필요가 없어요. 하지만, 구조체나 열거형 등은 값 타입이므로 메서드 앞에 mutating 키워드를 붙여서 해당 메서드가 인스턴스 내부의 값을 변경한다는 것을 명시해야합니다 !

 

 

---

self 프로퍼티

- 모든 인스턴스는 암시적으로 생성된 self 프로퍼티를 가집니다. 자바의 this와 비슷하게 인스턴스 자기 자신을 가리키는 프로퍼티에요 !

- self 프로퍼티는 인스턴스를 더 명확히 지칭하고 싶을 때 사용합니다.

- level 변수를 사용할 때, 스위프트는 자동으로 메서드 내부에 선언된 지역변수를 먼저 사용하고, 그 다음에 메서드 매개변수, 그 다음에 인스턴스의 프로퍼티를 찾아서 level이 무엇을 지칭하는지 유추합니다. 

=> 그런데 메서드 매개변수의 이름이 level인데 이 level 매개변수가 아닌 인스턴스 프로퍼티인 level을 지칭하고 싶다면 ? self 프로퍼티를 사용해줍니다.

 

class LevelClass {
	var level: Int = 0 
    
    func jumpLevel(to level: Int) {
    	print("Jump to \(level)")
        self.level = level
    }
}

- 위의 예시를 보면, jumpLevel 메서드의 매개변수의 이름과 인스턴스 프로퍼티의 이름이 같습니다.

- 그럴 때 level = level 이라고 적어주면, 컴파일러는 좌측의 level은 인스턴스 프로퍼티의 level이 아닌 매개변수 level을 지칭하는 걸로 판단하겠죠 ! ( 위의 유추 순서에 따라.. )

- 그래서 좌측의 level 대신 self.level을 적어줍니다. 그러면 이제 인스턴스 프로퍼티라는 것을 명확히 할 수 있어요.

 

 

 

또, self  프로퍼티의 다른 용도는 값 타입 인스턴스 자체의 값을 치환할 수 있습니다.

=> 클래스의 인스턴스는 참조 타입이라 self 프로퍼티에 다른 참조를 할당할 수 없는데, 구조체나 열거형 등은 self 프로퍼티를 사용하여 자기 자체를 치환할 수 있어요 !

 

class LevelClass {
    var level: Int = 0
    
    func reset() {
        // 오류 ! 
        self = LevelClass()
    }
}

struct LevelStruct {
    var level: Int = 0
    
    mutating func levelUp() {
		level += 1
    }
    
    mutating func reset() {
        self = LevelStruct()
    }
}

enum OnOffSwitch {
    case on, off
    mutating func nextState() {
        self = self == .on ? .off : .on
    }
}

var toggle: OnOffSwitch = OnOffSwitch.off
toggle.nextState()
print(toggle) // on

 

 

---

 

인스턴스를 함수처럼 호출하도록 하는 메서드

- 특정 타입의 인스턴스를 문법적으로 함수를 사용하는 것처럼 보이게 할 수 있습니다.

- 인스턴스를 함수처럼 호출할 수 있도록 하려면 callAsFunction이라는 이름의 메서드를 구현하면 됩니다.

- 이 메서드는 매개변수와 반환타입만 다르다면 개수에 제한 없이 원하는 만큼 만들 수 있습니다.

- mutating 키워드도 사용할 수 있고, throws와 rethrows도 함께 사용할 수 있습니다.

 

struct Puppy {
    var name: String = "흰둥이"
    
    func callAsFunction() {
        print("멍멍")
    }
    
    func callAsFunction(destination: String) {
        print("\(destination)으로 달려갑니다.")
    }
}

var myPuppy: Puppy = Puppy()
myPuppy.callAsFunction()
myPuppy()
myPuppy.callAsFunction(destination: "집")
myPuppy(destination: "집")

 

- Puppy 구조체에 다양한 형태의 callAsFunction 메서드를 구현할 수 있습니다.

- 매개변수 타입, 전달인자 레이블, 반환 타입만 안 겹치게하면 원하는 만큼 가능해요. 

- myPuppy() 와 myPuppy.callAsFunction 이 같은 표현. 하지만, 메서드를 호출하는 것 외에 함수표현으로는 사용할수 없습니다.

- 즉, let function: (String) -> Void = myPuppy(destination:) 처럼은 안됩니다. 대신 let function: (String) -> Void = myPuppy.callAsFunction(destination:) 으로 표현해야 해요.

 

---

타입 메서드 = 타입 자체에 호출이 가능한 메서드

 

- 메서드에도 인스턴스 메서드와 타입 메서드가 있는데요, 타입메서드는 타입 자체에 호출이 가능한 메서드입니다.

- 흔히 객체지향 프로그래밍에서 지칭하는 클래스 메서드와 유사한 개념입니다.

- static 키워드를 사용해서 타입 메서드임을 나타내주고요.

- 클래스의 타입 메서드는 static 키워드와 class 키워드를 사용할 수 있는데 static으로 정의하면 상속 후 메서드 재정의가 불가능하고, class로 정의하면 상속 후 메서드 재정의가 가능해요 !

 

class AClass {
    static func staticTypeMethod() {
        print("에이 클래스 타입메서드")
    }
    
    class func classTypeMethod() {
		print("에이 클래스 클래스 메서드")
    }
}

class BClass: AClass {
    override class func classTypeMethod() {
        print("비 클래스 클래스 메서드")
    }
    // 타입메서드는 재정의 불가능
}

AClass.staticTypeMethod() // 에이 클래스 타입메서드
AClass.classTypeMethod() // 에이 클래스 클래스 메서드
BClass.classTypeMethod() // 비 클래스 클래스 메서드

- 또, 타입 메서드는 인스턴스 메서드와 달리 self 프로퍼티가 타입 그자체를 가리킵니다. 

- 인스턴스 메서드에서는 self가 인스턴스 를 가리키고, 타입 메서드의 self는 타입을 가리킵니다.

- 그래서 타입 메서드 내부에서 타입이름과 self는 같은 뜻이에요.

- 타입 메서드에서 self 프로퍼티를 사용하면 타입 프로퍼티 및 타입 메서드를 호출할 수 있습니다.

 

// 시스템 용량은 함 기기에서 유일한 값
struct SystemVolume {
    // 타입프로퍼티를 사용하면 언제나 유일한 값이 된다.
    static var volume: Int = 5
    
    // 타입프로퍼티를 제어하기 위해 타입 메서드를 사용
    static func mute() {
        self.volume = 0 // SystemVolume.volume 과 같은 표현, Self.volume과도 같은표현
    }
}

// 내비게이션 역할은 여러 인스턴스가 수행할 수 있다.
class Navigation {
    // 내비게이션 인스턴스마다 음량을 따로 설정할 수 있다.
    var volume: Int = 5
    
    // 길 안내 음성 재생
    func guideWay() {
        // 내비게이션 외 다른 재생원 음소거
        SystemVolume.mute()
    }
    
    // 길 안내 음성 종료
    func finishGuideWay() {
        // 기존 재생원 음서 ㅇ복구
        SystemVolume.volume = self.volume
    }
}

SystemVolume.volume = 10
let myNavi: Navigation = Navigation()

myNavi.guideWay()
print(SystemVolume.volume) // 0

myNavi.finishGuideWay()
print(SystemVolume.volume) // 5

 

 

오늘은 Struct , Class, Property, Method 내용을 다시 훑어봤는데요.

아는 내용도 있었고, 다시봐서 상기시킨 내용도 있었습니다. 

다음에는 더 깊은 내용을 다뤄볼 생각입니다 !

 

타입 메서드에서 class func과 static func의 차이를 자세히 찾아보려구요.

그리고, static property나 method를 효과적으로 사용하는 방법도 조만간 정리해볼게요 !

 

 

출처 : 모든 내용은 야곰님의 Swift 프로그래밍 책을 참고했습니다.