'프로그래밍'에 해당되는 글 23건

  1. 2017.07.31 기본문법을 마치며...
  2. 2017.07.27 고차함수
  3. 2017.07.20 익스텐션
  4. 2017.07.17 프로토콜
  5. 2017.07.13 assert와 guard
  6. 2017.07.10 타입캐스팅 (2)
  7. 2017.07.06 옵셔널 체이닝 (2)
  8. 2017.07.03 인스턴스의 생성과 소멸
  9. 2017.06.23 Swift 4 변경사항 (10)
  10. 2017.06.22 클로저 - Closure
  11. 2017.06.15 열거형 - Enumerations
  12. 2017.06.12 클래스
  13. 2017.03.24 스위프트 프로그래밍 (2)
  14. 2013.01.09 파헤치기 #5. iOS App Programming Guide (5) App States and Multitasking <1> (12)
  15. 2012.05.24 C <20>. enum (4)
  16. 2012.05.21 C <18>. 연결리스트 (Linked list) - 자료구조(1)
  17. 2012.05.18 C <17>. 동적할당 (2)
  18. 2012.05.16 C <16>. 구조체 (2)
  19. 2012.05.11 C <14>. 배열 (4)
  20. 2011.12.14 C <7>. 조건문(2) switch (6)

더 알아보기

이제까지 포스팅한 내용 외에 추가적으로 알아가야 할 문법과 개념들을 모아봤습니다.

  • 제네릭(Generics)
  • 서브스크립트(Subscript)
  • 접근수준(Access Control)
  • ARC(Automatic Reference Counting)
  • 중첩타입(Nested Types)
  • 사용자정의 연산자(Custom Operators)

스위프트 기본문법 강좌는 여기서 마칩니다. 많은 도움이 되었길 소망합니다.


yagom  



관련저서


스위프트 프로그래밍 - 야곰 지음 (한빛미디어)

http://book.naver.com/bookdb/book_detail.nhn?bid=11445773





by yagom

facebook : http://www.facebook.com/yagomSoft

facebook group : https://www.facebook.com/groups/yagom/


p.s 제 포스팅을 RSS 피드로 받아보실 수 있습니다.

RSS Feed 받기   


↓↓↓ 블로거에게 공감은 큰 힘이 됩니다 ↓↓↓ 

저작자 표시 비영리 변경 금지
신고

'Swift > 기본문법' 카테고리의 다른 글

기본문법을 마치며...  (0) 2017.07.31
고차함수  (0) 2017.07.27
오류처리  (0) 2017.07.24
익스텐션  (0) 2017.07.20
프로토콜  (0) 2017.07.17
assert와 guard  (0) 2017.07.13
Posted by yagom

고차함수

Swift/기본문법 2017.07.27 11:00

고차함수

고차함수(Higher-order function)은 '다른 함수를 전달인자로 받거나 함수실행의 결과를 함수로 반환하는 함수'를 뜻합니다.

스위프트의 함수(클로저)는 일급시민(first-citizen)이기 때문에 함수의 전달인자로 전달할 수 있으며, 함수의 결과값으로 반환할 수 있습니다.


이번 파트에서는 스위프트 표준라이브러리에서 제공하는 유용한 고차함수에 대해 알아봅니다.

  • map
  • filter
  • reduce

map, filter, reduce 함수는 스위프트 표준 라이브러리의 컨테이너 타입(Array, Set, Dictionary 등)에 구현되어 있습니다.


소스코드



map

map함수(메서드)는 컨테이너 내부의 기존 데이터를 변형(transform)하여 새로운 컨테이너를 생성합니다.


> 변형하고자 하는 numbers와 변형 결과를 받을 doubledNumbers, strings

let numbers: [Int] = [0, 1, 2, 3, 4]
var doubledNumbers: [Int]
var strings: [String]


> for 구문 사용

doubledNumbers = [Int]()
strings = [String]()

for number in numbers {
    doubledNumbers.append(number * 2)
    strings.append("\(number)")
}

print(doubledNumbers) // [0, 2, 4, 6, 8]
print(strings) // ["0", "1", "2", "3", "4"]


> map 메서드 사용

// numbers의 각 요소를 2배하여 새로운 배열 반환
doubledNumbers = numbers.map({ (number: Int) -> Int in
    return number * 2
})

// numbers의 각 요소를 문자열로 변환하여 새로운 배열 반환
strings = numbers.map({ (number: Int) -> String in
    return "\(number)"
})

print(doubledNumbers) // [0, 2, 4, 6, 8]
print(strings) // ["0", "1", "2", "3", "4"]

// 매개변수, 반환 타입, 반환 키워드(return) 생략, 후행 클로저
doubledNumbers = numbers.map { $0 * 2 }
print(doubledNumbers) // [0, 2, 4, 6, 8]


filter

filter함수(메서드)는 컨테이너 내부의 값을 걸러서 새로운 컨테이너로 추출합니다.


> for 구문 사용

// 변수 사용에 주목하세요
var filtered: [Int] = [Int]()

for number in numbers {
    if number % 2 == 0 {
        filtered.append(number)
    }
}

print(filtered) // [0, 2, 4]


> filter 메서드 사용

// numbers의 요소 중 짝수를 걸러내어 새로운 배열로 반환
let evenNumbers: [Int] = numbers.filter { (number: Int) -> Bool in
    return number % 2 == 0
}
print(evenNumbers) // [0, 2, 4]

// 매개변수, 반환 타입, 반환 키워드(return) 생략, 후행 클로저
let oddNumbers: [Int] = numbers.filter {
    $0 % 2 != 0
}
print(oddNumbers) // [1, 3]



reduce

reduce함수(메서드)는 컨테이너 내부의 콘텐츠를 하나로 통합합니다.


> 통합하고자 하는 someNumbers

let someNumbers: [Int] = [2, 8, 15]


> for 구문 사용

// 변수 사용에 주목하세요
var result: Int = 0

// someNumbers의 모든 요소를 더합니다
for number in someNumbers {
    result += number
}

print(result) // 25


> reduce 메서드 사용

// 초깃값이 0이고 someNumbers 내부의 모든 값을 더합니다.
let sum: Int = someNumbers.reduce(0, { (first: Int, second: Int) -> Int in
    //print("\(first) + \(second)") //어떻게 동작하는지 확인해보세요
    return first + second
})

print(sum)  // 25

// 초깃값이 0이고 someNumbers 내부의 모든 값을 뺍니다.
var subtract: Int = someNumbers.reduce(0, { (first: Int, second: Int) -> Int in
    //print("\(first) - \(second)") //어떻게 동작하는지 확인해보세요
    return first - second
})

print(subtract) // -25

// 초깃값이 3이고 someNumbers 내부의 모든 값을 더합니다.
let sumFromThree = someNumbers.reduce(3) { $0 + $1 }

print(sumFromThree) // 28



더 알아보기

flatmap








by yagom

facebook : http://www.facebook.com/yagomSoft

facebook group : https://www.facebook.com/groups/yagom/


p.s 제 포스팅을 RSS 피드로 받아보실 수 있습니다.

RSS Feed 받기   


↓↓↓ 블로거에게 공감은 큰 힘이 됩니다 ↓↓↓ 

저작자 표시 비영리 변경 금지
신고

'Swift > 기본문법' 카테고리의 다른 글

기본문법을 마치며...  (0) 2017.07.31
고차함수  (0) 2017.07.27
오류처리  (0) 2017.07.24
익스텐션  (0) 2017.07.20
프로토콜  (0) 2017.07.17
assert와 guard  (0) 2017.07.13
Posted by yagom

익스텐션

Swift/기본문법 2017.07.20 15:59

익스텐션

익스텐션(Extension) 은 스위프트의 강력한 기능 중 하나입니다. 익스텐션은 구조체, 클래스, 열거형, 프로토콜 타입에 새로운 기능을 추가 할 수 있는 기능입니다. 

기능을 추가하려는 타입의 구현된 소스 코드를 알지 못하거나 볼 수 없다 해도, 타입만 알고 있다면 그 타입의 기능을 확장할 수도 있습니다.


스위프트의 익스텐션이 타입에 추가할 수 있는 기능

  • 연산 타입 프로퍼티 / 연산 인스턴스 프로퍼티 
  • 타입 메서드 / 인스턴스 메서드
  • 이니셜라이저
  • 서브스크립트 
  • 중첩 타입
  • 특정 프로토콜을 준수할 수 있도록 기능 추가 


익스텐션은 타입에 새로운 기능을 추가할 수는 있지만, 기존에 존재하는 기능을 재정의 할 수는 없습니다.


클래스의 상속과 익스텐션을 비교해보겠습니다. 이 둘은 비슷해보이지만 실제 성격은 많이 다릅니다. 

클래스의 상속은 클래스 타입에서만 가능하지만 익스텐션은 구조체, 클래스, 프로토콜 등에 적용이 가능합니다. 또 클래스의 상속은 특정 타입을 물려받아 하나의 새로운 타입을 정의하고 추가 기능을 구현하는 수직 확장이지만, 익스텐션은 기존의 타입에 기능을 추가하는 수평 확장입니다. 또, 상속을 받으면 기존 기능을 재정의할 수 있지만, 익스텐션은 재정의할 수 없다는 것도 큰 차이 중 하나입니다. 상황과 용도에 맞게 상속과 익스텐션을 선택하여 사용하면 됩니다. 

 

 상속

익스텐션 

확장 

수직확장 

수평확장 

사용 

클래스 타입 

클래스, 구조체, 프로토콜, 제네릭 등 모든 타입 

재정의 

가능 

불가능 


익스텐션을 사용하는 대신 원래 타입을 정의한 소스에 기능을 추가하는 방법도 있겠지만, 외부 라이브러리나 프레임워크를 가져다 썼다면 원본 소스를 수정하지 못합니다. 이처럼 외부에서 가져온 타입에 내가 원하는 기능을 추가하고자 할 때 익스텐션을 사용합니다. 따로 상속을 받지 않아도 되며, 구조체와 열거형에도 기능을 추가할 수 있으므로 익스텐션은 매우 편리한 기능입니다. 

익스텐션은 모든 타입에 적용할 수 있습니다. 모든 타입이라 함은 구조체, 열거형, 클래스, 프로토콜, 제네릭 타입 등을 뜻합니다. 즉, 익스텐션을 통해 모든 타입에 연산 프로퍼티, 메서드, 이니셜라이저, 서브스크립트, 중첩 데이터 타입 등을 추가할 수 있습니다.

더불어 익스텐션은 프로토콜과 함께 사용하면 굉장히 강력한 기능을 선사합니다. 이 부분은 프로토콜 중심 프로그래밍(Protocol Oriented Programming)에 대해 더 알아보면 좋습니다.


소스코드


정의 문법

extension 키워드를 사용하여 정의합니다.

extension 확장할 타입 이름 {
    /* 타입에 추가될 새로운 기능 구현 */
}


익스텐션은 기존에 존재하는 타입이 추가적으로 다른 프로토콜을 채택할 수 있도록 확장할 수도 있습니다. 이런 경우에는 클래스나 구조체에서 사용하던 것과 똑같은 방법으로 프로토콜 이름을 나열해줍니다.

extension 확장할 타입 이름: 프로토콜1, 프로토콜2, 프로토콜3... {
    /* 프로토콜 요구사항 구현 */
}


스위프트 라이브러리를 살펴보면 실제로 익스텐션이 굉장히 많이 사용되고 있음을 알 수 있습니다. Double 타입에는 수많은 프로퍼티와 메서드, 이니셜라이저가 정의되어 있으며 수많은 프로토콜을 채택하고 있을 것이라고 예상되지만, 실제로 Double 타입의 정의를 살펴보면 그 모든것이 다 정의되어 있지는 않습니다. 

그러면 Double 타입이 채택하고 준수해야 하는 수많은 프로토콜은 어디로 갔을까요? 어디에서 채택하고 어디에서 준수하도록 정의되어 있을까요? 당연히 답은 익스텐션입니다. 이처럼 스위프트 표준 라이브러리 타입의 기능은 대부분 익스텐션으로 구현되어 있습니다. Double 외에도 다른 타입들의 정의와 익스텐션을 찾아보면 더 많은 예를 보실 수 있습니다. 꼭 한 번 찾아보세요! 


익스텐션 구현

연산 프로퍼티 추가

extension Int {
    var isEven: Bool {
        return self % 2 == 0
    }
    var isOdd: Bool {
        return self % 2 == 1
    }
}

print(1.isEven) // false
print(2.isEven) // true
print(1.isOdd)  // true
print(2.isOdd)  // false

var number: Int = 3
print(number.isEven) // false
print(number.isOdd) // true

number = 2
print(number.isEven) // true
print(number.isOdd) // false

위 코드의 익스텐션은 Int 타입에 두 개의 연산 프로퍼티를 추가한 것입니다. Int 타입의 인스턴스가 홀수인지 짝수인지 판별하여 Bool 타입으로 알려주는 연산 프로퍼티입니다. 익스텐션으로 Int 타입에 추가해준 연산 프로퍼티는 Int 타입의 어떤 인스턴스에도 사용이 가능합니다. 위의 코드처럼 인스턴스 연산 프로퍼티를 추가할 수도 있으며, static 키워드를 사용하여 타입 연산 프로퍼티도 추가할 수 있습니다. 


메서드 추가

extension Int {
    func multiply(by n: Int) -> Int {
        return self * n
    }
}
print(3.multiply(by: 2))  // 6
print(4.multiply(by: 5))  // 20

number = 3
print(number.multiply(by: 2))   // 6
print(number.multiply(by: 3))   // 9

위 코드의 익스텐션을 통해 Int 타입에 인스턴스 메서드multiply(by:) 메서드를 추가했습니다. 여러 기능을 여러 익스텐션 블록으로 나눠서 구현해도 전혀 문제가 없습니다. 관련된 기능별로 하나의 익스텐션 블록에 묶어주는 것도 좋습니다. 


이니셜라이저 추가

extension String {
    init(int: Int) {
        self = "\(int)"
    }
    
    init(double: Double) {
        self = "\(double)"
    }
}

let stringFromInt: String = String(int: 100) 
// "100"

let stringFromDouble: String = String(double: 100.0)    
// "100.0"

인스턴스를 초기화(이니셜라이즈)할 때 인스턴스 초기화에 필요한 다양한 데이터를 전달받을 수 있도록 여러 종류의 이니셜라이저를 만들 수 있습니다. 타입의 정의부에 이니셜라이저를 추가하지 않더라도 익스텐션을 통해 이니셜라이저를 추가할 수 있습니다. 

하지만 익스텐션으로 클래스 타입에 편의 이니셜라이저는 추가할 수 있지만, 지정 이니셜라이저는 추가할 수 없습니다. 지정 이니셜라이저와 디이니셜라이저는 반드시 클래스 타입의 구현부에 위치해야 합니다(값 타입은 상관없습니다).



관련문서

The Swift Programming Language - Extensions





by yagom

facebook : http://www.facebook.com/yagomSoft

facebook group : https://www.facebook.com/groups/yagom/


p.s 제 포스팅을 RSS 피드로 받아보실 수 있습니다.

RSS Feed 받기   


↓↓↓ 블로거에게 공감은 큰 힘이 됩니다 ↓↓↓ 

저작자 표시 비영리 변경 금지
신고

'Swift > 기본문법' 카테고리의 다른 글

고차함수  (0) 2017.07.27
오류처리  (0) 2017.07.24
익스텐션  (0) 2017.07.20
프로토콜  (0) 2017.07.17
assert와 guard  (0) 2017.07.13
타입캐스팅  (2) 2017.07.10
Posted by yagom

프로토콜

Swift/기본문법 2017.07.17 11:00

프로토콜

프로토콜(Protocol)은 특정 역할을 수행하기 위한 메서드, 프로퍼티, 기타 요구사항 등의 청사진을 정의합니다. 구조체, 클래스, 열거형은 프로토콜을 채택(Adopted)해서 특정 기능을 수행하기 위한 프로토콜의 요구사항을 실제로 구현할 수 있습니다. 어떤 프로토콜의 요구사항을 모두 따르는 타입은 그 프로토콜을 준수한다(Conform)고 표현합니다. 타입에서 프로토콜의 요구사항을 충족시키려면 프로토콜이 제시하는 청사진의 기능을 모두 구현해야 합니다. 

즉, 프로토콜은 기능을 정의하고 제시 할 뿐이지 스스로 기능을 구현하지는 않습니다.


소스코드


정의 문법

protocol 키워드를 사용하여 정의합니다.

protocol 프로토콜 이름 {
    /* 정의부 */
}


프로토콜 구현

protocol Talkable {
    
    // 프로퍼티 요구
    // 프로퍼티 요구는 항상 var 키워드를 사용합니다
    // get은 읽기만 가능해도 상관 없다는 뜻이며
    // get과 set을 모두 명시하면 
    // 읽기 쓰기 모두 가능한 프로퍼티여야 합니다
    var topic: String { get set }
    var language: String { get }
    
    // 메서드 요구
    func talk()
    
    // 이니셜라이저 요구
    init(topic: String, language: String)
}


프로토콜 채택 및 준수

// Person 구조체는 Talkable 프로토콜을 채택했습니다
struct Person: Talkable {
    // 프로퍼티 요구 준수
    var topic: String
    let language: String
    
    // 읽기전용 프로퍼티 요구는 연산 프로퍼티로 대체가 가능합니다
//    var language: String { return "한국어" }
    
    // 물론 읽기, 쓰기 프로퍼티도 연산 프로퍼티로 대체할 수 있습니다
//    var subject: String = ""
//    var topic: String {
//        set {
//            self.subject = newValue
//        }
//        get {
//            return self.subject
//        }
//    }
    
    // 메서드 요구 준수    
    func talk() {
        print("\(topic)에 대해 \(language)로 말합니다")
    }

    // 이니셜라이저 요구 준수    
    init(topic: String, language: String) {
        self.topic = topic
        self.language = language
    }
}


> 프로퍼티 요구는 다양한 방법으로 해석, 구현할 수 있습니다.

struct Person: Talkable {
    var subject: String = ""

