클래스와 구조체 기본

정의

struct PersonStruct {
    var name: String
    var age: Int
    //class와 다르게 struct는 기본적으로 멤버와이즈 이니셜라이저가 생성된다.
}


class PersonClass {
    var name: String
    var age: Int
    //멤버와이즈 이니셜라이저
    init(name: String, age: Int){ 
        self.name = name
        self.age = age
    }
}

💡클래스와 구조체의 프로퍼티들은 반드시 초기화 되어야 한다.

클래스와 구조체의 차이

할당 방식의 차이

var struct1: PersonStruct = PersonStruct(name: "choi", age: 22);
let class1: PersonClass = PersonClass(name: "hoon", age: 21);

var struct2: PersonStruct = struct1;
let class2: PersonClass = class1;

//구조체는 값을 복사해서 전달한다.
struct2.name="jun";
print(struct1.name) //choi, 구조체는 각각이 존재한다.

//클래스는 값을 복사하지 않고 인스턴스의 위치를 참조한다.
class1.age = 32
print(class2.age) //32, 같은곳을 참조함으로 함께 변한다

//클래스 참조 식별 연산자 ===
print(class1 === class2) //true

전달인자(매개변수)로서 클래스와 구조체가 전달될때 역시 같은 개념이 적용된다.
💡inout매개변수를 활용하면 아래 코드처럼 구조체도 참조방식을 사용할 수 있다.

func referStruct(_ refer: inout PersonStuct) -> Void {
    refer.name = "change";
}
func referClass(_ refer: PersonClass) -> Void {
    refer.name = "change";
}

referStruct(&struct1); //inout 매개변수 전달방식
referClass(class1);

print(struct1.name) //change
print(class1.name) //change

구조체의 사용시기

• 값의 집합을 캡슐화하는 것만이 목적일때
• 캡슐화한 값을 참조하는 것보단 복사하는 것이 합당할 때
• 다른타입의 상속이 불필요할 때

---

프로퍼티

지연저장프로퍼티

🔎사용시기

• 인스턴스의 많은양의 프로퍼티가 한번에 생성되는게 비효율적일 경우
• 모든프로퍼티를 사용할 필요가 없는 경우

//lazy 키워드를 프로퍼티 앞에 작성해준다.
struct LazyStruct {
    lazy var lazyVar: String = "lazy man"
}

😲예외사항: 지연저장프로퍼티가 let으로 선언됬을 경우

struct LazyStruct {
    lazy let lazyVar: String = "lazy man"
}

let lazyClass: LazyStruct = LazyStruct(); 
print(lazyClass.lazyVar); //cannot use mutating getter on immutable value

lazyClass.lazyVar를 호출할 때 lazyVar에 값이 할당된다.
let 키워드로 선언된 프로퍼티는 초기화 시에만 값 할당이 가능함으로 에러가 발생하게 된다.

📃고려사항

• 다중스레드 환경에서 한꺼번에 지연저장프로퍼티를 호출한다면
  값이 여러번 할당되는 현상이 나타날 수 있다.
• 전역 변수/상수는 호출시에 할당을 실시한다.
  즉, 전역변수/상수는 기본적으로 lazy 키워드 특성을 지니고 있다.

---

연산프로퍼티

• 프로퍼티에 대한 접근자와 설정자를 가독성 높게 표현가능하다.

연산프로퍼티와 프로퍼티 감시자

struct MyInform {
    var name: String
    //연산프로퍼티 sayHello
    var sayHello: String {
        get {
            name + "입니다" //코드가 한줄이라면 return키워드 생략가능
        }

        set(newName) { //전달인자를 작성하지 않으면 newValue를 기본으로 사용가능하다.
            name = newName;
        }
    }

    //age 프로퍼티 감시자
    var age: Int { 
        //값 변경 직전 실행된다.
        //전달인자를 사용하지 않으면 newValue, oldValue를 기본으로 사용가능하다.
        willSet(newOne) {
            print("age값이 \(newOne)로 변경됩니다.");
        }
        //값 변경 후 실행된다.
        didSet(oldOne) {
            print("age값이 \(oldOne)에서 \(age)로 바꼈습니다.");
        }
    }
}

