Swift 심화 문법 강의 정리 💻 #2

접근제한자

: 다른 소스 파일이나 모듈의 코드에서 코드 일부에 대한 접근을 제한

[제약 적음] open < public < internal < fileprivate < private [제약 많음]

상위 요소보다 하위 요소가 더 높은 접근 수준을 가질 수 없습니다.

private struct Car {
	  public var model: String // 🚨 에러
}

//private의 제약이 public보다 더욱 크기에 에러가 발생!

- open 			: 모든 소스 파일에서 해당 level 접근 가능
				+ 모든 곳에서 서브클래싱 가능
                
- public 		: 모든 소스 파일에서 해당 level 접근 가능 
		  		+ 같은 모듈 내에서만 서브클래싱 가능
                
- internal 		: 같은 모듈 내에서만 접근 가능
				+ 접근 제한자를 작성하지 않으면 `internal`로 판단

- fileprivate 	: 같은 소스파일 내에서만 접근 가능

- private 		: 클래스 내부에서만 접근 가능

fileprivate -> 서로 다른 클래스가 같은 하나의 소스 파일에 fileprivate로 선언되어 있다면, 두 클래스는 서로 접근할 수 있음

private -> 같은 파일 안에 있어도 서로 다른 클래스이고, private로 선언되어 있다면 두 요소는 서로 접근할 수 없음

---

예외처리

에러처리

: 프로그램에서 에러가 발생한 상황에 대응하고 이에 대응하는 과정

Error 프로토콜을 채택하여 사용자 정의 에러를 정의하여 에러 대응

enum VendingMachineError: Error {
    case invalidSelection
    case insufficientFunds(coinsNeeded: Int)
    case outOfStock
}

throw, do-catch

• throws는 리턴 값을 반환하기 전에, 오류가 발생하면 에러 객체를 반환
• throws는 오류가 발생할 가능성이 있는 메소드 제목 옆에 사용
• throw는 오류가 발생할 구간에서 사용

throw로 던진 에러를 do-catch문에서 처리

enum CustomError: Error {
    case outOfBounds
    case invalidInput(String)
} // Error 프로토콜을 활용하여 사용자가 직접 에러 정의


func processValue(_ value: Int) throws -> Int {
    if value < 0 {
        throw CustomError.invalidInput("Value cannot be negative")
    } else if value > 100 {
        throw CustomError.outOfBounds
    }
    return value * 2
} // `throw`문을 활용하여 오류가 발생하였을 때의 동작 설정


do {
    let result = try processValue(-10)
    print("Result is \(result)")
} catch CustomError.outOfBounds {
    print("Value is out of bounds!")
} catch CustomError.invalidInput(let errorMessage) {
    print("Invalid Input: \(errorMessage)")
} catch {
    print("An error occurred: \(error)")
} // `do-catch`문을 활용하여 에러 처리
// 출력 : Invalid Input: Value cannot be negative

try , try? , try!

• try
  • 에러가 발생할 수 있는 코드 블록을 표시
  • 에러를 던질 수 있는 함수나 메서드를 호출할 때 사용
  • 해당 코드 블록에서 발생한 에러를 잡거나 처리할 수 있음 -> do-catch
• try?
  • do-catch 구문 없이도 사용이 가능
  • 에러 발생시 nil값을 반환
  • 에러가 발생하지 않으면 리턴 값의 타입은 옵셔널로 반환
• try!
  • 에러가 발생을 하면 앱이 강제 종료
  • 반환 타입은 옵셔널이 언래핑된 값이 리턴됨

enum MyError: Error {
    case invalidInput
}


func someThrowingFunction(value: Int) throws -> String {
    guard value >= 0 else {
        throw MyError.invalidInput // value가 음수인 경우 에러를 던짐
    }

    return "The value is \(value)"
}


do {
    let result = try someThrowingFunction(value: -2)
    print(result)
} catch {
    print("Error occurred: \(error)") // 음수 값을 처리하는 에러
} // do-catch문과 try 함께 사용

// try?를 사용하여 에러 처리하기
let result1 = try? someThrowingFunction(value: 5) // 유효한 값 호출
print(result1) // Optional("The value is 5") -> 옵셔널 타입으로 결과 반환