    // 프로퍼티 요구는 연산 프로퍼티로 대체가 가능합니다
    var topic: String {
        set {
            self.subject = newValue
        }
        get {
            return self.subject
        }
    }
    
    var language: String { return "한국어" }
    
    func talk() {
        print("\(topic)에 대해 \(language)로 말합니다")
    }
    
    init(topic: String, language: String) {
        self.topic = topic
    }
}



프로토콜 상속

프로토콜은 하나 이상의 프로토콜을 상속받아 기존 프로토콜의 요구사항보다 더 많은 요구사항을 추가할 수 있습니다. 프로토콜 상속 문법은 클래스의 상속 문법과 유사하지만, 프로토콜은 클래스와 다르게 다중상속이 가능합니다.

protocol 프로토콜 이름: 부모 프로토콜 이름 목록 {
 /* 정의부 */
 }


protocol Readable {
    func read()
}
protocol Writeable {
    func write()
}
protocol ReadSpeakable: Readable {
    func speak()
}
protocol ReadWriteSpeakable: Readable, Writeable {
    func speak()
}

struct SomeType: ReadWriteSpeakable {
    func read() {
        print("Read")
    }
    
    func write() {
        print("Write")
    }
    
    func speak() {
        print("Speak")
    }
}


클래스 상속과 프로토콜

클래스에서 상속과 프로토콜 채택을 동시에 하려면 상속받으려는 클래스를 먼저 명시하고 그 뒤에 채택할 프로토콜 목록을 작성합니다.

class SuperClass: Readable { func read() { } } class SubClass: SuperClass, Writeable, ReadSpeakable { func write() { } func speak() { } }


프로토콜 준수 확인

is, as 연산자를 사용해서 인스턴스가 특정 프로토콜을 준수하는지 확인할 수 있습니다.

let sup: SuperClass = SuperClass()
let sub: SubClass = SubClass()

var someAny: Any = sup
someAny is Readable // true
someAny is ReadSpeakable // false

someAny = sub
someAny is Readable // true
someAny is ReadSpeakable // true

someAny = sup

if let someReadable: Readable = someAny as? Readable {
    someReadable.read()
} // read

if let someReadSpeakable: ReadSpeakable = someAny as? ReadSpeakable {
    someReadSpeakable.speak()
} // 동작하지 않음

someAny = sub

if let someReadable: Readable = someAny as? Readable {
    someReadable.read()
} // read



관련문서

The Swift Programming Language - Protocols





by yagom

facebook : http://www.facebook.com/yagomSoft

facebook group : https://www.facebook.com/groups/yagom/


p.s 제 포스팅을 RSS 피드로 받아보실 수 있습니다.

RSS Feed 받기   


↓↓↓ 블로거에게 공감은 큰 힘이 됩니다 ↓↓↓ 

저작자 표시 비영리 변경 금지
신고

'Swift > 기본문법' 카테고리의 다른 글

오류처리  (0) 2017.07.24
익스텐션  (0) 2017.07.20
프로토콜  (0) 2017.07.17
assert와 guard  (0) 2017.07.13
타입캐스팅  (2) 2017.07.10
옵셔널 체이닝  (2) 2017.07.06
Posted by yagom

assertguard

애플리케이션이 동작 도중에 생성하는 다양한 연산 결과값을 동적으로 확인하고 안전하게 처리할 수 있도록 확인하고 빠르게 처리할 수 있습니다.


소스코드


Assertion

assert(_:_:file:line:) 함수를 사용합니다. assert 함수는 디버깅 모드에서만 동작합니다. 배포하는 애플리케이션에서는 제외됩니다. 

주로 디버깅 중 조건의 검증을 위하여 사용합니다.

var someInt: Int = 0

// 검증 조건에 부합하므로 지나갑니다
assert(someInt == 0, "someInt != 0")

someInt = 1
//assert(someInt == 0) // 동작 중지, 검증 실패
//assert(someInt == 0, "someInt != 0") // 동작 중지, 검증 실패
// assertion failed: someInt != 0: file guard_assert.swift, line 26


func functionWithAssert(age: Int?) {
    
    assert(age != nil, "age == nil")
    
    assert((age! >= 0) && (age! <= 130), "나이값 입력이 잘못되었습니다")
    print("당신의 나이는 \(age!)세입니다")
}

functionWithAssert(age: 50)
//functionWithAssert(age: -1) // 동작 중지, 검증 실패
//functionWithAssert(age: nil) // 동작 중지, 검증 실패


assert(_:_:file:line:)와 같은 역할을 하지만 실제 배포 환경에서도 동작하는 precondition(_:_:file:line:) 함수도 있습니다. 함께 살펴보세요.



빠른 종료 - Early Exit

guard를 사용하여 잘못된 값의 전달 시 특정 실행구문을 빠르게 종료합니다. 디버깅 모드 뿐만 아니라 어떤 조건에서도 동작합니다. guardelse 블럭 내부에는 특정 코드블럭을 종료하는 지시어(return, break 등)가 꼭 있어야 합니다. 타입 캐스팅, 옵셔널과도 자주 사용됩니다. 그 외에도 단순 조건 판단 후 빠르게 종료할 때도 용이합니다.

func functionWithGuard(age: Int?) {
    
    guard let unwrappedAge = age,
        unwrappedAge < 130,
        unwrappedAge >= 0 else {
        print("나이값 입력이 잘못되었습니다")
        return
    }
    
    print("당신의 나이는 \(unwrappedAge)세입니다")
}

var count = 1

while true {
    guard count < 3 else {
        break
    }
    print(count)
    count += 1
}
// 1
// 2


func someFunction(info: [String: Any]) {
    guard let name = info["name"] as? String else {
        return
    }
    
    guard let age = info["age"] as? Int, age >= 0 else {
        return
    }
    
    print("\(name): \(age)")
    
}

someFunction(info: ["name": "jenny", "age": "10"])
someFunction(info: ["name": "mike"])
someFunction(info: ["name": "yagom", "age": 10]) // yagom: 10


관련문서

* The Swift Programming Language - Control Flow - Early Exit

* The Swift Programming Language - The Basics - Assertion





by yagom

facebook : http://www.facebook.com/yagomSoft

facebook group : https://www.facebook.com/groups/yagom/


p.s 제 포스팅을 RSS 피드로 받아보실 수 있습니다.

RSS Feed 받기   


↓↓↓ 블로거에게 공감은 큰 힘이 됩니다 ↓↓↓ 


저작자 표시 비영리 변경 금지
신고

'Swift > 기본문법' 카테고리의 다른 글

익스텐션  (0) 2017.07.20
프로토콜  (0) 2017.07.17
assert와 guard  (0) 2017.07.13
타입캐스팅  (2) 2017.07.10
옵셔널 체이닝  (2) 2017.07.06
인스턴스의 생성과 소멸  (0) 2017.07.03
Posted by yagom

타입캐스팅

스위프트의 타입캐스팅은 인스턴스의 타입을 확인하는 용도 또는 클래스의 인스턴스를 부모 혹은 자식 클래스의 타입으로 사용할 수 있는지 확인하는 용도로 사용합니다. is, as를 사용합니다.


소스코드


타입 캐스팅 예제를 위한 클래스 정의

class Person {
    var name: String = ""
    func breath() {
        print("숨을 쉽니다")
    }
}

class Student: Person {
    var school: String = ""
    func goToSchool() {
        print("등교를 합니다")
    }
}

class UniversityStudent: Student {
    var major: String = ""
    func goToMT() {
        print("멤버쉽 트레이닝을 갑니다 신남!")
    }
}


예제를 위한 인스턴스 생성

var yagom: Person = Person()
var hana: Student = Student()
var jason: UniversityStudent = UniversityStudent()


타입 확인

is를 사용하여 타입을 확인합니다.

var result: Bool

result = yagom is Person // true
result = yagom is Student // false
result = yagom is UniversityStudent // false

result = hana is Person // true
result = hana is Student // true
result = hana is UniversityStudent // false

result = jason is Person // true
result = jason is Student // true
result = jason is UniversityStudent // true

if yagom is UniversityStudent {
    print("yagom은 대학생입니다")
} else if yagom is Student {
    print("yagom은 학생입니다")
} else if yagom is Person {
    print("yagom은 사람입니다")
} // yagom은 사람입니다

switch jason {
case is Person:
    print("jason은 사람입니다")
case is Student:
    print("jason은 학생입니다")
case is UniversityStudent:
    print("jason은 대학생입니다")
default:
    print("jason은 사람도, 학생도, 대학생도 아닙니다")
} // jason은 사람입니다

switch jason {
case is UniversityStudent:
    print("jason은 대학생입니다")
case is Student:
    print("jason은 학생입니다")
case is Person:
    print("jason은 사람입니다")
default:
    print("jason은 사람도, 학생도, 대학생도 아닙니다")
} // jason은 대학생입니다


업 캐스팅

as를 사용하여 부모클래스의 인스턴스로 사용할 수 있도록 컴파일러에게 타입정보를 전환해줍니다. Any 혹은 AnyObject로도 타입정보를 변환할 수 있습니다. 암시적으로 처리되므로 꼭 필요한 경우가 아니라면 생략해도 무방합니다.

// UniversityStudent 인스턴스를 생성하여 Person 행세를 할 수 있도록 업 캐스팅
var mike: Person = UniversityStudent() as Person

var jenny: Student = Student()
//var jina: UniversityStudent = Person() as UniversityStudent // 컴파일 오류

// UniversityStudent 인스턴스를 생성하여 Any 행세를 할 수 있도록 업 캐스팅
var jina: Any = Person() // as Any 생략가능


다운 캐스팅

as? 또는 as!를 사용하여 자식 클래스의 인스턴스로 사용할 수 있도록 컴파일러에게 인스턴스의 타입정보를 전환해줍니다.


조건부 다운 캐스팅

as?를 사용합니다. 캐스팅에 실패하면, 즉 캐스팅하려는 타입에 부합하지 않는 인스턴스라면 nil을 반환하기 때문에 결과의 타입은 옵셔널 타입입니다.

var optionalCasted: Student?

optionalCasted = mike as? UniversityStudent
optionalCasted = jenny as? UniversityStudent // nil
optionalCasted = jina as? UniversityStudent // nil
optionalCasted = jina as? Student // nil


강제 다운 캐스팅

as!를 사용합니다. 캐스팅에 실패하면, 즉 캐스팅하려는 타입에 부합하지 않는 인스턴스라면 런타임 오류가 발생합니다. 캐스팅에 성공하면 옵셔널이 아닌 일반 타입을 반환합니다.

var forcedCasted: Student

optionalCasted = mike as! UniversityStudent
//optionalCasted = jenny as! UniversityStudent // 런타임 오류
//optionalCasted = jina as! UniversityStudent // 런타임 오류
//optionalCasted = jina as! Student // 런타임 오류


활용

func doSomethingWithSwitch(someone: Person) {
    switch someone {
    case is UniversityStudent:
        (someone as! UniversityStudent).goToMT()
    case is Student:
        (someone as! Student).goToSchool()
    case is Person:
        (someone as! Person).breath()
    }
}

doSomethingWithSwitch(someone: mike as Person) // 멤버쉽 트레이닝을 갑니다 신남!
doSomethingWithSwitch(someone: mike) // 멤버쉽 트레이닝을 갑니다 신남!
doSomethingWithSwitch(someone: jenny) // 등교를 합니다
doSomethingWithSwitch(someone: yagom) // 숨을 쉽니다


func doSomething(someone: Person) {
    if let universityStudent = someone as? UniversityStudent {
        universityStudent.goToMT()
    } else if let student = someone as? Student {
        student.goToSchool()
    } else if let person = someone as? Person {
        person.breath()
    }
}

doSomething(someone: mike as Person) // 멤버쉽 트레이닝을 갑니다 신남!
doSomething(someone: mike) // 멤버쉽 트레이닝을 갑니다 신남!
doSomething(someone: jenny) // 등교를 합니다
doSomething(someone: yagom) // 숨을 쉽니다


관련문서

The Swift Programming Language - Type Casting





by yagom

facebook : http://www.facebook.com/yagomSoft

facebook group : https://www.facebook.com/groups/yagom/


p.s 제 포스팅을 RSS 피드로 받아보실 수 있습니다.

RSS Feed 받기   


↓↓↓ 블로거에게 공감은 큰 힘이 됩니다 ↓↓↓ 

저작자 표시 비영리 변경 금지
신고

'Swift > 기본문법' 카테고리의 다른 글

프로토콜  (0) 2017.07.17
assert와 guard  (0) 2017.07.13
타입캐스팅  (2) 2017.07.10
옵셔널 체이닝  (2) 2017.07.06
인스턴스의 생성과 소멸  (0) 2017.07.03
상속  (0) 2017.06.29
Posted by yagom

옵셔널 체이닝

옵셔널 체이닝은 옵셔널의 내부의 내부의 내부로 옵셔널이 연결되어 있을 때 유용하게 활용할 수 있습니다. 매 번 nil 확인을 하지 않고 최종적으로 원하는 값이 있는지 없는지 확인할 수 있습니다. 


소스코드


예제 클래스

class Person {
    var name: String
    var job: String?
    var home: Apartment?
    
    init(name: String) {
        self.name = name
    }
}

class Apartment {
    var buildingNumber: String
    var roomNumber: String
    var `guard`: Person?
    var owner: Person?
    
    init(dong: String, ho: String) {
        buildingNumber = dong
        roomNumber = ho
    }
}


옵셔널 체이닝 사용

let yagom: Person? = Person(name: "yagom")
let apart: Apartment? = Apartment(dong: "101", ho: "202")
let superman: Person? = Person(name: "superman")


// 옵셔널 체이닝이 실행 후 결과값이 nil일 수 있으므로
// 결과 타입도 옵셔널입니다

// 만약 우리집의 경비원의 직업이 궁금하다면..?

// 옵셔널 체이닝을 사용하지 않는다면...
func guardJob(owner: Person?) {
    if let owner = owner {
        if let home = owner.home {
            if let `guard` = home.guard {
                if let guardJob = `guard`.job {
                    print("우리집 경비원의 직업은 \(guardJob)입니다")
                } else {
                    print("우리집 경비원은 직업이 없어요")
                }
            }
        }
    }
}

guardJob(owner: yagom)

// 옵셔널 체이닝을 사용한다면
func guardJobWithOptionalChaining(owner: Person?) {
    if let guardJob = owner?.home?.guard?.job {
        print("우리집 경비원의 직업은 \(guardJob)입니다")
    } else {
        print("우리집 경비원은 직업이 없어요")
    }
}

guardJobWithOptionalChaining(owner: yagom)
// 우리집 경비원은 직업이 없어요



yagom?.home?.guard?.job // nil

yagom?.home = apart

yagom?.home // Optional(Apartment)
yagom?.home?.guard // nil

yagom?.home?.guard = superman

yagom?.home?.guard // Optional(Person)

yagom?.home?.guard?.name // superman
yagom?.home?.guard?.job // nil

yagom?.home?.guard?.job = "경비원"




nil 병합 연산자

중위 연산자입니다. ??

예) Optional ??  Value


옵셔널 값이 nil일 경우, 우측의 값을 반환합니다. 

띄어쓰기에 주의하여야 합니다.

var guardJob: String
    
guardJob = yagom?.home?.guard?.job ?? "슈퍼맨"
print(guardJob) // 경비원

yagom?.home?.guard?.job = nil

guardJob = yagom?.home?.guard?.job ?? "슈퍼맨"
print(guardJob) // 슈퍼맨



관련문서

* The Swift Programming Language - Optional Chaining

* The Swift Programming Language - Basic Operators - Nil-Coalescing Operator





by yagom

facebook : http://www.facebook.com/yagomSoft

facebook group : https://www.facebook.com/groups/yagom/


p.s 제 포스팅을 RSS 피드로 받아보실 수 있습니다.

RSS Feed 받기   


↓↓↓ 블로거에게 공감은 큰 힘이 됩니다 ↓↓↓ 

저작자 표시 비영리 변경 금지
신고

'Swift > 기본문법' 카테고리의 다른 글

assert와 guard  (0) 2017.07.13
타입캐스팅  (2) 2017.07.10
옵셔널 체이닝  (2) 2017.07.06
인스턴스의 생성과 소멸  (0) 2017.07.03
상속  (0) 2017.06.29
프로퍼티 - Property  (2) 2017.06.26
Posted by yagom

인스턴스의 생성과 소멸

인스턴스를 생성하는 이니셜라이저와 클래스의 인스턴스가 소멸될 때 호출되는 디이니셜라이저 그리고 그와 관련된 것들에 대해 알아봅니다.

  • 프로퍼티 초기값
  • 이니셜라이저 init
  • 디이니셜라이저 deinit


소스코드



프로퍼티 기본값

스위프트의 모든 인스턴스는 초기화와 동시에 모든 프로퍼티에 유효한 값이 할당되어 있어야 합니다.
프로퍼티에 미리 기본값을 할당해두면 인스턴스가 생성됨과 동시에 초기값을 지니게 됩니다.

class PersonA {
    // 모든 저장 프로퍼티에 기본값 할당
    var name: String = "unknown"
    var age: Int = 0
    var nickName: String = "nick"
}

// 인스턴스 생성
let jason: PersonA = PersonA()

// 기본값이 인스턴스가 지녀야 할 값과 맞지 않다면
// 생성된 인스턴스의 프로퍼티에 각각 값 할당
jason.name = "jason"
jason.age = 30
jason.nickName = "j"


이니셜라이저

프로퍼티 기본값을 지정하기 어려운 경우에는 이니셜라이저 init을 통해 인스턴스가 가져야 할 초기값을 전달할 수 있습니다.

class PersonB {
    var name: String
    var age: Int
    var nickName: String
    
    // 이니셜라이저
    init(name: String, age: Int, nickName: String) {
        self.name = name
        self.age = age
        self.nickName = nickName
    }
}

let hana: PersonB = PersonB(name: "hana", age: 20, nickName: "하나")


> 프로퍼티의 초기값이 꼭 필요 없을 때 

옵셔널을 사용!

class PersonC {
    var name: String
    var age: Int
    var nickName: String?
    