var myName: MyInform = MyInform(name: "choi", age: 22);
print(myName.sayHello);   // choi입니다 (get)
myName.sayHello = "hoon"; // (set)
print(myName.sayHello);   // hoon입니다 (get)


myName.age = 44; //age값이 44로 변경됩니다.(willSet) age값이 22에서 44로 바꼈습니다.(didSet)

💡프로퍼티의 값이 초기화될때는 프로퍼티 감시자 매서드가 호출 되지 않습니다.😮

🔎프로퍼티 감시자, 연산 프로퍼티는 프로퍼티에 쓰였지만 해당기능은
모든 전역, 지역변수가 사용이 가능합니다.

---

타입프로퍼티

c , cpp 언어의 static과 유사한 개념이다.

struct TypeStruct {
    static let myStaticProp = 100;

    var calcProp: Int {
        get {
            Self.myStaticProp //대문자 Self는 내부에서 타입자체를 가리킨다.
        }
    }
}

//타입을 통해 직접 호출
print(TypeStruct.myStaticProp) //100

var ts: TypeStruct = TypeStruct();
print(ts.calcProp); //100

💡self는 내부에서 인스턴스를 가리키고 Self는 내부에서 타입자체를 가리킨다.

---

Self & self

• self는 모든 인스턴스가 암시적으로 생성하는 프로퍼티이다.
  자기 자신을 가리키는 것으로, 클래스나 구조체 등의 인스턴스 내에서 사용할 수 있다.

• 구조체나 열거형일 경우, self 프로퍼티를 사용해 자기 자신으로 교체(치환)가 가능하다.
  클래스는 참조 타입이라, self 프로퍼티에 다른 참조를 할당할 수 없다.

• Self는 타입이다. 특정한 타입이 아니라, 타입의 이름을 반복해 작성하지 않고
  현재 타입을 가리키는 코드를 사용할 수 있게 해 준다

---

프로퍼티와 키경로

• swift에서 함수를 변수/상수에 저장해 사용하는 것처럼
  클래스나 구조체의 프로퍼티 위치를 저장해서 사용할 수 있다.
• 키경로는
  구조체의 경우 WritableKeyPath<AddressStruct, String>를 사용한다.
  클래스의 경우 ReferenceWritableKeyPath<AddressClass, String>를 사용한다.

struct AddStruct {
    var home: String
    var email: String
}

class AddClass {
    var home: String = ""
    var email: String = ""
}

// \, . 를 이용해 선언이 가능하다.
var structKeyPath = \AddStruct.home;
var classKeyPath = \AddClass.home;

//구조체와 클래스의 키경로는 다른 타입을 가진다.
print(type(of: structKeyPath)) //WritableKeyPath<AddStruct, String>
print(type(of: classKeyPath)) //ReferenceWritableKeyPath<AddClass, String>

var structInstance: AddStruct = AddStruct(home: "Seoul", email: "email@naver.com");

//해당 프로퍼티에 키경로를 전달해 값을 추출할 수 있다.
print( structInstance[keyPath: structKeyPath] ); //Seoul

//해당프로퍼티를 수정할 수 있다. 상수인 경우는 불가능하다.
structInstance[keyPath: structKeyPath] = "Daejun";
print( structInstance[keyPath: structKeyPath] ); //Daejun

//.self 를 사용해 타입을 유추시킬 수 있다.
print( structInstance[keyPath: \.self.email ] ) //email@naver.com

📝위내용중 [keyPath:]의 사용에 대해서는 서브스크립트 포스팅에서 정리하도록 하겠다.

---

매서드

struct MyStruct {
    var name: String

    //구조체의 경우 내부프로퍼티의 값을 변경(mutate)하는 매서드는 mutating 키워드를 붙여줘야 한다.
    //클래스는 상관없다.
    mutating func changeName(_ name: String) {.
        self.name = name; //mutating
    }

    mutating func allnewStruct(_ name: String) {
        //구조체의 경우만 self를 사용해 자기자신을 치환시킬 수 있다. 
        self = MyStruct(name: name);
    }

    //인스턴스 함수처럼 호출 할수 있도록 해준다.
    func callAsFunction() {
        print(name);
    }
    
    //개수제한 없이 생성 가능하다.
    func callAsFunction(_ remark: String) {
        print("my name is \(name), \(remark)");
    }
}

