[Swift] #3 다양한 표현 및 확장1 (구조체 / 클래스 / 열거형)

1. 구조체

struct 이름 {
	/* 구현부 */
}

• UpperCamelCase 사용
• 프로퍼티: 인스턴스 변수 (타입 안에 들어있는 변수)
  • 인스턴스 프로퍼티: var, let
  • 타입 프로퍼티: static , 타입에서 사용할 수 있는 프로퍼티
• 메소드: 구조체 안에 들어있는 함수 (타입 안에 들어있는 함수)
  • 인스턴스 메서드: 인스턴스가 사용
  • 타입 메서드: static,  타입 자체가 사용하는 메서드

struct Sample {
    // 가변 프로퍼티(값 변경 가능)
    var mutableProperty: Int = 100 
    
    // 불변 프로퍼티(값 변경 불가능)
    let immutableProperty: Int = 100 
    
    // 타입 프로퍼티(static 키워드 사용 : 타입 자체가 사용하는 프로퍼티)
    static var typeProperty: Int = 100 
    
    // 인스턴스 메서드(인스턴스가 사용하는 메서드)
    func instanceMethod() {
        print("instance method")
    }
    
    // 타입 메서드(static 키워드 사용 : 타입 자체가 사용하는 메서드)
    static func typeMethod() {
        print("type method")
    }
}

 

• 가변 인스턴스 생성
  •  불변 프로퍼티만 수정 불가

var mutable: Sample = Sample();

mutable.mutableProperty = 200

// 불변 프로퍼티 수정 불가
// mutable.immutableProperty = 200

 

• 불변 인스턴스 생성
  • 프로퍼티 수정 불가
  • 메소드 호출 가능

// 불변 인스턴스
let immutable: Sample = Sample()

// 불변 인스턴스는 아무리 가변 프로퍼티라도
// 인스턴스 생성 후에 수정할 수 없습니다
// 컴파일 오류 발생
//immutable.mutableProperty = 200
//immutable.immutableProperty = 200

 

• 타입 프로퍼티
  • 인스턴스에서는 타입 프로퍼티 & 타입 메서드 사용 불가
  • 컴파일 오류

// 타입 프로퍼티 및 메서드
Sample.typeProperty = 300
Sample.typeMethod() // type method

// 인스턴스에서는 타입 프로퍼티나 타입 메서드를
// 사용할 수 없습니다
// 컴파일 오류 발생
//mutable.typeProperty = 400
//mutable.typeMethod()

# C에서의 구조체와 다르게 인스턴스 메소드가 존재한다.

2. 클래스

• 클래스는 참조(reference) 타입입니다.
• 타입이름은 대문자 카멜케이스를 사용하여 정의합니다.
• Swift의 클래스는 다중 상속이 되지 않습니다.

class Sample {
    // 가변 프로퍼티
    var mutableProperty: Int = 100 

    // 불변 프로퍼티
    let immutableProperty: Int = 100 
    
    // 타입 프로퍼티
    static var typeProperty: Int = 100 
    
    // 인스턴스 메서드
    func instanceMethod() {
        print("instance method")
    }
    

    // 타입 메서드
    // 상속시 재정의 불가 타입 메서드 - static
    static func typeMethod() {
        print("type method - static")
    }
    
    // 상속시 재정의 가능 타입 메서드 - class
    class func classMethod() {
        print("type method - class")
    }
}

• 타입 메서드
  1. static func
     상속 시 재정의가 불가능한 메서드
  2. class func
     상속 시 재정의가 가능한 타입 메서드
• let 으로 선언된 클래스의 인스턴스도 인스턴스 프로퍼티 값 변경 가능
• 불변 인스턴스는 수정 불가

3. 열거형

 Swift 열거형은 다른 언어의 열거형과 많이 다릅니다. 강력한 기능을 지니고 있어 잘 알아두고 사용하면 좋습니다.

• 유사한 종류의 여러 값을 한 곳에 모아서 정의한 것입니다. 예) 요일, 월, 계절 등
• enum 자체가 하나의 데이터 타입으로, 대문자 카멜케이스를 사용하여 이름을 정의합니다.
• 각 case는 소문자 카멜케이스로 정의합니다.
• 각 case는 그 자체가 고유의 값입니다.(각 case에 자동으로 정수값이 할당되지 않음 -> 할당할 수 있음, case 별로 다른 값)
• 각 case는 한 줄에 개별로도, 한 줄에 여러개도 정의할 수 있습니다.

3.1 열거형 사용

타입이 명확한 경우, 열거형 이름 생략하여 사용 가능 (switch 구문)

enum Weekday {
    case mon
    case tue
    case wed
    case thu, fri, sat, sun
}

// 열거형 타입과 케이스를 모두 사용하여도 됩니다
var day: Weekday = Weekday.mon

// 타입이 명확하다면 .케이스 처럼 표현해도 무방합니다
day = .tue

print(day) // tue

// switch의 비교값에 열거형 타입이 위치할 때
// 모든 열거형 케이스를 포함한다면
// default를 작성할 필요가 없습니다
switch day {
case .mon, .tue, .wed, .thu:
    print("평일입니다")
case Weekday.fri:
    print("불금 파티!!")
case .sat, .sun:
    print("신나는 주말!!")
}

3.2 rawValue (원시값)

• C 언어의 enum 처럼 정수값을 가질 수 있다.
• rawValue는 case 별로 각각 다른 값을 가져야 한다.
• 자동으로 1이 증가된 값이 할당
• 꼭 필요하지 않으면 없어도 됨

enum Fruit: Int {
    case apple = 0
    case grape = 1
    case peach
    