    init(name: String, age: Int, nickName: String) {
        self.name = name
        self.age = age
        self.nickName = nickName
    }
    
    init(name: String, age: Int) {
        self.name = name
        self.age = age
    }
}

let jenny: PersonC = PersonC(name: "jenny", age: 10)
let mike: PersonC = PersonC(name: "mike", age: 15, nickName: "m")


암시적 추출 옵셔널은 인스턴스 사용에 꼭 필요하지만 초기값을 할당하지 않고자 할 때 사용

class Puppy {
    var name: String
    var owner: PersonC!
    
    init(name: String) {
        self.name = name
    }
    
    func goOut() {
        print("\(name)가 주인 \(owner.name)와 산책을 합니다")
    }
}

let happy: Puppy = Puppy(name: "happy")
// 강아지는 주인없이 산책하면 안돼요!
//happy.goOut() // 주인이 없는 상태라 오류 발생
happy.owner = jenny
happy.goOut()
// happy가 주인 jenny와 산책을 합니다


실패가능한 이니셜라이저

이니셜라이저 매개변수로 전달되는 초기값이 잘못된 경우 인스턴스 생성에 실패할 수 있습니다. 인스턴스 생성에 실패하면 nil을 반환합니다. 그래서 실패가능한 이니셜라이저의 반환타입은 옵셔널 타입입니다. init?을 사용합니다.

class PersonD {
    var name: String
    var age: Int
    var nickName: String?
    
    init?(name: String, age: Int) {
        if (0...120).contains(age) == false {
            return nil
        }
        
        if name.characters.count == 0 {
            return nil
        }
        
        self.name = name
        self.age = age
    }
}

//let john: PersonD = PersonD(name: "john", age: 23)
let john: PersonD? = PersonD(name: "john", age: 23)
let joker: PersonD? = PersonD(name: "joker", age: 123)
let batman: PersonD? = PersonD(name: "", age: 10)

print(joker) // nil
print(batman) // nil


디이니셜라이저

deinit은 클래스의 인스턴스가 메모리에서 해제되는 시점에 호출됩니다. 인스턴스가 해제되는 시점에 해야할 일을 구현할 수 있습니다. 자동으로 호출되므로 직접 호출할 수 없습니다. 인스턴스가 메모리에서 해제되는 시점은 ARC(Automatic Reference Counting) 의 규칙에 따라 결정됩니다. ARC에 대해 더 자세한 사항은 ARC 문서를 참고하세요.

디이니셜라이저는 클래스 타입에만 구현할 수 있습니다.

class PersonE {
    var name: String
    var pet: Puppy?
    var child: PersonC
    
    init(name: String, child: PersonC) {
        self.name = name
        self.child = child
    }
    
    // 인스턴스가 메모리에서 해제되는 시점에 자동 호출
    deinit {
        if let petName = pet?.name {
            print("\(name)가 \(child.name)에게 \(petName)를 인도합니다")
            self.pet?.owner = child
        }
    }
}

var donald: PersonE? = PersonE(name: "donald", child: jenny)
donald?.pet = happy
donald = nil // donald 인스턴스가 더이상 필요없으므로 메모리에서 해제됩니다
// donald가 jenny에게 happy를 인도합니다



관련문서

* The Swift Programming Language - Initialization

* The Swift Programming Language - Deinitialization

* The Swift Programming Language - Automatic Reference Counting





by yagom

facebook : http://www.facebook.com/yagomSoft

facebook group : https://www.facebook.com/groups/yagom/


p.s 제 포스팅을 RSS 피드로 받아보실 수 있습니다.

RSS Feed 받기   


↓↓↓ 블로거에게 공감은 큰 힘이 됩니다 ↓↓↓ 


저작자 표시 비영리 변경 금지
신고

'Swift > 기본문법' 카테고리의 다른 글

타입캐스팅  (2) 2017.07.10
옵셔널 체이닝  (2) 2017.07.06
인스턴스의 생성과 소멸  (0) 2017.07.03
상속  (0) 2017.06.29
프로퍼티 - Property  (2) 2017.06.26
클로저 - Closure  (0) 2017.06.22
Posted by yagom

Swift 4 변경사항

Swift 2017.06.23 11:00


오늘의 주제

스위프트 4 추가/변경사항


아, 벌써 스위프트가 4번째 버전이 나오네요! 참으로 빠르게 변합니다. 이제 문법적으로 변경되는 부분이 크게 많지 않아서 서 3 버전과 크게 달라진 문법은 많지 않습니다. 내부적으로 수정되거나 추가된 문법이 많고, 삭제된 부분은 거의 없습니다.

긴 말 필요없이 한 번 무엇이 바뀌었는지 살펴볼까요?

스따뚜~~~~~~~~~~~~


단방향 범위 연산자

이제 범위연산자에서 양 쪽 끝을 모두 신경쓸 필요가 없습니다, 야호! [SE-0172]

var numbers = [1, 2, 3, 4, 5]

// Swift 3
numbers[2..<numbers.endIndex] // [3, 4, 5]
numbers[0...2] // [1, 2, 3]
numbers[0..<2] // [1, 2]

// Swift 4
numbers[2...] // [3, 4, 5]
numbers[...2] // [1, 2, 3]
numbers[..<2] // [1, 2]

numbers = []

// Swift 3
//numbers[0...numbers.endIndex] // out of range - error

// Swift 4
numbers[0...] // []


let number: Int = 100

// Swift 3
switch number {
case Int.min..<0:
    print("negative")
case 0:
    print("zero")
case 1...Int.max:
    print("positive")
default:
    print("unknwon")
}


// Swift 4
switch number {
case ..<0:
    print("negative")
case 0:
    print("zero")
case 1...:
    print("positive")
default:
    print("unknwon")
}


 

String의 많은 변화

Swift 4에서 String은 정말 많은 변화가 있는 부분 중 하나입니다. 그 중 눈에 띌만한 내용을 위주로 정리했습니다. 더 많은 사항은 [String Processing For Swift 4] 문서를 참고해보시기 바랍니다.


String 구조체가 다시 Collection 프로토콜을 따릅니다. [SE-0163]

var greeting: String = "Hello, Swift!"

// Swift 3
greeting.characters.forEach { print($0) }
print(greeting.characters.count) // 13

// Swift 4
greeting.forEach { print($0) }
print(greeting.count) // 13


Unicode 9이 적용되었습니다. [String Processing For Swift 4 - Unicode 9 Conformance]

이전에 문자열 길이 결과가 제각각이었던 유니코드 문자들이 사람이 인지할 수 있는 단위로 세어집니다.

// Swift 3
"😍".characters.count // 1
"🇰🇷".characters.count // 1
"🐻".characters.count // 1
"🙌🏻".characters.count // 2
"🙌🏾".characters.count // 2
"‍‍👨‍👨‍👦".characters.count // 3
"‍‍‍👨‍👨‍👦‍👦".characters.count // 4

// Swift 4
"😍".count // 1
"🇰🇷".count // 1
"🐻".count // 1
"🙌🏻".count // 1
"🙌🏾".count // 1
"‍‍👨‍👨‍👦".count // 1
"‍‍‍👨‍👨‍👦‍👦".count // 1


여러 줄 리터럴 문법이 생겼습니다. [SE-0168]

  • 큰따옴표 세 개를 연결하여 표현하면 여러 줄 문자열을 표현하는 리터럴 문법입니다.   
  • 반드시 """ 다음 줄부터 문자열을 입력해야하며, 문자열 마지막 줄 다음줄에 """로 닫아줘야 합니다.

// Swift 3
greeting = "Hello\nHow are you?\nI'm fine thanks, and you?"

// Swift 4
greeting = """
Hello
How are you?
I'm fine thanks, and you?
"""


Substring 타입과 StringProtocol 프로토콜이 생겼습니다.

기존에 String 타입에 구현되어있던 주요 기능을 StringProtocol에 기본구현 하였습니다.

let subIndex = greeting.index(greeting.startIndex, offsetBy: 4)

// Swift 3
let subGreeting = greeting[greeting.startIndex...subIndex]
print(type(of: subGreeting)) // String

// Swift 4
let subGreeting = greeting[...subIndex]
print(type(of: subGreeting)) // Substring
let stringFromSubstring: String = String(subGreeting)


Character 타입에 unicodeScalars 프로퍼티가 추가되었습니다. [SE-0178]

Swift 3에서는 Character 인스턴스의 유니코드 스칼라 값을 알아내려면 String 타입으로 변환하여야 했지만, 이제는 바로 Character 인스턴스의 unicodeScalars 프로퍼티를 이용해 알아낼 수 있습니다.

let character: Character = ""

// Swift 3
print(String(character).unicodeScalars)

// Swift 4
print(character.unicodeScalars)


DictionarySet

자주 사용하는 콜렉션 타입인 DictionarySet의 기능이 한층 강화되었습니다.  

[SE-0154], [SE-0165]


키와 값의 시퀀스를 통해 새로운 딕셔너리를 생성할 수 있습니다. 또, 키와 값을 기존의 딕셔너리에 병합할 수 있습니다.

let zipSequence = zip("abcdefghijklmnopqrstuvwxyz", 97...)
let asciiTable = Dictionary(uniqueKeysWithValues: zipSequence)
// ["w": 119, "n": 110, "u": 117, "v": 118, "x": 120, "q": 113, ...]

let vegetables = ["tomato", "carrot", "onion", "onion", "carrot", "onion"]
let vegetableZipSequence = zip(vegetables, repeatElement(1, count: Int.max))

var vegetableCounts = Dictionary(vegetableZipSequence, uniquingKeysWith: +)
vegetableCounts.merge([("tomato", 1)], uniquingKeysWith: +)
// ["tomato": 2, "carrot": 2, "onion": 3]


DictionarySetfilter 결과가 이제 Array대신 각각의 원래 타입으로 반환됩니다. 또, 딕셔너리는 mapValues(_:) 메서드를 통해 값이 변형된 새로운 딕셔너리를 만들 수 있습니다.

let vowels: Set<Character> = ["a", "e", "i", "o", "u"]
let asciiVowels = asciiTable.filter({ vowels.contains($0.key) })

// Swift 3
print(type(of: asciiVowels)) // Array<(key : Character, value : Int)>

// Swift 4
print(type(of: asciiVowels)) // Dictionary<Character, Int>
asciiVowels["a"]  // 97
asciiVowels["b"]  // nil

let filteredSet: Set<Character> = vowels.filter{ $0 < "h" }

// Swift 3
print(type(of: filteredSet)) // Array<Character>

// Swift 4
print(type(of: filteredSet)) // Set<Character>

// Swift 3
let strangeMap = asciiTable.map { [$0: "0x" + String($1, radix: 16)] }
print(type(of: strangeMap)) // Array<Dictionary<Character, String>>
// [["u": "0x75"], ["v": "0x76"], ["w": "0x77"], ["x": "0x78"], ["q": "0x71"], ["n": "0x6e"], ...]

// Swift 4
let asciiHexTable = asciiTable.mapValues({ "0x" + String($0, radix: 16) })
// ["w": "0x77", "n": "0x6e", "u": "0x75", "v": "0x76", "x": "0x78", ...]


딕셔너리 서브스크립트 문법이 추가되었습니다. 원하는 키에 해당하는 값이 없으면 nil 대신 기본값을 돌려줍니다. 

기본값이 있다는 것은 값이 항상 존재한다는 의미이므로, 해당 서브스크립트의 반환값은 옵셔널이 아닌 값이라는 뜻입니다. 딕셔너리 옵셔널 전쟁에서 해방될 수도!

let favoriteSubject: [String: String] = ["yagom": "swift", "hana": "communication", "jisu": "swift"]

// Swift 3
type(of: favoriteSubject["minji"]) // Optional<String>

// Swift 4
type(of: favoriteSubject["minji"]) // Optional<String>
type(of: favoriteSubject["minji", default: "unknown"]) // String

var favoriteCount = [String: Int]()

favoriteSubject.forEach { favoriteCount[$0.value, default: 0] += 1 }
print(favoriteCount) // ["swift": 2, "communication": 1]


init(grouping:by:) 이니셜라이저를 통해 특정 조건에 따라 Array 또는 다른 시퀀스를 딕셔너리 형태로 그룹지을 수 있습니다. 그룹 기준값은 딕셔너리의 키가 됩니다.

struct Person: CustomStringConvertible {
    enum Gender {
        case male, female, unknwon
    }
    
    let name: String
    var gender: Gender
    
    var description: String { return name }
}

let yagom = Person(name: "yagom", gender: .male)
let hana = Person(name: "hana", gender: .female)
let jisu = Person(name: "jisu", gender: .unknwon)
let eric = Person(name: "eric", gender: .male)
let mike = Person(name: "mike", gender: .male)

let friends = [yagom, hana, jisu, eric, mike]
let friendsByGender = Dictionary(grouping: friends, by: { $0.gender })
print(type(of: friendsByGender))    // Dictionary<Gender, Array<Person>>
print(friendsByGender)
// [Person.Gender.unknwon: [jisu], Person.Gender.male: [yagom, eric, mike], Person.Gender.female: [hana]]


reserveCapacity(_:) 메서드를 통해 Array 처럼 예약된 공간을 가질 수 있습니다.

var emptyDictionary = [String: String]()
print(emptyDictionary.capacity) // 0
emptyDictionary.reserveCapacity(100)
print(emptyDictionary.capacity) // 192
// 최소 100개의 요소가 들어갈 수 있도록 공간을 확보하기 때문에 꼭 100이지 않을 수 있습니다
emptyDictionary.reserveCapacity(10)
print(emptyDictionary.capacity) // 192
emptyDictionary.reserveCapacity(1000)
print(emptyDictionary.capacity) // 1536


Key path

Cocoa에서 단순한 문자열로 표현하던 key path를 스위프트에서는 정확한 타입(KeyPath 라는 제네릭 클래스) 방식으로 표현합니다. 조금 더 안전한 동적 프로그래밍을 할 수 있지 않을까 기대됩니다. [SE-0161]

  • key path를 통하여 프로퍼티에 접근할 수 있도록 모든 타입에 자동으로 [keyPath:] 서브스크립트 메서드가 추가됩니다.
  • key path는 백슬래시(\)를 통해 표현합니다.

struct Person {
    var name: String
}

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


var yagom = Person(name: "yagom")
let macbook = Stuff(name: "macbook pro", owner: yagom)

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

var result: Any = macbook[keyPath: \Stuff.name]
print(result) // macbook pro

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

result = macbook[keyPath: nameKeyPath]
print(result) // yagom

result = macbook[keyPath: \Stuff.owner.name]
print(result) // yagom


프로토콜 혼합 타입

Objective-C 에서 특정 클래스와 프로토콜을 동시에 따르고 있는 타입이라는 의미로 사용되었던 표현이 있습니다. 

SomeClass<SomeProtocol, AnotherProtocol> *name
// SomeProtocol과 AnotherProtocol을 준수하는 SomeClass 타입의 변수 name

이 표현이 이제 스위프트에서도 가능해졌습니다. [SE-0156]

class ClassA { }
class ClassB: ClassA { }
protocol ProtocolA { }
extension ClassB: ProtocolA { }

var someVariable: ClassA & ProtocolA
// someVariable = ClassA()
// 오류발생 : ProtocolA를 충족하지 않음

someVariable = ClassB() // 모든 조건 충족


where 확장

프로토콜과 그 연관 타입에 where 절을 사용하여 타입 제약을 줄 수 있습니다. [SE-0142]

protocol StringRepresentable: RawRepresentable
where RawValue == String { }

protocol RawStringWrapper {
  associatedtype Wrapped: RawRepresentable
    where Wrapper.RawValue == String
}



제네릭 서브스크립트

서브스크립트가 이제 제네릭 매개변수와 반환 타입을 사용할 수 있게 되었습니다. [SE-0148]

struct CustomModel<Key: Hashable, Value> {
    var dictionary: [Key: Value]
    
    subscript<T>(key: Key) -> T? {
        return dictionary[key] as? T
    }
}

let information = CustomModel(dictionary: ["name": "yagom", "age": 100, "height": 183.0])
let name: String? = information["name"] // yagom


Private 접근수준의 변경

기존의 private 접근수준은 같은 파일인 여부와 상관없이 private 요소를 해당 범위를 벗어나면 사용할 수 없었습니다. 대체제로 fileprivate를 사용하였는데, 이는 문제를 야기할 수 있는 가능성을 가지고 있습니다. 같은 파일이라도 접근을 원치 않는 요소가 있는데, extension 등으로 타입을 확장하여 요소를 사용려면 fileprivate로 지정해 주어야 하는 문제가 있었기 때문이죠. 아래 Swift 3의 예를 먼저 보겠습니다.

// Swift 3
struct Person {
    var name: String
    // private로 지정하면 extension에서 접근할 수 없기 때문에 fileprivate로 선언
    fileprivate var age: Int = 0
    init(name: String) {
        self.name = name
    }
}

extension Person {
    mutating func passedYear() {
        self.age += 1
    }
}

var yagom = Person(name: "yagom")
yagom.passedYear()
yagom.age // 접근가능! 원하던 시나리오가 아님!


나이라는 민감한 부분은 숨기고 싶었기 때문에 private로, 어디서든 접근을 막고 싶었지만, 같은 파일의 익스텐션에서 조차 접근할 수 없기 때문에 fileprivate로 접근수준을 지정했습니다. 그 결과, 엉뚱하게 같은 파일의 다른 소스에서도 접근할 수 있게 되었습니다.

// Swift 4