var myName: MyStruct = MyStruct(name: "choi");
myName() //choi
myName.changeName("hoon")
myName() //hoon
myName.allnewStruct("young")
myName() //young

myName("nice to meet you.") //my name is young, nice to meet you.

---

타입매서드

• 앞의 타입 프로퍼티와 비슷한 개념이다.
• class 키워드를 사용한 타입매서드는 상속시 재정의(overriding)가 가능하다.
• static 키워드를 사용하면 재정의가 불가능하다.

class Aclass {
    static func sayHello(){
        print("Hello~")
    }

    class func sayGoodBye() {
        print("Good Bye")   
    }

    static func hiAndBye() {
        //타입 매서드에서 self는 인스턴스가 아닌 타입자체를 가리킨다.
        self.sayHello();
        self.sayGoodBye();
    }
}

class Bclass: Aclass{
    //타입매서드 재정의
    override class func sayGoodBye(){
        print("Good Bye, see you again!")
    }
}

Aclass.hiAndBye(); //Hello~ Good Bye

//재정의 됬음으로 재정의전 매서드는 실행되지 않는다.
Bclass.sayGoodBye(); //Good Bye, see you again!

---

이니셜라이저

• 옵셔널 타입을 제외한 인스턴스의 모든 프로퍼티는 초기화시 값을 가져야한다.
• 상수 프로퍼티의 경우 기본값사용하거나 이니셜라이저에서 초기화가 가능하다.

실패가능한 이니셜라이저

• 프로퍼티 초기화시 전달인자의 오류 등으로 의도치않은 생성을 막기위해 사용된다.
• init 함수 뒤에 ?를 붙여 선언한다.
• 초기화에 실패한경우 nil을 반환해 실패사실을 알린다.

struct School {
    var name: String;

    init?(_ name: String){
        if name.isEmpty {
            return nil;
        }
        self.name = name;
    }
} 

var mySchool: School? = School("")
print(mySchool) //nil

//열거형 활용
enum SchoolAge: String{
    case elementary="초등학생"
    case middle="중학생"

    init?(_ age: Int){
        switch(age){
            case 8...13:
                //self를 사용하여 자신 지정
                self = .elementary
            case 14...16:
                self = .middle
            default:
                return nil
        }
    }
}

//초기화 실패시 옵셔널값을 받아야 함으로 옵셔널타입으로 선언한다.
var choi: SchoolAge? = SchoolAge(22);
print(choi == Optional<SchoolAge>.none); //true

💡열거형 항목을 rawValue로 조회하는 방법은 실패가능한 이니셜라이저의 예시이다.

enum ForSearch: Int{
    case zero, one
    
    init?(value: Int){
        switch value {
        case 0:
            self = .zero
        case 1:
            self = .one
        default:
            return nil;
        }
    }
}

//value를 rawValue로 바꾸기만 하면 기존 매서드랑 일치한다.
var test: ForSearch? = ForSearch(value: 2)

print(test); //nil

클로저를 활용한 초기화 방법

초기화 클로저 내부 유의사항

• 인스턴스의 다른 프로퍼티, 매서드가 초기화 전임으로 사용이 불가능하다.
• self 프로퍼티 역시 사용이 불가능하다.
• 반환하는 값의 타입이 프로퍼티 타입과 일치해야 한다.

struct ClosureStruct {
    var name: String = {
        () -> String in //생략가능한 표현
        return "choi"  //프로퍼티 타입인 String
    }() //클로저를 실행값을 반환해야 함으로 ()붙여 실행문으로 작성한다.
}

var me: ClosureStruct = ClosureStruct();
print(me.name); //choi

🔎클로저는 클로저 포스팅에서 자세하게 설명하겠다.

---

인스턴스 소멸

• 클래스 인스턴스에서만 구현가능하다.
• 사용목적은 예를들어 클래스가 어떤 파일을 열고 소멸된다면 파일은 열린채로 방치된다.
  이런 상황을 막기위해 사용한다.
• deinit 이름으로 선언되며 모든 프로퍼티에 접근 가능하다.

class SomeClass{
    deinit {
        print("good bye");
    }
}

var test: SomeClass? = SomeClass();

//인스턴스가 어느곳에도 참조되있지 않음으로 소멸된다.👉deinit호출
test = nil; //good bye

---