    // mango와 apple의 원시값이 같으므로 
    // mango 케이스의 원시값을 0으로 정의할 수 없습니다
//    case mango = 0
}

print("Fruit.peach.rawValue == \(Fruit.peach.rawValue)")
// Fruit.peach.rawValue == 2

 

• Hashable 프로토콜을 따르는 모든 타입을 원시값의 타입으로 지정할 수 있다.
• 원시값 타입이 String인데 지정되지 않은 경우, case 이름을 값으로 사용

enum School: String {
    case elementary = "초등"
    case middle = "중등"
    case high = "고등"
    case university
}

print("School.middle.rawValue == \(School.middle.rawValue)")
// School.middle.rawValue == 중등

// 열거형의 원시값 타입이 String일 때, 원시값이 지정되지 않았다면
// case의 이름을 원시값으로 사용합니다
print("School.university.rawValue == \(School.university.rawValue)")
// School.middle.rawValue == university

3.3 원시값을 통한 초기화

• rawValue를 통해 초기화 할 수 있습니다.
• rawValue가 case에 해당하지 않을 수 있으므로, rawValue를 통해 초기화 한 인스턴스는 옵셔널 타입입니다.

// rawValue를 통해 초기화 한 열거형 값은 옵셔널 타입이므로 Fruit 타입이 아닙니다
//let apple: Fruit = Fruit(rawValue: 0)
let apple: Fruit? = Fruit(rawValue: 0)

// if let 구문을 사용하면 rawValue에 해당하는 케이스를 곧바로 사용할 수 있습니다
if let orange: Fruit = Fruit(rawValue: 5) {
    print("rawValue 5에 해당하는 케이스는 \(orange)입니다")
} else {
    print("rawValue 5에 해당하는 케이스가 없습니다")
} // rawValue 5에 해당하는 케이스가 없습니다

3.4 메서드 추가

enum Month {
    case dec, jan, feb
    case mar, apr, may
    case jun, jul, aug
    case sep, oct, nov
    
    func printMessage() {
        switch self {
        case .mar, .apr, .may:
            print("따스한 봄~")
        case .jun, .jul, .aug:
            print("여름 더워요~")
        case .sep, .oct, .nov:
            print("가을은 독서의 계절!")
        case .dec, .jan, .feb:
            print("추운 겨울입니다")
        }
    }
}

Month.mar.printMessage()

 

3.5 enum 타입 for 문에서 사용하기

enum 타입에서 CaseIterable 프로토콜 채택

enum Suits : CaseIterable {
    case heart
    case spade
}

for suit in Suits.allCases {}

 

4. 클래스 vs 구조체 / 열거형

• 클래스는 참조 타입, 열거형과 구조체는 값 타입이라는 것이 가장 큰 차이입니다.
• 클래스는 상속이 가능하지만, 열거형과 구조체는 상속이 불가능 합니다.

클래스 Class	구조체 struct	열거형 Enum
- 전통적인 OOP 관점 - 단일 상속 - (인스턴스/타입) 메서드 - (인스턴스/타입) 프로퍼티 < 참조 타입 > - Apple 프레임워크 큰 뼈대는 클래스	- C 언어 구조체보다 다양한 기능 - 상속 불가 - (인스턴스/타입) 메서드 - (인스턴스/타입) 프로퍼티 < 값 타입 > - Swift 큰 뼈대는 구조체	- 다른 언어의 열거형과는 많이 다름 - 상속 불가 - (인스턴스/타입) 메서드 - (인스턴스/타입) 연산 프로퍼티 < 값 타입 > - 열거형 자체가 하나의 데이터 타입 case 하나하나 전부 하나의 유의미한 값으로 취급
Extension 가능

4.1 구조체 사용

• 연관된 몇몇의 값들을 모아서 하나의 데이터 타입으로 표현하고 싶을 때
• 다른 객체 또는 함수 등으로 전달될 때, 참조가 아닌 복사를 원할 때
• 상속할 필요, 상속 받을 필요 없을 때

4.2 Value vs Reference

• Value
  • 값을 복사하여 데이터 전달
• Reference
  • 값의 메모리 위치를 전달

struct ValueType {
    var property = 1
}

class ReferenceType {
    var property = 1
}

// 첫 번째 구조체 인스턴스
let firstStructInstance = ValueType()

// 두 번째 구조체 인스턴스에 첫 번째 인스턴스 값 복사
var secondStructInstance = firstStructInstance

// 두 번째 구조체 인스턴스 프로퍼티 값 수정
secondStructInstance.property = 2

// 두 번째 구조체 인스턴스는 첫 번째 구조체를 똑같이 복사한 
// 별도의 인스턴스이기 때문에 
// 두 번째 구조체 인스턴스의 프로퍼티 값을 변경해도
// 첫 번째 구조체 인스턴스의 프로퍼티 값에는 영향이 없음
print("first struct instance property : \(firstStructInstance.property)")    // 1
print("second struct instance property : \(secondStructInstance.property)")  // 2


// 클래스 인스턴스 생성 후 첫 번째 참조 생성
let firstClassReference = ReferenceType()
// 두 번째 참조 변수에 첫 번째 참조 할당
let secondClassReference = firstClassReference
secondClassReference.property = 2

// 두 번째 클래스 참조는 첫 번째 클래스 인스턴스를 참조하기 때문에
// 두 번째 참조를 통해 인스턴스의 프로퍼티 값을 변경하면
// 첫 번째 클래스 인스턴스의 프로퍼티 값을 변경하게 됨
print("first class reference property : \(firstClassReference.property)")    // 2
print("second class reference property : \(secondClassReference.property)")  // 2

useyourloaf.com/blog/getting-all-cases-of-an-enum/