struct Person { var name: String private var age: Int = 0 init(name: String) { self.name = name } } extension Person { mutating func passedYear() { // private라도 같은 파일의 extension에서 접근 가능 self.age += 1 } } var yagom = Person(name: "yagom") yagom.passedYear() // yagom.age // 접근불가

Swift 4에서는 이 문제를 개선하여 같은 파일의 익스텐션에서는 접근할 수 있도록 변경되었습니다.


아카이브와 시리얼라이제이션 / JSON 인코딩

NSCodingNSObject를 손쉽게 사용할 수 있는 클래스 타입을 제외하고, 구조체나 열거타입에서는 아카이빙이 참으로 난해했습니다. 물론 NSObject를 상속받지 않는 스위프트 고유 클래스도 마찬가지였습니다. 그러나 이제 타입이 스스로 어떻게 아카이브하고 시리얼라이즈 할지 정의할 수 있게 되었습니다. 그저 타입과 그 타입의 하위 타입이 모두 Codable 프로토콜을 준수하면 아카이브하고 그것을 풀어낼 수 있도록 할 수 있습니다. 기존에 사용하던 NSKeyedArchiver 클래스도 Codable 프로토콜을 완벽히 지원합니다. Codable과 함께 JSONEncoder, JSONDecoder로 인해 JSON 인코딩과 디코딩이 엄청나게 편해졌습니다!! 으아아아아아아아~!! [SE-0166],  [SE-0167]

struct Person: Codable {
    enum Gender: String, Codable {
        case male, female, unknown
    }
    
    var name: String
    var age: Int
    var gender: Gender
    var friends: [Person]
}

let yagom = Person(name: "yagom", age: 20, gender: .male, friends: [])
let hana = Person(name: "hana", age: 22, gender: .female, friends: [yagom])
let eric = Person(name: "eric", age: 25, gender: .male, friends: [yagom, hana])

var encoder = JSONEncoder()

let jsonData = try encoder.encode(eric)
let jsonString = String(data: jsonData, encoding: .utf8)
print(jsonString) 
// "{\"age\":25,\"gender\":\"male\",\"friends\":[{\"age\":20,\"gender\":\"male\",\"friends\":[],\"name\":\"yagom\"},{\"age\":22,\"gender\":\"female\",\"friends\":[{\"age\":20,\"gender\":\"male\",\"friends\":[],\"name\":\"yagom\"}],\"name\":\"hana\"}],\"name\":\"eric\"}"

let decoder = JSONDecoder()
let decoded: Person = try decoder.decode(Person.self, from: jsonData)
print(decoded.name) // eric


NSNumber 브릿징

예상치 못한 결과를 낼 수 있는 NSNumber 브릿징 결과가 수정되었습니다.

// Swift 3

let numberOne = NSNumber(value: Int64.max)

if numberOne is Int16 {
    print("numberOne == Int16")
} else if numberOne is Int64 {
    print("numberOne == Int64")
} // numberOne == Int16

let numberTwo = NSNumber(value: UInt32(777))
if let value = numberTwo as? Int8 {
    print(value)
} // 9

// Swift 4
let numberOne = NSNumber(value: Int64.max)

if numberOne is Int16 {
    print("numberOne == Int16")
} else if numberOne is Int64 {
    print("numberOne == Int64")
} // numberOne == Int64

let numberTwo = NSNumber(value: UInt32(777))
if let value = numberTwo as? Int8 {
    print(value)
} // 아무 출력 없음


그 외 기타 변경사항

* Core Foundation 타입들은 HashableEquatable 프로토콜을 CFHashCFEqual 함수구현을 통해 준수합니다. Swift 3 모드(Swift 3.2 버전)에서도 적용되는 사항입니다. [SR-2388]

* 암시적인 @objc 선언을 이제 더욱 명확히 표현해 주어야 합니다. [SE-0160]

* raw buffer를 슬라이스 한 결과는 더이상 같은 타입으로 반환되지 않습니다. [SE-0138]

* 재정의(override)가 더 완벽하게 지원됩니다. [SR-1529]

* 제네릭 매개변수를 갖는 서브스크립트를 정의할 수 있습니다. [SE-0148]

* 스위프트 타입 시스템이 이제는 하나의 튜플 전달인자를 가지는 함수와 여러 매개변수를 가지는 함수를 구분합니다. [SE-0110]

* 여러 연산자를 수반한 정수형 상수를 정의하는 C 언어의 매크로의 형태를 더 다양하게 임포트 할 수 있습니다. 

* inout 매개변수를 사용하는 reduce 함수가 추가되었습니다. [SE-0171]

* 컬렉션 타입의 두 요소를 서로 바꿔주는 swapAt(_:_:) 메서드가 추가됐습니다. [SE-0173], [SE-0176]


참고문서

Swift CHANGELOG - Swift 4.0






by yagom

facebook : http://www.facebook.com/yagomSoft

facebook group : https://www.facebook.com/groups/yagom/


p.s 제 포스팅을 RSS 피드로 받아보실 수 있습니다.

RSS Feed 받기   


↓↓↓ 블로거에게 공감은 큰 힘이 됩니다 ↓↓↓ 


저작자 표시 비영리 변경 금지
신고

'Swift' 카테고리의 다른 글

Swift 4 변경사항  (10) 2017.06.23
Posted by yagom

클로저

클로저는 코드의 블럭입니다. 일급시민(first-citizen)으로, 전달인자, 변수, 상수 등으로 저장, 전달이 가능합니다.  
함수는 클로저의 일종으로, `이름이 있는 클로저`라고 생각하면 됩니다.


소스코드


기본 클로저 문법

{ (매개변수 목록) -> 반환타입 in
    실행 코드
}


클로저의 사용

// sum이라는 상수에 클로저를 할당
let sum: (Int, Int) -> Int = { (a: Int, b: Int) in
    return a + b
}

let sumResult: Int = sum(1, 2)
print(sumResult) // 3


함수의 전달인자로서의 클로저

클로저는 주로 함수의 전달인자로 많이 사용됩니다. 함수 내부에서 원하는 코드블럭을 실행할 수 있습니다.

let add: (Int, Int) -> Int
add = { (a: Int, b: Int) in
    return a + b
}

let substract: (Int, Int) -> Int
substract = { (a: Int, b: Int) in
    return a - b
}

let divide: (Int, Int) -> Int
divide = { (a: Int, b: Int) in
    return a / b
}

func calculate(a: Int, b: Int, method: (Int, Int) -> Int) -> Int {
    return method(a, b)
}

var calculated: Int

calculated = calculate(a: 50, b: 10, method: add)

print(calculated) // 60

calculated = calculate(a: 50, b: 10, method: substract)

print(calculated) // 40

calculated = calculate(a: 50, b: 10, method: divide)

print(calculated) // 5

//따로 클로저를 상수/변수에 넣어 전달하지 않고, 
//함수를 호출할 때 클로저를 작성하여 전달할 수도 있습니다.

calculated = calculate(a: 50, b: 10, method: { (left: Int, right: Int) -> Int in
    return left * right
})

print(calculated) // 500



다양한 클로저표현

클로저는 다양한 모습으로 표현될 수 있습니다.

  • 함수의 매개변수 마지막으로 전달되는 클로저는 후행클로저(trailing closure)로 함수 밖에 구현할 수 있습니다. 
  • 컴파일러가 클로저의 타입을 유추할 수 있는 경우 매개변수, 반환 타입을 생략할 수 있습니다.
  • 반환 값이 있는 경우, 암시적으로 클로저의 맨 마지막 줄은 return 키워드를 생략하더라도 반환 값으로 취급합니다.
  • 전달인자의 이름이 굳이 필요없고, 컴파일러가 타입을 유추할 수 있는 경우 축약된 전달인자 이름($0, $1, $2...)을 사용 할 수 있습니다.


소스코드



클로저 매개변수를 갖는 함수 calculate(a:b:method:)와 결과값을 저장할 변수 result를 먼저 선언해둡니다.

func calculate(a: Int, b: Int, method: (Int, Int) -> Int) -> Int {
    return method(a, b)
}

var result: Int


후행 클로저

클로저가 함수의 마지막 전달인자라면 마지막 매개변수 이름을 생략한 후 함수 소괄호 외부에 클로저를 구현할 수 있습니다.

result = calculate(a: 10, b: 10) { (left: Int, right: Int) -> Int in
    return left + right
}

print(result) // 20


반환타입 생략

calculate(a:b:method:) 함수의 method 매개변수는 Int 타입을 반환할 것이라는 사실을 컴파일러도 알기 때문에 굳이 클로저에서 반환타입을 명시해 주지 않아도 됩니다. 

대신 in 키워드는 생략할 수 없습니다.

result = calculate(a: 10, b: 10, method: { (left: Int, right: Int) in
    return left + right
})

print(result) // 20

// 후행클로저와 함께 사용할 수도 있습니다
result = calculate(a: 10, b: 10) { (left: Int, right: Int) in
    return left + right
}

print(result) // 20


단축 인자이름

클로저의 매개변수 이름이 굳이 불필요하다면 단축 인자이름을 활용할 수 있습니다. 단축 인자이름은 클로저의 매개변수의 순서대로 $0, $1, $2... 처럼 표현합니다.

result = calculate(a: 10, b: 10, method: {
    return $0 + $1
})

print(result) // 20


// 당연히 후행 클로저와 함께 사용할 수 있습니다
result = calculate(a: 10, b: 10) {
    return $0 + $1
}

print(result) // 20


암시적 반환 표현

클로저가 반환하는 값이 있다면 클로저의 마지막 줄의 결과값은 암시적으로 반환값으로 취급합니다.

result = calculate(a: 10, b: 10) { $0 + $1 } print(result) // 20 // 간결하게 한 줄로 표현해 줄 수도 있습니다 result = calculate(a: 10, b: 10) { $0 + $1 } print(result) // 20


축약 전과 후 비교

//축약 전
result = calculate(a: 10, b: 10, method: { (left: Int, right: Int) -> Int in
    return left + right
})

//축약 후
result = calculate(a: 10, b: 10) { $0 + $1 }

print(result) // 20


관련문서

* The Swift Programming Language - Closures

* 일급시민(first-citizen)





by yagom

facebook : http://www.facebook.com/yagomSoft

facebook group : https://www.facebook.com/groups/yagom/


p.s 제 포스팅을 RSS 피드로 받아보실 수 있습니다.

RSS Feed 받기   


↓↓↓ 블로거에게 공감은 큰 힘이 됩니다 ↓↓↓ 


저작자 표시 비영리 변경 금지
신고

'Swift > 기본문법' 카테고리의 다른 글

상속  (0) 2017.06.29
프로퍼티 - Property  (2) 2017.06.26
클로저 - Closure  (0) 2017.06.22
클래스, 구조체, 열거형 비교  (0) 2017.06.19
열거형 - Enumerations  (0) 2017.06.15
클래스  (0) 2017.06.12
Posted by yagom

열거형


소스코드



정의 문법

스위프트의 열거형은 다른 언어의 열거형과는 많이 다릅니다. 잘 살펴보아야 할 스위프트의 기능 중 하나입니다.

  • enum은 타입이므로 대문자 카멜케이스를 사용하여 이름을 정의합니다
  • 각 case는 소문자 카멜케이스로 정의합니다
  • 각 case는 그 자체가 고유의 값입니다
  • 각 케이스는 한 줄에 개별로도, 한 줄에 여러개도 정의할 수 있습니다

enum 이름 {
	case 이름1
	case 이름2
	case 이름3, 이름4, 이름5
	// ...
}


열거형 사용

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("신나는 주말!!")
}


원시값(Raw value)

C 언어의 enum처럼 정수값을 가질 수도 있습니다. rawValue를 사용하면 됩니다. 

case별로 각각 다른 값을 가져야합니다.

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 프로토콜을 따르는 모든 타입이 원시값의 타입으로 지정될 수 있습니다.

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


원시값을 통한 초기화

rawValue를 통해 초기화 할 수 있습니다. rawValuecase에 해당하지 않을 수 있으므로 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에 해당하는 케이스가 없습니다


메서드

스위프트의 열거형에는 메서드도 추가할 수 있습니다.

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()


관련문서

The Swift Programming Language - Enumerations





by yagom

facebook : http://www.facebook.com/yagomSoft

facebook group : https://www.facebook.com/groups/yagom/


p.s 제 포스팅을 RSS 피드로 받아보실 수 있습니다.

RSS Feed 받기   


↓↓↓ 블로거에게 공감은 큰 힘이 됩니다 ↓↓↓ 

저작자 표시 비영리 변경 금지
신고

'Swift > 기본문법' 카테고리의 다른 글

클로저 - Closure  (0) 2017.06.22
클래스, 구조체, 열거형 비교  (0) 2017.06.19
열거형 - Enumerations  (0) 2017.06.15
클래스  (0) 2017.06.12
구조체  (2) 2017.06.08
옵셔널  (0) 2017.06.05
Posted by yagom

클래스

Swift/기본문법 2017.06.12 11:00

클래스


소스코드


정의 문법

클래스는 참조 타입입니다. 타입이름은 대문자 카멜케이스를 사용하여 정의합니다.

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


프로퍼티 및 메서드 구현

클래스의 타입 메서드는 두 종류가 있습니다. 상속 후 재정의가 가능한 class 타입메서드, 상속 후 재정의가 불가능한 static 타입메서드가 있습니다. 자세한 내용은 상속 부분에서 다시 다룹니다.

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")
    }
}


클래스 사용

// 인스턴스 생성 - 참조정보 수정 가능
var mutableReference: Sample = Sample()

mutableReference.mutableProperty = 200

// 불변 프로퍼티는 인스턴스 생성 후 수정할 수 없습니다
// 컴파일 오류 발생
//mutableReference.immutableProperty = 200


// 인스턴스 생성 - 참조정보 수정 불가
let immutableReference: Sample = Sample()

// 클래스의 인스턴스는 참조 타입이므로 let으로 선언되었더라도 인스턴스 프로퍼티의 값 변경이 가능합니다
immutableReference.mutableProperty = 200

// 다만 참조정보를 변경할 수는 없습니다
// 컴파일 오류 발생
//immutableReference = mutableReference

// 참조 타입이라도 불변 인스턴스는 
// 인스턴스 생성 후에 수정할 수 없습니다
// 컴파일 오류 발생
//immutableReference.immutableProperty = 200


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

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


학생 클래스 만들어보기

class Student {
	// 가변 프로퍼티
    var name: String = "unknown"

    // 키워드도 `로 묶어주면 이름으로 사용할 수 있습니다
    var `class`: String = "Swift"
    
    // 타입 메서드
    class func selfIntroduce() {
        print("학생타입입니다")
    }
    
    // 인스턴스 메서드
    // self는 인스턴스 자신을 지칭하며, 몇몇 경우를 제외하고 사용은 선택사항입니다
    func selfIntroduce() {
        print("저는 \(self.class)반 \(name)입니다")
    }
}

// 타입 메서드 사용
Student.selfIntroduce() // 학생타입입니다

// 인스턴스 생성
var yagom: Student = Student()
yagom.name = "yagom"
yagom.class = "스위프트"
yagom.selfIntroduce()   // 저는 스위프트반 yagom입니다

// 인스턴스 생성
let jina: Student = Student()
jina.name = "jina"
jina.selfIntroduce() // 저는 Swift반 jina입니다




관련문서

The Swift Programming Language - Classes and Structures





by yagom

facebook : http://www.facebook.com/yagomSoft

facebook group : https://www.facebook.com/groups/yagom/


p.s 제 포스팅을 RSS 피드로 받아보실 수 있습니다.

RSS Feed 받기   


↓↓↓ 블로거에게 공감은 큰 힘이 됩니다 ↓↓↓ 

저작자 표시 비영리 변경 금지
신고

'Swift > 기본문법' 카테고리의 다른 글

클래스, 구조체, 열거형 비교  (0) 2017.06.19
열거형 - Enumerations  (0) 2017.06.15
클래스  (0) 2017.06.12
구조체  (2) 2017.06.08
옵셔널  (0) 2017.06.05
반복문  (0) 2017.06.01
Posted by yagom


집필도서 출간 안내

안녕하세요 야곰입니다 :)


벌써 책이 나온지는 꽤 되었고 부끄럽지만 제가 쓴 책을 소개합니다.


스위프트 프로그래밍이라는 책이구요, 한빛미디어에서 나왔습니다.




[링크]


스위프트 프로그래밍 언어 문법서이며, 여러가지 팁과 노트가 수록되어 있습니다. 

스위프트를 활용한 프로그래밍 기법이라던지 최근 이야기되고 있는 프로그래밍 패러다임에 대한 이야기들도 있습니다.


많은 참고가 되면 좋겠습니다.


링크


by yagom

facebook : http://fb.yagom.net

facebook group : https://www.facebook.com/groups/yagom/


p.s 제 포스팅을 RSS 피드로 받아보실 수 있습니다.

RSS Feed 받기   

저작자 표시 비영리 변경 금지
신고

'Notice' 카테고리의 다른 글

스위프트 프로그래밍  (2) 2017.03.24
iOS 7 핵심노트  (15) 2014.01.20
페이스북 그룹 안내  (6) 2013.07.03
Posted by yagom

이 문서는 2013s 01. 기준으로 작성된 글이므로, 이후에 애플 문서의 내용이 변경될 수 있습니다.
또한 전문 번역가가 아니기 때문에 의역, 오역의 소지가 다분히 많습니다.
참고하시기 바랍니다.

공개 수배 합니다!
유용한 iOS 개발문서를 함께 번역해 나갈 분들을 찾습니다.
현재도 함께 작업중이신 분들 모두 전문 번역가 아닙니다.
모두 열정과 열의로 함께 작업하고 계십니다.
자신의 재능을 자신뿐만 아니라 또 다른 누군가를 위해서 사용한다면 더더욱 빛이 날 것입니다.
함께하길 원하는 분께서는 덧글 또는 이메일 주시기 바랍니다 :)
 

오늘의 주제

1. Manage App State Changes


파헤치기 다섯 번째 시간입니다.^^

이번 파트는 Scott Lim 님께서 도와주셨습니다. 번역에 도움주셔서 진심으로 고맙습니다 :)