let result2 = try? someThrowingFunction(value: -2)
print(result2) // nil


let result4 = try! someThrowingFunction(value: -2)
print(result4)
// 에러가 발생할 수 있는 상황에서 try! 사용으로 인해, 에러 발생 및 앱 강제 종료

---

ARC와 메모리 누수

ARC(Automatic Reference Counting)

: Swift에서의 메모리 관리 기법 중 하나로, 객체나 인스턴스가 참조되는 횟수를 추적하여 메모리에서 해제할 시점을 결정

참조 횟수가 0이 되면 해당 객체는 메모리에서 해제

class Person {
    let name: String
    init(name: String) {
        self.name = name
        print("\(name) is being initialized")
    }
    deinit {
        print("\(name) is being deinitialized")
    }
}

var reference1: Person?
var reference2: Person?
var reference3: Person?

reference1 = Person(name: "John Appleseed") // RC: 1️⃣
// Prints "John Appleseed is being initialized"

reference2 = reference1 // RC: 2️⃣ 
reference3 = reference1 // RC: 3️⃣

reference1 = nil // RC: 2️⃣ -> 참고했던 객체를 지우면 RC가 1씩 감소
reference2 = nil // RC: 1️⃣

reference3 = nil // RC: 0️⃣ -> 해당 객체는 메모리에서 해제
// Prints "John Appleseed is being deinitialized"
// 프로퍼티 옵저버와 유사하게 참고 여부를 계속 확인하여 반응

강한 참조 순환(Strong Reference Cycle)

: 두 개 이상의 인스턴스가 서로가 서로를 강한 참조일 때 발생

강한 참조 순환: 메모리가 해제되지 않고 유지되어 메모리 누수가 발생하는 현상

• Swift로 개발할 때에는 메모리 누수(Memory Leak)을 주의
• 참조는 디폴트로 강한 참조(Strong Reference)를 사용

강한 참조를 잘못 사용하면 메모리 누수(Memory Leak) 문제가 발생할 수 있음

강한 참조 순환 문제 해결 방법

1. 약한 참조(Weak Reference) 사용
   : 참조되는 대상을 약하게 참조하여 순환 참조를 방지

• weak는 옵셔널로 선언되는 참조

• 참조 대상이 메모리에서 해제되면 자동으로 nil로 설정

두 객체가 서로를 강하게 참조하는 경우, 한쪽을 weak로 선언하여 순환 참조 문제를 해결

class Man {
    var name: String
    weak var girlfriend: Woman? 
    //weak는 클래스 내부가 아니라 사용하는 객체 앞에 붙여도 됨

    init(name: String) {
        self.name = name
    }
    deinit { print("Man Deinit!") }
}

class Woman {
    var name: String
    var boyfriend: Man?

    init(name: String) {
        self.name = name
    }
    deinit { print("Woman Deinit!") }
}


var chelosu: Man? = .init(name: "철수")
var yeonghee: Woman? = .init(name: "영희")

chelosu?.girlfriend = yeonghee
yeonghee?.boyfriend = chelosu


chelosu = nil
yeonghee = nil
chelosu?.girlfriend // nil -> `weak`를 활용한 에러 처리

2. 비소유 참조(Unowned Reference)
   : 참조되는 대상이 항상 유효한 경우에만 사용하며, 해당 대상이 해제될 수 있는 상황에는 사용하지 않음

• unowned는 옵셔널이 아닌 비소유 참조

• 비소유 참조는 항상 값이 있다고 가정하며, 참조하는 객체가 해제되면 런타임 에러가 발생할 수 있음

unowned 참조는 참조 대상이 해제될 수 있는 경우에만 사용

class Man {
    var name: String
    unowned var girlfriend: Woman?

    init(name: String) {
        self.name = name
    }
    deinit { print("Man Deinit!") }
}

class Woman {
    var name: String
    var boyfriend: Man?

    init(name: String) {
        self.name = name
    }
    deinit { print("Woman Deinit!") }
}

var chelosu: Man? = .init(name: "철수")
var yeonghee: Woman? = .init(name: "영희")

chelosu?.girlfriend = yeonghee
yeonghee?.boyfriend = chelosu


yeonghee = nil
chelosu?.girlfriend // 에러 발생