자, 그럼 출발해 봅시다^^~
[##_http://yagom.tistory.com/script/powerEditor/pages/1C%7Ccfile2.uf@1979C54150E41B6B32FD56.png%7Cwidth=%22212%22%20height=%22619%22%20alt=%22%22%20filename=%221.png%22%20filemime=%22image/jpeg%22%7C_##]
# App States and Multitasking





iOS 어플리케이션에서는, 당신의 어플리케이션이 "현재 실행(foreground)" 상태인지 "백그라운드실행상태(background)" 인지를 아는 것이 중요하다. 시스템 리소스가 iOS 장치에 매우 한계가 정해져 있으므로, 어플리케이션은 현재 실행상태일 떄보다 백그라운드 실행상태일때 다르게 작동해야만 한다. 운영체제 또한 배터리 수명을 향상시키고, 사용자들의 현재 실행중인 어플리케이션에 대한 사용경험을 향상시키기 위해 백그라운드 실행상태인 어플리케이션이 할 수 있는 것들에 한계를 두어야만 한다. 운영체제는 당신의 어플리케이션에게 실행중상태와 백그라운드 실행상태를 이동할 때마다 알려줄 것이다. 이런 알림은 당신의 어플리케이션의 동작을 수정하는 기회가 된다.
당신의 어플리케이션이 현재 실행중인 동안, 시스템은 프로세스처리(processing)를 위해 터치 이벤트를 어플리케이션에게 보낸다. UlKit 구조는 당신의 전용(custom) 오브젝트에 이벤트를 전달하기 위한 어려운 작업의 대부분을 수행한다. 당신이 해야하는 것은 이런 이벤트들을 처리하기 위해 적당한 오브젝트에 이 메소드를 오버라이드 하는 것이 전부다. 작동을 위해, UlKit 는 텍스트 필드의 값의 변화 같은 어떤 흥비로운 일이 발생할떄만 당신의 전용(custom) 코드를 불러낸다거나, 당신을 위한 터치 이벤트를 다루는 것으로 훨씬 간단하게 작동하도록 해준다.
당신의 앱을 구현하고 싶다면, 이 가이드라인을 따라하십시오.
- (필수사항) 발생하는 상태 변화(state transition) 에 적합하게 반응하십시오. 이러한 변화들을 적절하게 다루지 못하는 것은 데이터 손실이나 사용자들에게 나쁜 인상을 가져올 수 있습니다. 상태 변이에 반응하는 방법의 요약본을 찾는다면, "Managing App State Changes" 를 보십시오.

- (필수사항) 백그라운드 실행상태로 이동할 땐, 당신의 앱이 그 동작을 적절하게 조정할 수 있는지 확실하게 해라. 당신의 앱이 백그라운드 실행상태로 이동할 때, 해야하는 것들에 대한 가이드라인을 찾는다면, "Being a Responsible Background App" 를 보십시오.

- (권장사항) 당신의 앱이 필요로 하는 시스템 변화를 알려주는 모든 알림기능을 등록하십시오. 앱이 잠자기(suspended) 상태(아무 동작도 하지 않음)일 때, 시스템은 앱이 실행을 재개하게 될 때 키 알림을 보낸다(queue). 앱은 다시 실행으로 돌아가는 부드러운 변이를 만들어내기 위해 이런 알림기능을 사용해야만 한다. 더 많은 정보를 찾는다면, "Processing Queued Notifications at Wakeup Time" 을 보십시오.

- (선택사항) 만약 당신의 앱이 백그라운드 실행상태에서 실제 작업을 수행할 필요가 있는 경우, 시스템에게 실행을 계속할 수 있는 적합한 허용을 요청해라. 당신이 할 수 있는 백그라운드 실행상태에서의 작업의 종류와 그 작업을 하기 위해 허가를 요청하는 방법에 대해 알고 싶다면, "Background Execution and Multitasking" 을 보십시오.



Managing App State Changes
[##_http://yagom.tistory.com/script/powerEditor/pages/1C%7Ccfile25.uf@157A8F4150E41B7D31B6C7.png%7Cwidth=%22824%22%20height=%22295%22%20alt=%22%22%20filename=%223.png%22%20filemime=%22image/jpeg%22%7C_##]
어떤 주어진 상황에서든, 당신의 앱은 Table 3.1 에 나열된 상태 중의 한가지에 있어야 한다. 시스템은 시스템을 통해 일어나는 액션들의 반응으로 상태를 변화시킨다. 예를 들면, 사용자가 홈버튼을 눌렀을 때, 전화가 왔을 때, 또는 어떤 다른 인터럽션(interruptions)이 발생했을 때, 현재 실행중인 앱은 그에 대한 응답으로 상태를 변화시킨다. Figure 3-1 은 다른 상태로 변할 때 앱이 선택하게 되는 경로들을 보여준다.


Table 3-1    앱 상태들
실행중이 아님   :  앱이 실행되지 않았거나, 실행은 되고 있었으나 시스템에 의해 종료됨.

비활성 상태      :  앱이 실행상테에서(현재 메인 화면에서) 실행중이지만, 현재 이벤트를 받고 있지 않고 있다. (다른 코드를 수행하고 있을 수 있다.) 어플리케이션은 보통 다른 상태로의 변이가 일어날 때 일시적으로 이 상태에 머물러 있는다.

활성 상태  :  앱이 메인화면에서 실행중이고, 이벤트를 받고 있다. 이것은 실행상태의 앱의 일반적인 상태이다.
백그라운드 실행 상태 : 앱이 백그라운드 상태에 있으면서 코드를 수행하고 있다. 대부분의 앱들은 종료되어가는 과정에서 일시적으로 이 상태에 들어가게 된다. 그러나, 추가적인 실행 시간을 요청하는 앱은 일정 시간동안 이 상태에 남아있을 수 있다. 게다가, 바로 백그라운드 실행상태로 시작되는 앱은

비활성 상태(Inactive)대신 이 상태로 들어간다. 백그라운드 실행상태에 있는 동안 코드를 실행하는 방법에 대한 정보를 알고 싶다면, "Background Execution and Multitasking" 을 보십시오.

잠자기 상태  :  앱이 백그라운드 상태로 있지만, 코드를 수행하고 있지 않는다. 시스템은 그렇게 하기 전에 앱을 자동으로 이 상태로 옮기고 통지하지 않는다. 잠자기(suspended) 상태인 동안, 앱은 메모리에 남아있으나 어떤 코드도 수행하지 않는다. 메모리 부족 상태(low-memory)가 발생할 때, 시스템은 실행상태의 앱에 더 많은 공간을 만들어주기 위해 통지 없이 잠자기 상태(suspended) 앱들을 제거할 수 있다.

[##_http://yagom.tistory.com/script/powerEditor/pages/1C%7Ccfile24.uf@23307C3E50E41BA224ADE4.png%7Cwidth=%22824%22%20height=%22378%22%20alt=%22%22%20filename=%224.png%22%20filemime=%22image/jpeg%22%7C_##]Figure 3-1  





주의: iOS3.2 나 그 이전 버전에서 실행되는 앱들은 백그라운드 실행상태나 잠자기(suspended) 상태가 되지 못한다. 게다가, 어떤 장치들은 멀티태스킹이나 백그라운드 실행상태 수행을 전혀 지원하지 않는다,(심지어 iOS 4나 그 이후에서 실행되더라도). 이러한 장치들에서 실행되는 앱들은 또한 백그라운드 실행상태나 잠자기(suspended) 상태로 들어가지 못한다. 대신, 앱들은 실행상태를 떠나면서 종료된다.


[##_http://yagom.tistory.com/script/powerEditor/pages/1C%7Ccfile25.uf@24307C3E50E41BA22512F1.png%7Cwidth=%22824%22%20height=%22150%22%20alt=%22%22%20filename=%225.png%22%20filemime=%22image/jpeg%22%7C_##]
대부분의 상태 변화는 당신의 앱에 delegate object 의 메소드에 따라 상응하는 호출에 동반된다. 이러한 메소드들은 적합한 방법으로 상태 변화에 응답하는 기회(chance)가 된다. 이러한 메소드들은 아래에 당신이 사용하는 방법의 요약과 함께 나와있다.


- application:willFinishLaunchingWithOptions : 이 메소드는 당신의 앱이 실행(Launch) 시에 코드를 수행하는 첫 번째 기회가 된다.

- application:didFinishLaunchingWithOptions : 이 메소드는 당신이 당신의 앱이 사용자에게 보여지기 전에 최종적으로 어떤 초기화든지 수행하도록 해준다.

- applicationDidBecomeActive : 당신의 앱이 실행상태로 막 되려고 한다는 것을 알게 해준다. 어떠한 마지막 준비 시기(preperation)에도 이 메소드를 사용해라. 
- applicationWillResignActive : 당신에게 당신의 앱이 실행상태에서 다른 상태로 변이될 것을 알려준다. 당신의 앱을 조용한(quiescent) 상태로 놓고자 할 때, 이 메소드를 사용해라.

- applicationDidEnterBackground : 당신에게 당신의 앱이 백그라운드 실행상태로 실행되고, 어떤 때든지 잠자기(suspended) 상태로 갈 수 있음을 알려준다.

- applicationWillEnterForeground : 당신에게 당신의 앱이 백그라운드 실행상태에서 나와서 실행상태로 돌아가는 것을 알게 해준다. 그러나, 아직은 실행상태는 아니다.

- applicationWillTerminate : 당신에게 당신의 앱이 종료될 것임을 알려준다. 이 메소드는 당신의 앱이 잠자기(suspended) 상태일 때는 호출되지 않는다.


The App Launch Cycle
[##_http://yagom.tistory.com/script/powerEditor/pages/1C%7Ccfile29.uf@25307C3E50E41BA226953B.png%7Cwidth=%22824%22%20height=%2283%22%20alt=%22%22%20filename=%226.png%22%20filemime=%22image/jpeg%22%7C_##]
당신의 앱이 시작되었을 때, 실행상태나 백그라운드 실행 상태로 이동하는 것이 아니라, 일시적으로 비활성상태를 통해 변이하게 된다. 실행 사이클의 부분으로서, 시스템은 프로세스를 만들고 당신의 앱을 위한 메인 쓰레드를 만들고, 당신의 앱의 메인 함수를 그 메인 쓰레드에 호출한다. 당신의 XCode 프로젝트와 함께 나오는 기본 메인 함수는 신속하게 컨트롤을 UlKit Framework 로  넘겨주는데, 이 컨트롤들은 당신의 앱을 초기화하고, 실행되는데 준비되도록 하는 작업의 대부분을 수행한다.
Figure 3-2 는 앱이 실행상태로 시작될 때, 호출된 앱 delegate 메소드를 포함해서 발생하는 이벤트들의 순서들을 보여준다.


Figure 3-2  앱을 실행상태로 시작하는 과정
[##_http://yagom.tistory.com/script/powerEditor/pages/1C%7Ccfile26.uf@134E564D50E41BD3238DFF.png%7Cwidth=%22824%22%20height=%22501%22%20alt=%22%22%20filename=%227.png%22%20filemime=%22image/jpeg%22%7C_##]

만약 당신의 앱이 백그라운드 실행상태로 시작되었다면 - 보통 백그라운드 실행상태의 이벤트들을 다루기 위해 - 시작 사이클은 Figure 3-3 에 보인 것처럼 살짝 바뀐다. 중요한 차이점은 당신의 앱을 활성상태로 만드는 대신에, 이벤트를 다루기 위한 백그라운드 실행상태로 들어가서 그 후에 금방 잠자기(suspended) 상태가 된다. 백그라운드 실행상태로 시작했을때, 시스템은 여전히 앱 사용자의 인터페이스 파일을 로드하지만  앱 창에는 보여주지 않는다.



Figure 3-3 앱을 백그라운드 실행상태로 시작하는 과정
[##_http://yagom.tistory.com/script/powerEditor/pages/1C%7Ccfile29.uf@154E564D50E41BD424EBF4.png%7Cwidth=%22824%22%20height=%22621%22%20alt=%22%22%20filename=%228.png%22%20filemime=%22image/jpeg%22%7C_##]
당신의 앱이 실행상태 또는 백그라운드 실행상태로 시작되는지를 결정하기 위해서는, 당신의 application:willFinishLaunchingWithOptions: 또는 application:didFinishLaunchingWithOptions 델리게이트 메소드에 있는 공유된 UIApplication object 의 applicationState 프로퍼티를 체크하여라. 앱이 실행상태로 시작되었을 때는, 이 프로퍼티는 UIApplicationStateInactive 값을 포함한다. 앱이 비실행상태로 시작된다면, 프로퍼티는 UIApplicationStateBackground 값을 대신 포함한다. 당신은 당신의 델리게이트 메소드의 시작시간 행동을 조정하기 위해 이런 차이점들을 각각 맞추어 사용할 수 있다.

주의 : 앱이 URL을 열 수 있도록 시작되었을 땐, Startup 이벤트의 과정이 Figure 3-2, 3-3 에 보여진 것들과는 조금 다르다. URL을 열 때 발생하는 Startup 과정들에 대한 정보를 알고 싶으면, "Handling URL Requests" 를 보십시오.



About the main Function
[##_http://yagom.tistory.com/script/powerEditor/pages/1C%7Ccfile4.uf@174E564D50E41BD5254F0D.png%7Cwidth=%22824%22%20height=%22262%22%20alt=%22%22%20filename=%229.png%22%20filemime=%22image/jpeg%22%7C_##] C 기반의 앱과 마찬가지로, iOS 앱의 주된 시작점은 메인 함수(main function)이다. iOS 앱에서 메인 함수는 최소한으로만 사용된다. 메인 함수의 주된 역할은 UlKit fraomwork 로 컨트롤을 전달하는 것이다. 그러므로, XCode 에서 당신이 만드는 어떤 새로운 프로젝트라도 Listing 3-1 에 보이는 것 처럼 기본 메인 함수를 가지고 시작한다. 거의 예외 없이, 당신은 이 함수의 구현을 결코 바꾸어선 안된다.


Listing 3-1   iOS 앱의 메인 함수
( 코드 내용 생략 )
 
주의 : 메모리 관리에서 autorelease pool 이 사용된다. 이는 functional block of code 동안 만들어지는 object의 release 를 지연시켜주는데 사용되는 Cocoa 메커니즘이다. autorelease pools 에 대한 더 많은 정보를 원한다면, Advanced Memory Management Programming Guide 를 보십시오.







UIApplicationMain 함수는 4개의 변수를 택하고, 이를 앱을 초기화하는 데 사용한다. 당신은 이 함수로 전해지는 초기 값들을 결코 바꾸어선 안된다. 그렇지만 그 목적이나 그들이 앱을 시작하는 방법 등을 이해하는 것은 중요하다.
- argc 와 argv 변수는 시스템으로부터 앱으로 전달되는 모든 시작 시간(Launch-time) 인수 (Arguments) 들을 포함한다. 이 인수들은 UlKit infrastructure 에 의하여 분석되고, 그렇지 않다면 무시될 수 있다.

- 3번째 변수는 중요한 앱 클래스의 이름을 식별한다. 이것은 앱을 실행하는데 책임이 있는 클래스이다. 이 변수에 nil 을 사용하길 권장하는데, 이는 UIKit 이 UIApplication 클래스를 사용하도록 유도한다.

- 4번째 변수는 당신의 전용(custom) 앱 델리게이트의 클래스를 식별한다. 당신의 앱 델리게이트는 시스템과 당신의 코드 사이의 수준높은 상호작용을 다루는 데 책임이 있다. Xcode 템플릿 프로젝트는 이 변수를 자동으로 적당한 값으로 세팅한다.


UIApplicationMain 함수가 하는 또다른 일은 앱의 메인 사용자의 인터페이스 파일을 로드(Load)하는 것이다. 주요 인터페이스 파일은 당신이 당신의 앱의 사용자 인터페이스에 보여주도록 계획한 초기 view-related objects 들을 포함한다. 스토리보드를 사용하는 앱에 대해선, 이 함수는 당신의 스토리보드로 부터 초기 뷰 컨트롤러를 로드하고 당신의 앱 델리게이트에 의해 공급된 윈도우에 그것을 설치한다.  nib 파일을 사용하는 앱에선, 그 함수는 메모리로 nib 파일의 내용을 로드한다, 그러나 당신의 앱 윈도우에는 설치하진 않는다; 당신은 당신의 앱 델리게이트의 application:willFinishLaunchingWithOptions: 메소드에서 그것들을 설치해야만 한다.

앱은 메인 스토리보드 파일이나 메인 nib 파일 중 하나를 가질 수 있다, 그러나 동시에 둘다 가질 수는 없다. 스토리보드는 당신의 앱의 사용자 인터페이스를 구체화하는 방법으로 선호된다. 하지만 iOS 모든 버전에 지원되지는 않는다. 당신의 앱의 메인 스토리보드 파일의 이름은 당신의 앱의 Info.plist 파일의 UIMainStoryboardFile 키값에 저장된다. (nib 기반 앱에 대해서는, 대신에 메인 nib file 의 이름이 NSMainNibFile 키에 저장된다.) 일반적으로, Xcode 는 당신이 프로젝트를 만들 때, 적당한 키값을 정한다, 그러나 필요하다면 당신은 그 값을 바꿀 수 있다.

Info.plist 파일과 당신의 앱을 설정하기 위해 그 파일을 사용하는 방법에 대한 더 많은 정보를 원한다면, "The information Property List File" 을 보십시오.


What to Do at Launch Time
[##_http://yagom.tistory.com/script/powerEditor/pages/1C%7Ccfile3.uf@135A9F3350E41C22132B4A.png%7Cwidth=%22824%22%20height=%22134%22%20alt=%22%22%20filename=%2211.png%22%20filemime=%22image/jpeg%22%7C_##]
당신의 앱이 시작되었을 때 (실행상태든 백그라운드 실행상태든) 당신의 앱 델리게이트의 application:willFinishLaunchingWithOptions:와 application:didFinishLaunchingWithOptions: 메소드를 다음 내용을 구현하도록 사용하여라.

- 앱이 실행된 이유에 대한 정보를 찾는 실행 옵션 사전 (Launch options dictionary) 의 내용들을 확인하고, 알맞게 대응해라.

- 어플리케이션의 중요 데이터 구조를 초기화하여라.

- 보여질 앱의 윈도우와 뷰를 준비하여라.

OpenGL ES 를 사용하는 앱들은 그들의 그려낸 배경등을 준비하기 위해 이 방법을 써서는 안된다. 대신, 그들은 applicationDidBecomeActive: 메소드에 전달되는 모든 OpenGL ES 호출을 지연시켜야 한다.

[##_http://yagom.tistory.com/script/powerEditor/pages/1C%7Ccfile8.uf@145A9F3350E41C22142077.png%7Cwidth=%22824%22%20height=%22130%22%20alt=%22%22%20filename=%2212.png%22%20filemime=%22image/jpeg%22%7C_##]

만약 당신의 앱이 시작 시간에 자동으로 메인 스토리보드나 nib 파일을 불러오지 않는다면, 당신은 보여주기 위한 당신 앱의 윈도우를 준비하기 위하여 application:willFinishLaunchingWithOptions: 메소드를 사용할 수 있다.
가로, 세로방향을 전부 지원하는 앱에 대해선, 항상 당신의 메인 윈도우의 root view controller 를 세로 방향으로 설정하여라. 만약 장치가 시작 시간에 다른 방향으로 놓인다면, 윈도우를 보여주기 전에 시스템이 root view controller 에게 당신의 뷰를 올바른 방향으로 회전하라고 말해줄 것이다.

당신의 application:willFinishLaunchingWithOptions: 와 application:didFinishLaunchingWithOptions: 메소드들은 항상 당신의 앱의 시작 시간을 줄이기 위해 가능한 가벼워야만 한다. 앱들은 5초 이내에 그들 자신을 초기화하고 시작하고 이벤트들을 다루도록 기대되어 진다. 만약 앱이 적절한 시간에 시작 사이클을 완료해내지 못한다면, 시스템은 무반응 상태로 놓이기 전에 그것을 죽일 것이다. 이와 같이, 당신의 시작을 늦추는 어떤 작업들도(네트워크에 접속하는 것과 같은) 동시에 발생하지 않도록 2차 쓰레드에서 실행되어야만 한다.


실행상태로 시작할 때, 시스템은 실행 상태로의 변이를 완료하기 위해 applicationDidBecomeActive: 메소드를 호출한다. 이 메소드는 시작시간에도 그리고 백그라운드 실행상태로 변이할 때에도 호출되므로, 두 변이상태에 공통인 작업들을 수행하도록 그것을 사용하여라.
백그라운드 실행상태로 시작될 때, 도착한 각종의 이벤트들을 다루기 위해 준비상태가 되는 것 말고는 당신의 앱이 해야할 것들이 많지 않아야만 한다.






Responding to Interruptions
[##_http://yagom.tistory.com/script/powerEditor/pages/1C%7Ccfile2.uf@122AFF3F50E41C791137FB.png%7Cwidth=%22824%22%20height=%22383%22%20alt=%22%22%20filename=%2213.png%22%20filemime=%22image/jpeg%22%7C_##] 전화가 왔을 때 처럼, 경보(alert) 기반의 인터럽션이 발생했을 때 어플리케이션은 사용자가 진행해야할 방법으로 유도해주기 위해서 일시적으로 비활성 상태로 이동한다. 앱은 사용자가 경보를 끝낼 떄까지 이 상태에 남아있는다. 이 지점에서, 앱은 활성 상태로 돌아가거나 백그라운드 실행상태로 이동한다. Figure 3-4는 경보기반의 인터럽션이 발생했을 때 당신의 앱을 통과하는 이벤트들의 흐름을 보여준다.
Figure 3-4. 경보기반 인터럽션을 다루기
(그림 생략)

[##_http://yagom.tistory.com/script/powerEditor/pages/1C%7Ccfile29.uf@132AFF3F50E41C79128EC0.png%7Cwidth=%22824%22%20height=%2298%22%20alt=%22%22%20filename=%2214.png%22%20filemime=%22image/jpeg%22%7C_##] iOS5 에선, 배너를 보여주는 알림은 경보기반 알림이 하는 방식처럼 당신의 앱을 비활성화시키지는 않는다. 대신, 배너는 당신의 앱 윈도우의 가장 최상층에 놓이게 되고 당신의 앱은 전처럼 터치 이벤트를 계속해서 받는다. 그러나, 만약 사용자가 알림센터(notification center)를 드러내기 위해 화면을 위에서 아래로 끌어 내리면 당신의 앱은 경보기반 인터럽션이 발생했던 것처럼 비활성 상태로 이동한다. 당신의 앱은 사용자가 또다른 앱을 시작하거나, 알림 센터를 그만둘 떄까지 비활성 상태에 남아있게 된다. 이 지점에서, 당신의 앱은 알맞은 활성 상태나 백그라운드 실행 상태로 이동하게 된다. 사용자는 어떤 알림이 배너를 보여줄 것인지, 또 경보를 보여줄 것인지 설정하기 위해 앱 셋팅 (the Setting app) 을 사용할 수 있다.

Sleep/Wake 버튼을 누르는 것은 일시적으로 당신의 앱이 비활성화되도록 하는 인터럽션의 또다른 종류이다. 사용자가 이 버튼을 눌렀을 때, 시스템은 터치 이벤트를 불능 상태로 만들고 앱을 백그라운드 실행 상태로 옮긴다, 그러나 앱의 applicationState 프로퍼티 값을 UIApplicationStateInactive ( UIApplicationStateBackground 와는 반대로) 에 할당하고, 결국 화면을 잠근다(lock). 잠긴 화면은 파일을 암호화하기 위한 데이타 보호를 사용하는 앱들을 위해 부가적인 과정을 가지고 있다. 이런 과정들은 "What to Do When an Interruption Occurs" 에 설명되어 있다.



What to Do When an Interruption Occurs
[##_http://yagom.tistory.com/script/powerEditor/pages/1C%7Ccfile30.uf@222AFF3F50E41C7A132410.png%7Cwidth=%22824%22%20height=%22253%22%20alt=%22%22%20filename=%2215.png%22%20filemime=%22image/jpeg%22%7C_##]
경보기반 인터럽션은 당신의 앱에 의해 일시적인 컨트롤의 손실을 낳게 된다. 당신의 앱은 실행상태로 계속 진행된다, 하지만 시스템으로부터 터치 이벤트를 받지는 않는다.(알림 및 가속센서같은 이벤트의 종류는 계속해서 받는다.) 이 변화에 대응하여, 당신의 앱은 applicationWillResignActive: 메소드에 있는 다음의 사항을 해야만 한다.

- 타이머와 다른 주기적인 작업등을 멈춘다.
- 실행중인 모든 메타데이타 쿼리를 멈춘다.
- 어떤 새로운 작업도 시작하지 않는다.
- 동영상 재생을 멈춘다 (Airplay 인 경우만 제외하고)
- 만약 앱이 게임 중이면, 멈춤 상태(Pause state) 로 들어간다.
- OpenGL ES 의 Frame rate 를 줄인다.
- 중요하지 않은 코드를 실행하는 모든 전송 혹은 작동 큐를 중단한다(suspend).


당신의 앱이 활성 상태로 돌아갔을 때, applicationDidBecomeActive: 메소드는 applicationWillResignActive: 메소드에서 행한 모든 과정을 되돌린다. 이와 같이 재활성화 때엔 당신의 앱은 타이머를 재시작해야하고, 전송 큐를 재개해야 하고, OpenGl ES 의 Frame rate 를 다시 높여야 한다. 그러나, 게임은 자동으로 재게되지는 않는다; 게임은 사용자가 재개하기를 선택할 때 까지는 멈춤 상태로 남아있는다.

사용자가 Sleep/Wake 버튼을 눌렀을 때, NSFileProtectionComplete 보호 옵션에 의해 보호된 파일을 가진 앱들은 그 파일에 관련된 모든 레퍼런스(reference)를 닫아야만 한다. 적당한 패스워드로 설정된 장치들에서는, Sleep/Wake 버튼을 누르는 것은 화면을 잠그고, 시스템은 확실한 보호가 실행된 파일에 대한 해독 키를 사라지게끔(throw away)한다. 스크린이 잠겼을 때, 파일에 상응하는 모든 접근 시도는 무시된다. 그러므로 만약 그러한 파일을 당신이 가지고 있다면, 당신은 applicationWillResignActive: 메소드에 있는 관련된 모든 레퍼런스를 닫아야 하고, applicationDidBecomeActive: 메소드에 있는 새로운 레퍼런스를 열어야 한다.


Adjusting Your User Interface During a Phone Call



사용자가 전화를 받았을 때, 그리고 전화받는 도중 당신의 앱으로 돌아왔을 때, 상태 바(status bar) 의 세로길이는 사용자가 전화하고 있다는 사실을 나타내기 위해 커지게 된다. 비슷하게, 사용자가 전화를 끝마쳤을 때, 상태 바는 보통 사이즈로 줄어든다.
상태 바의 변화를 다루는 가장 좋은 방법은 당신의 뷰를 관리하도록 뷰 컨트롤러를 사용하는 것이다. 당신의 인터페이스에 설치되었을 때, 뷰 컨트롤러는 자동으로 상태 바 프레임 사이즈가 변할 때 그 관리되는 뷰들의 세로 길이를 조절한다.
만약 당신의 앱이 어떤 이유로 뷰 컨트롤러를 사용하지 않는다면, 당신은 UIApplicationDidChangeStatusBarFrameNotification 의 알림에 수동으로 등록함으로써 상태 바 프레임의 변화에 대응해야 한다. 이 알림에 대한 처리 부분은 상태 바의 세로 길이를 받아서 당신의 앱의 뷰에 알맞게 적응되도록 이를 사용해야 한다.



Moving to Background
[##_http://yagom.tistory.com/script/powerEditor/pages/1C%7Ccfile29.uf@0260433D50E41CC92ACB16.png%7Cwidth=%22824%22%20height=%22579%22%20alt=%22%22%20filename=%2217.png%22%20filemime=%22image/jpeg%22%7C_##]사용자가 홈버튼을 눌렀을 때, Sleep/Wake 버튼을 눌렀을 때, 또는 시스템이 다른 앱을 시작했을 때, 실행상태의 앱은 비활성 상태로, 그리고 백그라운드 실행 상태로 변이한다. 이런 변이는 Figure 3-5. 에 보이는 것 처럼 앱 델리게이트의 applicationWillResignActive: 와 applicationDidEnterBackground: 메소드들을 호출하는 결과를 가져온다. applicationDidEnterBackground: 메소드에서 온 다음에, 대부분의 앱들은 결국 곧 잠자기(suspended) 상태로 이동한다. 백그라운드 실행 상태의 특정 작동을 요청하거나 (음악을 재생하는 것과 같은) 시스템으로부터 짧은 추가 실행 시간을 요청하는 앱들은 조금 더 길게 실행이 이어질 수 있다.
Figure 3-5.  실행 상태에서 백그라운드 실행 상태로의 이동 (Moving from the foreground to the background)
( 그림 생략 )

주의 : 앱들은 멀티태스킹을 지원하는 장치에서만 그리고 iOS4.0 이나 이후 버전을 실행하는 장치에서만 백그라운드 실행상태로 이동한다. 다른 모든 경우에선, 앱은 백그라운드 실행상태로 이동되는 대신 종료된다(메모리에서 부터 제거된다).


What to Do When Moving to Background




앱들은 백그라운드 실행상태로 움직이는 것에 대비해서 applicationDidEnterBackground: 메소드를 사용할 수 있다. 백그라운드 실행상태로 이동할 때, 모든 앱들은 다음의 내용을 해야만 한다.
- 현재 상태 이미지가 찍히는 것에 대한 준비를 해라. 
applicationDidEnterBackground: 메소드가 돌아왔을 때, 시스템은 당신의 앱의 사용자 인터페이스의 상태를 찍는다(picture). 그리고 변이될 에니메이션을 위한 결과 이미지를 사용한다. 만약 당신의 인터페이스의 어떤 뷰라도 민감한 정보를 포함하고 있다면, applicationDidEnterBackground: 메소드가 돌아오기 전에 그런 뷰들을 숨기거나 수정해야만 한다.

- 사용자 데이터와 앱 상태 정보를 저장해라.
모든 저장되지않은 변화들은 백그라운드 실행상태로 들어갈 때 디스크에 기록되어야만 한다. 이 단계는 당신의 앱이 백그라운드 실행 상태에 있는 동안 수많은 사유로 인해 조용히 종료될 수 있으므로 매우 필요하다. 당신은 필요에 따라 이 작업을 백그라운드 실행상태 스레드에서 수행할 수 있다.

- 가능한한 많은 메모리를 비워놓아라(Free up).
무엇을 해야하고, 왜 이것이 중요한지에 대한 더 많은 정보를 원한다면, "Memory Usage for Background Apps" 를 보십시오.

당신의 앱 델리게이트의 applicationDidEnterBackground: 메소드는 대략 모든 업무를 종료하고 돌아오는 데 5초를 가진다. 실제로, 이 메소드는 가능한 빠르게 돌아와야만 한다. 만약 메소드가 시간이 끝나기 전에 돌아오지 못한다면, 당신의 앱은 메로리로부터 종료될 것이다. 만약 당신이 여전히 작업들을 수행하는 데 더 많은 시간을 필요로 한다면, 백그라운드 실행상태의 실행 시간을 요청하기 위한 beginBackgroundTaskWithExpirationHander: 메소드를 호출하여라 그리고 2차 스레드에서 오래 걸리는 작업들을 시작해라. 당신이 어떤 백그라운드 실행상태 작업들을 실행했더라도, applicationDidEnterBackground: 메소드는 여전히 5초 내에 종료해야만 한다.


주의 : UIApplicationDidEnterBackgroundNotification 알림은 또한 당신의 앱의 특정한 부분들에게 백그라운드 실행상태로 들어간다는 것을 알리기 위해 전송된다. 당신의 앱의 오브젝트들은 이 알림에 대한 등록을 위해 이 기본 알림 센터를 사용할 수 있다.

당신의 앱의 특징들에 따라, 백그라운드 실행상태로 들어갈 때, 당신의 앱이 해야만 하는 다른 것들이 있다. 예를 들면, 모든 활성상태의 Bonjour 서비스들은 잠자기(suspended) 상태로 가야만 한다. 그리고 앱은 OpenGl ES 함수들을 호출하는 것을 멈춰야만 한다. 백그라운드 실행상태로 들어갈 때 당신의 앱이 해야만 하는 것들의 목록을 보려면, "Being a Responsible Background App" 를 보십시오.


Memory Usage for Background Apps
[##_http://yagom.tistory.com/script/powerEditor/pages/1C%7Ccfile24.uf@14349C4450E41CE11F0AB6.png%7Cwidth=%22824%22%20height=%22238%22%20alt=%22%22%20filename=%2219.png%22%20filemime=%22image/jpeg%22%7C_##]
모든 앱들은 백그라운드 실행상태로 들어갈 때 실용적일 수 있을 만큼 많은 메모리를 비워놓아야만 한다. 시스템은 할 수 있는 한 동시에 메모리에 많은 앱들을 유지하려고 한다. 그러나 메모리가 부족할 때, 시스템은 메모리를 회복하기 위해 잠자기(suspended) 상태의 앱들을 종료한다. 백그라운드 실행상태에 있을 때 많은 양의 메모리를 소비하는 앱들은 종료되어야 할 첫번째 앱이 될 것이다.
실용적으로 말해서, 당신의 앱은 strong 레퍼런스가 더이상 필요하지 않게 되는 즉시 제거해야만 한다. strong 레퍼런스들을 제거하는 것은 컴파일러가 상응하는 메모리가 회복될 수 있도록 바로 오브젝트들을 release하게 해준다. 그러나 만약 당신이 퍼포먼스를 향상시키기 위해 일부 오브젝트들을 캐시(cache)에 저장하길 원한다면, 당신은 그 레퍼런스들을 제거하기 전에 앱이 백그라운드 실행상태로 변이될 떄까지 기다려야만 한다.

당신이 가능한 빠르게 strong 레퍼런스들을 제거해야만 하는 오브젝트들의 예들은 다음을 포함한다 :

- 이미지 오브젝트
- 당신이 디스크로부터 다시 불러올 수 있는 큰 미디어 혹은 데이타 파일들
- 당신의 앱이 필요로 하지 않고, 나중에 쉽게 다시 만들 수 있는 다른 모든 오브젝트들

당신의 앱의 메모리 흔적들을 줄이기 위해, 시스템은 당신의 앱이 백그라운드 실행상태로 이동할 때 당신의 앱을 대신해서 할당된 일부 데이터들을 자동으로 삭제한다.

- 시스템은 모든 Core Animation Layers 에 쓰이는 backing store 를 삭제한다.(?) 이런 수행은 메모리로부터 당신의 앱의 layer 오브젝트들을 삭제하지 않고, 현재의 layer 프로퍼티들을 바꾸지도 않는다. 그것은 단순히 그런 레이어의 컨텐츠들이 스크린에 등장하는 것을 막는데, 이는 백그라운드 실행상태의 앱이 어떻게든 실행되지 않도록 주어진다.

- 캐쉬에 저장된 이미지들의 시스템 레퍼런스들을 삭제한다. (만약 당신의 앱이 이미지들에 strong 레퍼런스를 가지고 있지 않다면, 그들은 메모리로부터 차후에 삭제될 것이다).

- 다른 시스템에 의해 관리된 캐쉬 데이터들의 strong 레퍼런스 들을 삭제한다.


Returning to the Foreground



실행상태로 돌아오는 것은 앱이 백그라운드 실행상태로 갔을 때 멈췄던 작업들을 다시 시작할 기회이다. 실행상태로 이동할 때 발생하는 단계들은 Figure 3-6. 에 나와있다. applicationWillEnterForeground: 메소드는 당신의 applicationDidEnterBackground: 메소드에서 행해진 모든 것들을 되돌려야(undo) 한다. 그리고 applicationDidBecomeActive: 메소드는 시작시간에 있었던 동일한 활성화 작업들을 계속해서 수행해야 한다.

Figure 3-6. 백그라운드 실행상태에서 실행상태로의 변이 (Transitioning from the background to foreground)

(그림 생략)


주의 : UIApplicationWillEnterForegroundNotification 알림 또한 당신의 앱이 실행상태로 다시 들어갈 때 트랙킹하는 데 사용될 수 있다. 당신이 앱의 오브젝트들은 이 알림에 등록을 위한 기본 알림 센터를 사용할 수 있다.



Processing Queued Notifications at Wakeup Time
[##_http://yagom.tistory.com/script/powerEditor/pages/1C%7Ccfile27.uf@2136443F50E41D0804B24A.png%7Cwidth=%22824%22%20height=%22109%22%20alt=%22%22%20filename=%2221.png%22%20filemime=%22image/jpeg%22%7C_##]
잠자기(suspended) 상태에 있던 어플은 실행상태나 백그라운드 실행상태로 돌아올 때 모든 대기중인 알림을 다룰 준비가 되어있어야 한다. 잠자기(Suspended) 상태 앱은 어떤 코드도 실행하지 못하므로 가로,세로의 방향 변화, 시간 변화, 설정(preference) 변화 및 앱의 보이는 모습이나 상태에 영향을 줄 수 있는 다른 많은 것들에 관련된 알림을 처리할 수 없다. 이런 변화들이 손실되지 않게끔 확신하기 위해서, 시스템은 많은 관련 알림들을 큐로 내보내고 다시 코드를 시작하는 순간 (실행상태이든 백그라운드 실행상태이든) 앱에게 그 내용들을 전달한다. 재개했을 때, 알림이 오버로딩되는 걸 막기 위해서, 시스템은 이벤트들을 합치고 앱이 잠자기(suspended) 된 이후의 순수 변화만을 반영하는 하나의 알림 (또는 각각 관련된 타입들)을 전달한다.
Table 3-2. 는 합쳐져서 당신의 앱으로 전달될 수 있는 알림들을 나열했다. 이 알림들의 대부분은 등록된 옵저버들에게 직접적으로 전달된다. 장치의 화면 출력방향 (가로, 세로) 변화에 관련된 것들은 일반적으로 시스템 framework 에 의해 인터셉트되어 다른 방식으로 당신의 앱에게 전달된다.
Table 3-2.  깨어있는 앱들에 전달되는 알림들 (Notifications delivered to waking apps)



- 악세사리가 탈착 또는 부착될 때
- 기기의 가로 또는 세로로 방향 전환을 할 때
- 시간대가 변경될 때
- 배터리가 저전력 상태로 변경될 때
- 근접 센서가 작동할 때
- 보호된 파일이 변경되었을 때
- 외부 디스플레이에 연결되거나 해제되었을 때
- 디스플레이 모드가 변경되었을 때
- 설정 앱에서 내 어플의 설정이 변경되었을 때
- 언어 또는 지역이 변경되었을 때
- 사용자의 iCloud 계정이 변경되었을 때

[##_http://yagom.tistory.com/script/powerEditor/pages/1C%7Ccfile1.uf@14343D4050E41D290FFDD1.png%7Cwidth=%22824%22%20height=%2293%22%20alt=%22%22%20filename=%2223.png%22%20filemime=%22image/jpeg%22%7C_##]대기된 알림들은 당신의 앱의 메인 run loop 에 전달되고 일반적으로 다른 터치 이벤트나 다른 사용자 입력 이전에 전달된다. 대부분의 앱들은 재개되었을 때 사용자가 알아차릴 수 있는 정도의 지연이 일어나지 않을 정도로 충분히 신속하게 이런 이벤트들을 전달할 수 있어야만 한다. 그러나, 만약 당신의 앱이 백그라운드 실행상태에서 돌아왔을 때 느리게 움직이는 모습을 보인다면 당신의 알림 전달 코드가 그 지연을 일으키고 있는지 결정할 Instruments 를 사용해라.

실행상태로 돌아온 앱은 또한 마지막 업데이트 이후로 어지러워진(marked dirty) 어떤 뷰에 대해서도 뷰-업데이트 알림을 받는다. 백그라운드 실행상태에서 돌아가고 있는 앱은 여전시 setNeedDisplay 나 setNeedsDisplayInRect: 메소드들을 그 뷰의 업데이트를 요청하기 위해 호출할 수 있다. 그러나, 뷰들은 보이지 않기 때문에, 시스템은 요청들을 합치고, 앱이 실행상태로 돌아오고 난 뒤에 뷰들을 업데이트한다.


Handling iCloud Changes



만약 iCloud 의 상태가 어떤 이유든지 변하게 되면, 시스템은 당신의 앱에 NSUbiquityIdentityDidChangeNotification 알림을 전송한다. iCloud 상태는 사용자가 iCloud 계정에 로그인 혹은 아웃을 하거나 문서와 데이터의 싱크(syncing)가 가능해지거나 불가능해지는 상태로 변하게 된다. 이 알림은 변화를 수용하기 위한 캐시메모리나 모든 iCloud 관련 사용자 인터페이스 요소들을 업데이트하라는 신호이다. 예를 들면, 사용자가 iCloud 로그아웃을 했을 경우, 당신은 iCloud 기반의 모든 파일과 데이터들의 reference 를 삭제해야만 한다.

만약 당신의 앱이 이미 iCloud 에 파일을 저장할 것인지에 대해 사용자에게 전달하였다면, iCloud 상태가 변했을 때 다시 전달할 필요는 없다. 사용자에게 처음으로 전달한 후에, 당신의 앱의 위치 설정들에서 사용자의 선택을 저장해라. 당신은 그러고 나면 그 설정을 Setting 번들을 사용하거나 당신의 앱의 옵션으로서 드러내길 원할수도 있다(?). 그러나 설정이 현재 사용자 기본 데이터베이스에 있지 않다면, 그 프롬프트를 반복할 필요는 없다.


Handling Locale Changes Gracefully
[##_http://yagom.tistory.com/script/powerEditor/pages/1C%7Ccfile25.uf@16316C4650E41D4D06368A.png%7Cwidth=%22824%22%20height=%22138%22%20alt=%22%22%20filename=%2225.png%22%20filemime=%22image/jpeg%22%7C_##]만약 사용자가 당신의 앱이 잠자기(suspended) 되어있는 동안 현재 언어를 변경한다면, 당신은 당신의 앱이 실행상태로 돌아왔을 때, 날짜, 시간, 숫자같은 지역(Locale)에 민감하게 관련된 정보들을 담고 있는 모든 뷰를 업데이트하도록 NSCurrentLocaleDidChangeNotification 알림을 사용할 수 있다. 물론, 언어관련된 문제점들을 피하는 가장 좋은 방법은 당신의 코드를 업데이트 뷰를 쉽게 만들 수 있는 방법으로 작성하는 것이다. 예를 들면:

- NSLocale 오브젝트들을 다시 받았을 때, autoupdatingCurrentLocale 클래스 메소드를 사용하여라. 이 메소드는 변화에 대응해서 자동으로 스스로를 업데이트 해주는 지역기반 오브젝트를 반환한다. 그래서 당신은 그것을 다시만들 필요가 없다. 그러나, 지역 변화가 일어났을 때, 당신은 여전히 현재 지역에서 전달된 내용을 포함하고 있는 뷰들을 리프레쉬 해줄 필요가 있다.

- 현재 지역 정보가 변할 때마다 캐쉬에 저장된 날짜나 숫자 formatter 오브젝트들을 다시 만들어라.
지역 변화를 다루도록 당신의 코드를 세계화하는 데 더 많은 정보를 찾는다면, Internationalization Programming Topics 를 보십시오.


Responding to Changes in Your App's Settings



만약, 당신의 앱이 셋팅 앱(Setting app)에 의해 관리되는 셋팅을 가졌다면, 당신의 앱은 NSUserDefaultsDidChangeNotification 알림을 관찰해야만 한다. 사용자는 당신의 앱이 잠자기(suspended) 상태이거나 백그라운드 실행상태인 동안 셋팅을 수정할 수 있으므로, 그러한 셋팅에서 중요한 모든 변화에 대해 응답하기 위한 이런 알림을 사용할 수 있다. 어떤 경우에서는, 이 알림에 대해 응답하는 것이 잠재적인 보안 구멍을 없애는 데 도움을 줄 수 있다. 예를 들면, 이메일 프로그램은 사용자의 계정 정보의 변화에 반응해야만 한다. 이런 변화들의 감지 실패는 프라이버시, 보안 문제점들을 야기시킬 수 있다. 구체적으로, 현재 사용자들은 계정이 더이상 그 사람에게 속해있지 않은 경우에도 예전의 계정 정보를 사용하여 이메일을 보낼 수도 있다.


NSUserDefaultsDidChangeNotification 알림을 받을 때, 당신의 앱은 모든 관련 셋팅들을 다시 로딩해야만 하고, 필요하다면 그 사용자 인터페이스를 적절하게 리셋해야 한다. 비밀번호나 다른 보안관련 정보가 변경된 경우에는, 당신은 또한 이전에 표시된 정보들을 가려야만 하고, 사용자들에게 새로운 비밀번호를 입력하도록 만들어야 한다.


App Termination
[##_http://yagom.tistory.com/script/powerEditor/pages/1C%7Ccfile4.uf@203FD84550E41D6E22F083.png%7Cwidth=%22824%22%20height=%22233%22%20alt=%22%22%20filename=%2227.png%22%20filemime=%22image/jpeg%22%7C_##]비록 일반적으로 앱들이 백그라운드 실행상태나 잠자기(suspended) 상태로 이동하였더라도, 다음에 나오는 조건들이 참값이라면, 당신의 앱은 종료되고, 메모리로부터 삭제된다.
- 앱이 iOS 4.0 이전의 버전에 반하는 연결이 되었다.
- 앱이 iOS 4.0 이전의 버전을 실행하는 장치에 배치되었다.
- 현재 장치가 멀티테스킹을 지원하지 않는다; "Determining Whether Multitasking Is Available)"을 보십시오.
- 앱이 Info.plist 파일에 UIApplicationExitsOnSuspended 키를 포함한다.; "Opting out of Background Execution" 을 보십시오.


만약 당신의 앱이 (실행상태든 백그라운드 실행상태든) 종료 시기에 실행되고 있다면, 시스템은 당신의 앱 엘리게이트의 applicationWillTerminate: 메소드를 호출하여 당신이 필요한 모든 정리(Cleanup) 을 수행할 수 있게 해준다. 당신은 현재 상태를 다음 실행 때 복원하기 위해 사용하게 되는 앱 상태 정보나 사용자 데이터 등을 저장하기 위해 이 메소드를 사용할 수 있다. 당신의 메소드는 모든 작업을 수행하고 반환하는 데 약 5초의 시간을 가질 수 있다. 만약 시간 내에 반환하지 못한다면, 앱은 메모리로부터 삭제되고 종료될 것이다.

중요: TheapplicationWillTerminate: 메소드는 만약 당신의 앱이 현재 잠자기(suspended) 상태라면 호출되지 않는다.


당신이 당신의 앱을 iOS SDK4 나 이후 버전을 사용해서 개발하는 경우, 당신은 아무 통지없이 당신의 앱이 종료되는 것에 대해 준비되어야만 한다. 사용자는 멀티태스킹 UI 를 사용하여 분명하게 앱을 종료시킬 수 있다. 게다가, 만약 메모리가 제한되었다면, 시스템은 더 많은 공간을 만들어내기 위해 앱을 메모리로부터 제거할 수도 있다. 잠자기(suspended) 상태의 앱들은 종료의 통지를 받지 않는다, 그러나 만약 당신의 앱이 백그라운드 실행 상태(잠자기(suspended) 상태가 아니라)에서 현재 돌아가고 있다면, 시스템은 당신의 앱 델리게이트의 applicationWillTerminate: 메소드를 호출한다. 당신의 앱은 이 메소드로부터 추가적인 백그라운드 실행상태 수행 시간을 요청할 수 없다.




by yagom

facebook : http://fb.yagom.net

twitter : http://twitter.yagom.net ( @yagomsoft )

p.s 제 포스팅을 RSS 피드로 받아보실 수 있습니다.

RSS Feed 받기   


↓↓↓저 열심히 썼는데 손가락 한방 꾹 눌러주고 가시는 건 어떨까요? 로그인이 필요 없습니다. ^~^ 고맙습니다~ ↓↓↓ 





저작자 표시 비영리 변경 금지
신고
Posted by yagom

C <20>. enum

C 2012.05.24 12:30

오늘의 주제

1. enum


벌써 스무 번째 시간입니다.^^

지난 번에 연결리스트에 대해 알아보았는데요 ㅎ 어려우셨죠?
요번에는 잠시 쉬어갈 겸 간단한 녀석 하나 들고 왔습니다~
이런 녀석도 있구나~
알고 가시면 될 듯 합니다.

자 그럼 상쾌한 기분으로 출발 해 볼까요?
고고씽~~~~~~~~~~~~




# enum

지난 번에 전처리자를 이야기 하면서 enum에 대하여 스치듯이 이야기 해 드린 것 같은데요 그때 소개해 드리지 못해 이번에 소개해 드리려 합니다.

enum은 상수 세트를 선언 해 줄 수 있습니다.

주로 어떤 상수 Flag를 지정해 줄 때 사용하게 되는데요, 그게 무슨 뜻이냐 하면 

내가 프로그램 안에서의 약속을 

상태1 == 0
상태2 == 1
상태3 == 2

으로 표현 간단히 해 주고 싶을 때 사용하게 됩니다.

뭐, 일단 알아두시고 나중에 프로그램을 짤 때 아! 이거 써먹으면 편하겠다! 라는 생각이 들 때가 올거예요 ㅎ 

언제 한 번 사용 해볼 때가 있으면 저도 다시 소개 해 드릴게요 ㅎ

오늘은 간단한 코드만 하나 내려놓고 갑니다~^^*


실행 해 보세요~

아까 말씀드렸다시피 enum으로는 상수형 정수만 표현이 가능합니다.

enum안에서 다음번의 순서에 있는 녀석에 특별히 숫자를 대입해 주지 않는다면, 이전 숫자에 +1 이 되어 들어갑니다.

직접 실행해서 확인해 보시는 방법이 가장 빠르겠네용 ㅎ

그럼 저는 이만~!

다음엔 뭘 가지고 나타나 볼까요 ㅎㅎ


by yagom

twitter : @yagomsoft

p.s 제 포스팅을 RSS 피드로 받아보실 수 있습니다.

RSS Feed 받기   


↓↓↓저 열심히 썼는데 추천 한방 꾹 눌러주고 가시는 건 어떨까요? 로그인이 필요 없습니다. ^~^ 고맙습니다~ ↓↓↓ 



저작자 표시 비영리 변경 금지
신고

'C' 카테고리의 다른 글

C <20>. enum  (4) 2012.05.24
C <18>. 연결리스트 (Linked list) - 자료구조(1)  (0) 2012.05.21
C <17>. 동적할당  (2) 2012.05.18
C <16>. 구조체  (2) 2012.05.16
C <15>. 전처리자  (0) 2012.05.14
C <14>. 배열  (4) 2012.05.11
Posted by yagom

오늘의 주제

1. 연결 리스트 (Linked list)


열 여덟 번째 시간입니다.^^

지난 번에 동적 할당에 대하여 알아보았습니다~
오늘은 동적 할당과 구조체를 알고 계셔야 이해할 수 있습니다.ㅎ

2012/05/16 - [C] - C <16>. 구조체

2012/05/18 - [C] - C <17>. 동적할당

자. 오늘 내용은 난이도가 쪼깨 있습니다~
처음 보시는 분들은 다섯 번은 봐야 이해가 될랑 말랑 하실거예요..ㅎㅎ
물론 C의 문법은 아닙니다만(사실 C의 중요한 문법은 거의 끝났다고 봐야겠죠?), 자료구조 공부하심에 있어서 도움이 되실거예요~
정말 중요한 것이니 몇 번을 보고, 다른 싸이트를 검색하고, 직접 계속 둘러보면서 꼭 몸으로 익히도록 하세요~!

자 험난한 여정을 함께 즐겨 볼까요?ㅎ
스따뚜~~~~~~~~~~~~


# 연결리스트

연결리스트 입니다.
이녀석은 언뜻 보면 배열과 비슷합니다.
하지만 동작 방식과 생성 방식은 크게 다르죠~

배열은 메모리 상에서 다닥다닥 서로 붙어있기 때문에 접근하기 용이 합니다. 하지만 우리가 마음대로 개수를 늘렸다 줄였다 할 수가 없지요.

그래서 우리는 연결 리스트라는 녀석을 고안해 냅니다. 쭈욱 늘어선 녀석들을 자유롭게 추가/삭제 할 수 있게 된 겁니다~

하지만, 기본적으로 C에서 주어진 자료형이 아닌, 우리가 직접 스스로 만들어야 하는 어려움이 있습니다.

코드의 양이 적지 않습니다~

잘 따라오세요^^ 물론 역시나 상세한 설명은 주석으로 남깁니다.

헤더 파일입니다.  (yagom.h)
연결리스트의 원소가 될 구조체를 처음에 선언 해 두었구요.
연결리스트 관리를 위한 함수들을 선언해 주었습니다.


구현 파일입니다. (yagom.c)
메인 함수를 구현합니다.


그 후에 헤더에 선언해 놓았던 함수들을 메인함수 아래쪽에 차례대로 작성해 줍니다.


그리고 실행을 해 볼까요?


자 이런식으로 우리는 연결리스트를 배열처럼 사용 할 수 있습니다.

어떤가요? 연결리스트라는 녀석, 비록 복잡하고 속도는 느리지만 용도에 따라 적절히 사용한다면 정말 매력적이 녀석이 됩니다^^*

그럼 다음에 또 뵈어요~^^*

by yagom

twitter : @yagomsoft

p.s 제 포스팅을 RSS 피드로 받아보실 수 있습니다.

RSS Feed 받기   


↓↓↓저 열심히 썼는데 추천 한방 꾹 눌러주고 가시는 건 어떨까요? 로그인이 필요 없습니다. ^~^ 고맙습니다~ ↓↓↓ 



저작자 표시 비영리 변경 금지
신고

'C' 카테고리의 다른 글

C <20>. enum  (4) 2012.05.24
C <18>. 연결리스트 (Linked list) - 자료구조(1)  (0) 2012.05.21
C <17>. 동적할당  (2) 2012.05.18
C <16>. 구조체  (2) 2012.05.16
C <15>. 전처리자  (0) 2012.05.14
C <14>. 배열  (4) 2012.05.11
Posted by yagom

C <17>. 동적할당

C 2012.05.18 12:30

오늘의 주제

1. 동적할당 malloc 


열 일곱 번째 시간입니다.^^

지난 번에는 구조체에 대하여 알아보았습니다.
구조체라는 녀석도 꽤나 매력적인 녀석입니다.
예를 들어 한 사람의 정보를 구조체 하나에 담을 수도 있구요(이름, 나이, 성별, 직업 등등)...
복합적인 자료를 관리하기 참 편리할 것 같죠?ㅎ

그리고 저번에 배웠던 배력적인 배열에 대해서도 잠깐 생각해 보도록 해요.
2012/05/11 - [C] - C <14>. 배열
ㅂㅐ열에서 우리는 하나의 의문을 가지고 끝을 맺었었죠.

배열의 크기는 조절 할 수 없는가 였는데요.
네, 조절할 수 없으므로, 필요에 따라서 우리가 원하는 크기만큼 할당하는 것이 좋겠죠?

그런데 우리가 개발을 하면서 이 배열은 딱 이 사이즈면 돼. 라고 말할 수 있는 경우는 많지 않습니다.
때에 따라 너무 다를 수 있으니까요.

그래서 배열을 때에 따라 상황에 맞게 할당 할 수 있는 기능이 있습니다.

물론 배열에 국한된 것은 아니지만 주로 배열에서 사용하게 되므로 배열로 예를 들어서 설명해 보겠습니다.

정말 중요한 것이니 몇 번을 보고, 다른 싸이트를 검색하고, 직접 계속 둘러보면서 꼭 몸으로 익히도록 하세요~! ^^

스따뚜~~~~~~~~~~~~

그 전에 추천 한 방 어떠세요?ㅎ 저에게 큰 힘이 됩니다 +_+ㅋ



# 동적할당 malloc

malloc이라는 함수가 하는 역할은 우리가 원하는 크기의 자료를 메모리에 할당하고 그 주소값을 다시 되돌려 주는 역할을 합니다.
즉, 입력값은 원하는 크기, 리턴값은 메모리의 주소 입니다.

사용방법은

포인터 변수 = (포인터의 자료형 종류)malloc(원하는 자료크기);

이런식으로 사용합니다.

잘 감이 안오시죠?ㅎ 예제를 봐도 감이 올랑말랑 할겁니다 ㅎ

그래도 한 번 예제 소스 보시죠~ 자세한 설명은 역시나 주석으로 ^^

 
지난 번 배열의 비밀에서 배열의 이름은 배열 첫 머리 원소의 주소가 된다고 말씀 드렸죠?ㅎ
그것을 여기서 멋들어지게 써먹는 겁니다~
배열을 메모리에 할당을 해주고 그 첫머리의 주소값을 포인터 변수에 넣어주는 것이죠 ㅎ
그러면 배열과 똑같은 역할을 하게 되는 것이죠~

참! 그리고 malloc을 한 후에 사용을 끝냈으면 꼭 free를 호출해서 메모리에 할당하였던 녀석을 풀어주어야 합니다~
안그러면 메모리에 좀비처럼 남겨져서 메모리가 필요할 때 사용을 할 수가 없어요^^&

그럼 결과를 한 번 볼까요?



자, 숫자는 랜덤으로 들어갔기 때문에 숫자는 다를 수가 있어요 ㅎ

어떤가요? malloc이라는 녀석 매력적인가요?ㅎ

부족하거나 더 궁금한 점이 있다면 주저말고 댓글 주세요~^^*

그럼 전 이만...!


by yagom

twitter : @yagomsoft

p.s 제 포스팅을 RSS 피드로 받아보실 수 있습니다.

RSS Feed 받기   


↓↓↓저 열심히 썼는데 추천 한방 꾹 눌러주고 가시는 건 어떨까요? 로그인이 필요 없습니다. ^~^ 고맙습니다~ ↓↓↓ 



저작자 표시 비영리 변경 금지
신고

'C' 카테고리의 다른 글

C <20>. enum  (4) 2012.05.24
C <18>. 연결리스트 (Linked list) - 자료구조(1)  (0) 2012.05.21
C <17>. 동적할당  (2) 2012.05.18
C <16>. 구조체  (2) 2012.05.16
C <15>. 전처리자  (0) 2012.05.14
C <14>. 배열  (4) 2012.05.11
Posted by yagom

C <16>. 구조체

C 2012.05.16 12:30

오늘의 주제

1. 구조체 


열 여섯 번째 시간입니다.^^

지난 번에는 전처리자에 대해 알아보았습니다.
잘만 사용하면 좋지만, 잘못 사용한다면 독이 될 수 있는 녀석입니다.
사용에 유의하세요^^

오늘은 또 하나의 개념 구조체에 대해 알아보도록 하겠습니다.

자 그럼 이제 시작해 볼까요?^^
스따뚜~~~~~~~~~~~~

그 전에 추천 한 방 부탁~~~~~~~해요~~~~~~
저에게 큰 힘이 됩니다. ^~^




# 구조체의 개념


간단 합니다.
이 녀석은 배열과는 다르게 서로 다른 종류의 자료들이 들어갈 수 있습니다.

큰~~~~~~~ 박스 안에 서로 다른 크기의 작은 박스들이 들어가 있는 형태라고 보시면 되겠습니다.

그래서 우리가 큰 박스를 만들고 그 안에 작은 박스들을 만들어 넣습니다.

선언하는 방법은

struct 구조체이름 {
  내용물(변수들 선언)
} 구조체변수이름;


한 번 구조체 이름으로 선언 해 주면
다음 번에는 
struct 구조체이름 구조체변수이름;
이라고 선언 해 줄 수도 있습니다.

구조체 안의 변수에 접근하는 방법은

구조체변수명.내용물변수이름

이런식으로 접근하게 됩니다.

말로 하니까 어렵네요 ㅎ 예제를 한 번 봅시다요~

# 구조체 예제
 


yagom이라는 이름의 구조체를 tYagom, tAgainYagom 이라고 선언해 준 형태입니다.
yagom이라는 이름의 구조체 안에는 int형 변수 nNum과 char 포인터형 변수 szName이 들어가 있네요~
그곳에 접근하는 방법은 .  을 통해서 접근하는 것이죠.


결과 캡쳐입니다. 다들 예상대로 출력이 되었나요?ㅎ

그런데 구조체를 선언 할 때 마다 struct yagom 이렇게 하기가 좀 귀찬습니다...ㅎㅎ

그래서 조금이라도 더 간단히 하기 위해서 우리는 이렇게도 선언을 할 수 있습니다.

typedef 라는 녀석을 이용하는데요.

typedef는 어떠한 형태의 타입을 나는 이렇게 정의 하겠다, 라고 말해주는 것으로써 #define이랑 하는 짓은 비슷합니다만, 정의 해 줄 녀석이 아무거나가 아니라 자료형이라는 점이 다릅니다.

typedef int my;
이런 식으로 해주면
int a; 라고 선언 한 것과 my a; 라고 선언 한 것과 동일한 효과를 가져오게 됩니다.

그러므로 typedef struct yagom{ ...} yagom; 이런 식으로 선언을 해준다면 struct yagom{...} 과 yagom과 같아지는 효과를 보게 되겠지요.

말로는 잘 이해가 다가오지 않죠?ㅎ 실습 해 봅시다.


위에 그림처럼 struct yagom을 한 것과 그냥 yagom이라고 한 것과 같은 효과를 볼 수가 있네요~


자, 이렇게 해서 구조체에 대해 간단히 알아보았습니다.

참, 오늘 빼먹은 것이 있는데, 만약 구조체의 포인터변수에서 내부의 변수에 접근을 하려면 . 을 사용하는 것이 아니라 ->을 사용하게 됩니다.

잘 이해가 안가시면 다다음 번 포스팅 때 제대로 볼 수 있으실 거예요~ㅎ

그럼 다음에 또 뵈어요~^^&

by yagom

twitter : @yagomsoft

p.s 제 포스팅을 RSS 피드로 받아보실 수 있습니다.

RSS Feed 받기   


↓↓↓저 열심히 썼는데 추천 한방 꾹 눌러주고 가시는 건 어떨까요? 로그인이 필요 없습니다. ^~^ 고맙습니다~ ↓↓↓ 



저작자 표시 비영리 변경 금지
신고

'C' 카테고리의 다른 글

C <18>. 연결리스트 (Linked list) - 자료구조(1)  (0) 2012.05.21
C <17>. 동적할당  (2) 2012.05.18
C <16>. 구조체  (2) 2012.05.16
C <15>. 전처리자  (0) 2012.05.14
C <14>. 배열  (4) 2012.05.11
C <13>. 변수의 범위  (0) 2012.04.05
Posted by yagom

C <14>. 배열

C 2012.05.11 12:30

오늘의 주제

1. 배열 


열 네번째 시간입니다.^^

지난 번에는 변수의 범위에 대하여 알아보았습니다.
감이 조금 오실지는 잘 모르겠습니다^^;
혹여나 부족한 부분이 있다면 말씀해 주세요 ㅎ
이번에는 또 하나 중요한 개념인 배열에 대하여 알아보도록 하겠습니다.

출발!!!!

자, 시작전에 추천 한 방 어떠세요?ㅎ



# 배열이란?

자, 배열이란 무엇일까요?

配列
 
나눌 배, 벌일 열.

사전에는
"동일한 성격의 데이터를 관리하기 쉽도록 하나로 묶는 ."
이라고 정의되어 있네요 ㅎ

자, 쉽게 한 번 알아봅시다.



위에는 제가 발로그린 배열의 개념도 입니다.

위의 정의에서 보듯이 배열은 같은 종류의 데이터를 줄세워 놓은 녀석을 말합니다.

그림에서 보듯이 배열은 같은 크기의 상자들이 쭈욱 붙어서 늘어서 있습니다. 
 
배열의 선언방법은

자료형 배열이름[배열크기];

입니다.

초기화 방법은 여러가지가 있습니다만 

5개의 배열에 하나씩 넣어주려면 위의 그림처럼 초기화 해 줄 수 있구요,

int arr[100] = { 0, };

으로 초기화하면 모든 원소의 값이 0으로 초기화 됩니다.

배열의 index는 0부터 시작합니다.

위의 그림에도 보듯이 5칸 배열을 선언을 해 주었는데

index는 0부터 시작을 하므로 index값이 0으로 시작하여 4로 끝나게 되지요.

위의 그림에서 

rgIntArray[0]에는 1이, rgIntArray[1]에는 3이... 이런식으로 들어가 있을 겁니다.

그래서 맨 첫칸의 자료를 변경하거나 읽어오려면 rgIntArray[0] 라고 하면 변수처럼 사용이 가능한 것입니다.

개념이 조금 잡히시나요?

배열은 단지 같은 유형의 데이터를 쭈욱 늘어놓은 것이라고 생각하시면 되겠습니다.^^


# 배열과 포인터
 

여기서 배열의 비밀을 하나 말씀드리려 합니다.

배열을 사용하게되면 같은 유형의 자료들을 모아놓고 쓸 수 있는 편한점이 있지만 이 외에도 좋은 점이 있습니다.

배열 자체를 포인터로 접근이 가능하다는 점입니다.

포인터에 대해서 잘 모르시겠다구요?

지난 포스팅을 참고해 주세요...^^

2012/03/23 - [C] - C <10>. 포인터 (1)개념잡기
2012/03/27 - [C] - C <11>. 포인터 (2)간단실습

'배열을 포인터로 사용이 가능하다고???'

무슨 말일까요?



자. 배열에서 각각의 자료를 불러오거나 저장할 때

배열명[index]로 변수처럼 사용한다고 말씀드렸죠?

그런데 만약에 함수(2012/04/02 - [C] - C <12>. 함수)를 사용할 때, 인자로 배열을 넘겨야 할 때...

이녀석들을 하나하나 다 넘길 수가 없겠죠?

그래서 인자를 넘길때는 해당 자료형의 포인터값으로 넘어가게 됩니다.

그래서 함수 안에서 이 배열 통채를 사용 할 수 있게 됩니다.

배열의 원소들은 메모리 안에서 위에 그림처럼 다닥다닥 붙어있게 됩니다.

그렇기 때문에 배열의 첫머리의 주소만 알면 그 다음녀석, 그 다다음 녀석도 메모리상의 어느 위치에 있는지 쉽게 알 수 있게되는거죠.

이해가 되시려나요? +_+

그래서 그림처럼 rgIntArray 라고 변수처럼 사용하면 이녀석은 배열의 첫 번째 원소를 가리키는 포인터값입니다.

그녀석에 +1을 해주면 그 다음칸 녀석의 주소를 가리키게 되는 것입니다. 그런식으로 rgIntArray+2면 rgIntArray의 주소값이 겠죠?

이해가 안되면 실습으로 궁금증을 풀어봅시다..ㅎㅎ

# 실습해보기 

자세한 코드 설명은 주석에 달려있으므로 참고하시기 바랍니다~!
yagom.h 파일에는

#include <stdio.h>
#include <stdlib.h>

만 작성되어 있습니다.



자, 실행 결과입니다.
자신의 실행결과와 일치하나요?ㅎ


여기까지 배열에 관하여 간단히 알아보았습니다.

문자 배열 ( char[] )는 문자열로 사용이 가능합니다.

printf와 같은 함수에서 %s로 문자열 출력이 가능하지요.

대신 문자열의 맨 마지막은 null (\0)으로 끝나야 합니다.

2차원, 다차원 배열도 있지만 그것도 어렵게 생각하실 필요가 없습니다.

쉽게 쉽게 생각해 보세요~

따로 포스팅할 필요를 잘 못느껴서 하진 않지만,

누군가 요청해 주시면 다차원 배열에 대해서도 한 번 알아보도록 하겠습니다~^^&


자, 그럼 여기서 생길만한 의문점..!!

Q : 배열을 생성해 놓고 배열의 크기나 종류를 변경 할 수는 없나요?
A : 네, 불가능 합니다. 그렇기 때문에 동적할당이라는 녀석을 사용하게 되는데, 추후에 포스팅 할 예정입니다.

다른 의문점이 또 있다면 댓글 주세요..^^

또 필요한 것이 있다면 말씀해 주세요 ㅎ

by yagom

twitter : @yagomsoft

p.s 제 포스팅을 RSS 피드로 받아보실 수 있습니다.

RSS Feed 받기   


↓↓↓저 열심히 썼는데 추천 한방 꾹 눌러주고 가시는 건 어떨까요? 로그인이 필요 없습니다. ^~^ 고맙습니다~ ↓↓↓ 



저작자 표시 비영리 변경 금지
신고

'C' 카테고리의 다른 글

C <16>. 구조체  (2) 2012.05.16
C <15>. 전처리자  (0) 2012.05.14
C <14>. 배열  (4) 2012.05.11
C <13>. 변수의 범위  (0) 2012.04.05
C <12>. 함수  (4) 2012.04.02
C <11>. 포인터 (2)간단실습  (0) 2012.03.27
Posted by yagom

C <7>. 조건문(2) switch

C 2011.12.14 13:40

오늘의 주제

1. switch문 사용해 보기

일곱 번째 시간입니다.^^

지난 번에는 if 조건문에 대해 알아보았습니다.
이번에는 또다른 조건문인 switch문에 대해 알아보도록 할게요 ㅎ

스따뚜~~~~~~~~~~~~


# switch

자, 일단 만들어 봅시다. 지난번 if문 할 때 만들어 놓았던 프로젝트를 열어 봅시다.
이번에는 switchNumbers() 라는 함수를 만들거예요.
빨간네모를 따라 코드를 작성해 봅시다.ㅎㅎ


위의 코드의 실행 결과 화면입니다.


switch문의 작성법은 이렇습니다.

switch(대상 변수)
{
    case 
정수 혹은 문자 :
           실행할 명령문
           break;
    case 
정수 혹은 문자 :
           실행할 명령문
           break;
    case 정수 혹은 문자 :
           실행할 명령문
           break;
    default :
           실행할 명령문
           break;  
}


자, switch문은 주로 정수형의 변수가 어느 특정 조건을 만족하는지 검사할 때 쓰입니다.

if문과 다른 점은 크거나 작다에 대한 비교를 하기 보다는, 딱 어떤 변수가 어떤 수일때 실행. 을 목표로 하는 조건문입니다.

눈치 채신 분들도 계시겠지만, case 안에 해당되는 수가 없으면 default에 있는 명령어를 실행합니다.

그리고 모든 case아래에 break 명령어가 있는 것이 보이실 텐데요, break문이 없으면 아래에 있는 모든 것들을 다 실행하라는 의미로 받아들여집니다.

한 번 break 없애고 실행해 보세요 ㅎㅎㅎ 어떤 참사하 일어나는지..^^

위의 코드에서는 i가 어떤 수인지 알아보는 코드가 되겠네요.

i가 5 또는 10 또는 17 중에 하나에 해당되면 거기에 맞는 명령이 실행될테구요, 만약 해당되는 것이 없으면 default에 있는 것을 실행합니다.

if조건문과 switch조건문의 특징을 잘 숙지하시고 알앚게 효율적으로 사용하시면 될 것 같습니다^^

사실 if문 보다 switch문의 사용법이나 규제가 좀 더 까다롭지만, if - else if - else if - else...를 한없이 늘어놓는 것 보다 훨씬 간편하게 사용하실 수도 있습니다.

즉, 때에 따라 적절히 ^^


by yagom

p.s 제 포스팅을 RSS 피드로 받아보실 수 있습니다.

RSS Feed 받기   


↓↓↓저 열심히 썼는데 추천 한방 꾹 눌러주고 가시는 건 어떨까요? ^~^ 사랑합니다~ ↓↓↓
저작자 표시 비영리 변경 금지
신고

'C' 카테고리의 다른 글

C <9>. 반복문(2) do-while  (7) 2012.02.06
C <8>. 조건문(3) 3항 연산자  (7) 2012.01.28
C <7>. 조건문(2) switch  (6) 2011.12.14
C <6>. 조건문(1), if, else  (6) 2011.12.11
C <5>. 반복문(1), 단항 연산자  (2) 2011.12.08
C <4>. 실수 표현 방법  (2) 2011.12.04
Posted by yagom


티스토리 툴바