HTML버전은 http://kjune.com/objc/objective-c-kor.html
원본 사이트 : http://www.otierney.net/objective-c.html.ko

개요

• 시작하기
• 이 튜토리얼 다운로드
• 환경설정
• 머리말
• hello world 만들기
• 클래스 만들기
• 인터페이스: @interface
• 구현: @implementation
• 모두 합하기
• 세부적인 내용들
• 매개변수를 여러 개 갖는 경우
• 생성자
• 접근 권한
• 클래스 수준 접근성
• 예외처리
• 상속, 다형성, 그리고 다른 객체 지향 프로그래밍의 기능들
• id 형
• 상속, 다형성, 그리고 다른 객체 지향 프로그래밍의 기능들
• 동적 형
• 카테고리
• 포징
• 프로토콜
• 메모리 관리
• Retain과 Release
• Dealloc
• Autorelease Pool
• Foundation Framework 클래스
• NSArray
• NSDictionary
• 장단점
• 추가 정보

시작하기

이 튜토리얼 다운로드

• 이 가이드에 사용된 소스 코드와 Makefile은 objc.tar.gz에서 다운 받을 수 있다. 이 튜토리얼의 예제들은 Steve Kochan씨가 쓴 Programming in Objective-C에서 인용한 것이다. 더 자세한 정보와 예제가 필요하다면, 이 책을 참조하면 도움이 될 것이다. 이 사이트에서 사용된 예제는 그의 허가를 받고 사용한 것이므로, 다른 곳에 무단 복제를 금지한다.

환경설정

• Linux/FreeBSD: GNUStep를 설치
• GNUStep 어플리케이션을 빌드하기 위해서는 먼저 /usr/GNUstep/System/Makefiles/GNUstep.sh에 있는 GNUstep.sh 스크립트를 실행한다. 경로는 시스템에 따라 다를 수 있다. /usr, 혹은 /usr/lib, 혹은 /usr/local를 찾아볼 것. 만약 사용하는 셀이 csh/tcsh 기반의 쉘이라면, GNUStep.csh를 대신 실행시키면 된다. 이 스크립트를 쉘 설정파일인 .bashrc 이나 .cshrc에 추가하는 것을 추천한다.
• Mac OS X: XCode설치
• Windows NT 5.X: 먼저 cygwin 이나 mingw를 설치한 후에 GNUStep을 설치

머리말

• 이 튜토리얼은 사용자가 기본적인 C 지식이 있다고 전제하고 설명을 하고 있다. C의 데이터형, 함수, 반환값, 포인터와 기본적인 메모리 관리등이 이에 해당된다. 아직 여기까지 내용을 모른다면, 다음의 책을 참조하길 바란다. The C Programming Language. 이 책은 C언어를 만든 사람들이 만든 바로 그 책이다.
• 오브젝티브-C는 C의 파생언어여서 C의 많은 기능을 차용받았다. 하지만 C로 부터 오지 않은 다른 부분들도 있다.
• nil: C/C++ 에서는 NULL이라고 사용하는 데, 오브젝티브-C에서는 nil이라고 한다. 차이점은 nil에게는 메시지를 전달할 수 있다는 점이다. (예를 들면 이런 식으로 [nil message];) 이렇게 해도 괜찮다. 반면 C에서 NULL에게는 이렇게 할 수 없다.
• BOOL: C에는 공식적인 불린 형이 없다. 사실 오브젝티브-C에서도 공식적인 불린형은 없다. 하지만 불린형은 Foundation classes에 포함이 되어서 (NSObject.h를 임포트 함으로써) 그리고 nil도 역시 이 헤더파일로부터 추가된다. 오브젝티브-C에서의 BOOL은 YES나 NO라는 2개의 모드를 갖는다. (TRUE나 FALSE가 아니다.)
• #import 대 #include: 위의 hello world 예제에서 눈치챘겠지만, 파일을 포함할 때 #import를 사용한다. #import는 gcc 컴파일러가 지원한다. 다만 #include를 더 선호하기 때문에 덜 사용되게 될 뿐이다. #import는 사용자가 만든 .h파일의 위와 아래에 #ifndef #define #endif 블럭을 붙이는 것과 같은 일을 한다. 이 블럭을 붙이는 건 정말 멍청한 짓이라고 생각하고, 아마 다른 모든 개발자들도 동의할 것이다. 따라서 그냥 #import를 사용하면 된다. 걱정할 필요도 없고, gcc에서 #import를 제거한다고 해도, 다른 오브젝티브-C 개발자들이 그런 일이 생기지 못하게 할 것이다. 공식적으로 애플에서 #import를 자신들의 코드에 사용하니, 만약 #import가 gcc에서 사라진다고 해도, 애플에서는 gcc를 변형한 버전이라도 출시할 것이다.
• 비록 메시지가 조금 더 특별한 특성을 가지긴 해도, 메소드와 메시지란 단어는 오브젝티브-C에서는 서로 교환 가능한 말이다. 메시지는 동적으로 다른 객체에게 포워딩 될 수 있다. 오브젝티브-C에서 객체의 메시지를 호출한다는 것은 객체가 그 메시지를 구현한 다는 것을 의미하는 것이 아니다. 단지 객체가 메시지가 전달되었을 때 어떻게 반응해야 하는 지를 안다는 뜻이다. 그 방식은 직접 구현을 하거나 혹은 처리방법을 아는 다른 객체에 메시지를 포워딩하는 방식을 사용할 수 있다.

hello world 만들기

• hello.m
  view plaincopy to clipboardprint?

  1. #import <stdio.h>  
  2.   
  3. int main( int argc, const char *argv[] ) {  
  4. printf( "hello world\n" );  
  5. return 0;  
  6. }  
• 결과

  hello world

• 오브젝티브-C에서는 #include 대신에 #import를 사용한다.
• 오브젝티브-C의 기본 확장자는 .m이다.

클래스 만들기

인터페이스 @interface

• 예제의 출처: “Programming in 오브젝티브-C,” Copyright © 2004 출판사 Sams Publishing. 허가 받고 사용함
• Fraction.h
  view plaincopy to clipboardprint?

  1. #import <Foundation/NSObject.h>  
  2.   
  3. @interface Fraction: NSObject {  
  4. int numerator;  
  5. int denominator;  
  6. }  
  7.   
  8. -(void) print;  
  9. -(void) setNumerator: (int) n;  
  10. -(void) setDenominator: (int) d;  
  11. -(int) numerator;  
  12. -(int) denominator;  
  13. @end  
• NSObject: NeXTStep Object의 줄임말. 이제는 OpenStep으로 이름이 바꿔서 의미가 맞지 않긴 하다.
• 상속, 다형성, 그리고 다른 객체 지향 프로그래밍의 기능들은 Class: Parent와 같은 형태로 표현하면 된다. 위의 예제에서는 Fraction: NSObject 부분이다.
• 인스턴스 변수들은 @interface Class: Parent { …. }의 안쪽으로 들어간다.
• 아직 접근 레벨이 정해져 있지 않다. (protected, public, private). 기본은 protected이다. 접근 셋팅하는 법은 뒤에 더 다루겠다.
• 멤버 함수 뒤에는 인스턴스 메소드가 나온다. 포멧은 scope (returnType) methodName: (parameter1Type) parameter1Name;과 같다.
• 스코프(scope)는 매스드가 클래스에서 사용하는지 인스턴스에서 사용하는 지를 판별한다. 인스턴스에서 사용하는 메소드는 -를, 클래스에서 사용하는 메소드는 +로 시작한다.
• 인터페이스는 @end로 끝난다.

@implementation

• 예제의 출처: “Programming in 오브젝티브-C,” Copyright © 2004 출판사 Sams Publishing. 허가 받고 사용함
• Fraction.m
  view plaincopy to clipboardprint?

  1. #import "Fraction.h"  
  2. #import <stdio.h>  
  3.   
  4. @implementation Fraction  
  5. -(void) print {  
  6. printf( "%i/%i", numerator, denominator );  
  7. }  
  8.   
  9. -(void) setNumerator: (int) n {  
  10. numerator = n;  
  11. }  
  12.   
  13. -(void) setDenominator: (int) d {  
  14. denominator = d;  
  15. }  
  16.   
  17. -(int) denominator {  
  18. return denominator;  
  19. }  
  20.   
  21. -(int) numerator {  
  22. return numerator;  
  23. }  
  24. @end  
• 클래스의 구현부분은 @implementation ClassName 으로 시작하고, @end으로 끝난다.
• 모든 정의된 메소드들은 인터페이스에서 정의된 것과 유사한 형태로 구현된다.

모두 합하기

• 예제의 출처: “Programming in 오브젝티브-C,” Copyright © 2004 출판사 Sams Publishing. 허가 받고 사용함
• main.m
  view plaincopy to clipboardprint?

  1. #import <stdio.h>  
  2. #import "Fraction.h"  
  3.   
  4. int main( int argc, const char *argv[] ) {  
  5. // create a new instance  
  6. Fraction *frac = [[Fraction alloc] init];  
  7.   
  8. // set the values  
  9. [frac setNumerator: 1];  
  10. [frac setDenominator: 3];  
  11.   
  12. // print it  
  13. printf( "The fraction is: " );  
  14. [frac print];  
  15. printf( "\n" );  
  16.   
  17. // free memory  
  18. [frac release];  
  19.   
  20. return 0;  
  21. }  
• 결과

  The fraction is: 1/3

• Fraction *frac = [[Fraction alloc] init];
• 이 한 줄에는 몇 가지 중요한 것들이 있다.
• 오브젝티브-C에서 메소드는 [object method]와 같은 형태로 호출된다. C++에서는 object->method() 와 같은 형태로 호출되는 것과 유사하다.
• 오브젝티브-C에는 값 타입이 없다. 다시 말해 C++처럼 Fraction frac; frac.print(); 이런 식으로 코딩하지 않는 다는 뜻이다. 오브젝티브-C에서는 반드시 객체를 포인터를 통해서 다뤄야 한다.
• 이 한 줄에서 실제로는 두 가지 일이 일어난다: [Fraction alloc]은 Fracion 클래스의 alloc 메소드를 호출한다. 이 것은 메모리를 할당하는 것과 유사하다. 이 단계에서 메모리 할당이 일어난다.
• [object init]은 객체 안에 있는 여러 변수들의 값을 초기화하는 생성자 호출이다. 이 메소드는 [Fraction alloc]에 의해서 반환된 인스턴스가 호출한다. 보통 이 과정은 다음과 같은 형태로 한 줄로 이뤄진다. Object* var = [[Object alloc]init];
• [frac setNumerator: 1]은 간단하다. frac객체의 setNumerator 함수를 호출하면서 인자 1을 전달한다.
• 다른 C의 변종들과 마찬가지로, 메모리를 해제하는 구조가 있다. 여기에서는 release를 통해서 처리되었는데, 이는 NSObject에서 상속 받은 것이다. 이에 대해서는 뒤에서 더 자세히 다루겠다.

세부적인 내용들

매개변수를 여러 개 갖는 경우

• 지금까지는 매개변수가 여러 개인 함수는 나오지 않았다. 처음에 보면 방식이 직관적이지 않다는 생각이 드는데, 이 것은 스몰토크(Smalltalk)로 부터 차용해온 것이다.
• 예제의 출처: “Programming in 오브젝티브-C,” Copyright © 2004 출판사 Sams Publishing. 허가 받고 사용함
• Fraction.h
  view plaincopy to clipboardprint?

  1. ...  
  2. -(void) setNumerator: (int) n andDenominator: (int) d;  
  3. ...  
• Fraction.m
  view plaincopy to clipboardprint?

  1. ...  
  2. -(void) setNumerator: (int) n andDenominator: (int) d {  
  3. numerator = n;  
  4. denominator = d;  
  5. }  
  6. ...  
• main.m
  view plaincopy to clipboardprint?

  1. #import <stdio.h>  
  2. #import "Fraction.h"  
  3.   
  4. int main( int argc, const char *argv[] ) {  
  5. // create a new instance  
  6. Fraction *frac = [[Fraction alloc] init];  
  7. Fraction *frac2 = [[Fraction alloc] init];  
  8.   
  9. // set the values  
  10. [frac setNumerator: 1];  
  11. [frac setDenominator: 3];  
  12.   
  13. // combined set  
  14. [frac2 setNumerator: 1 andDenominator: 5];  
  15.   
  16. // print it  
  17. printf( "The fraction is: " );  
  18. [frac print];  
  19. printf( "\n" );  
  20.   
  21. // print it  
  22. printf( "Fraction 2 is: " );  
  23. [frac2 print];  
  24. printf( "\n" );  
  25.   
  26. // free memory  
  27. [frac release];  
  28. [frac2 release];  
  29.   
  30. return 0;  
  31. }  
• 결과

  The fraction is: 1/3
  Fraction 2 is: 1/5

• 메소드는 실제로 setNumerator:andDenominator:를 호출했다.
• 더 많은 인자를 전달하고자 할 때는 두번째 인자를 전달하는 것과 같은 방식으로 하면 된다. method:label1:label2:label3: 그런 다음 호출할 때에는 [obj method: param1 label1: param2 label2: param3 label3: param4]식으로 하면 된다.
• 레이블은 써도 되고 안써도 된다. 메소드 이름을 method:::라고 해도 된다. 레이블 이름을 쓰지 않으면 이렇게 된다. 그리고 a: 를 인자를 구분하기 위해서 사용한다. 하지만, 이 방식을 추천하진 않는다.

생성자

• 예제의 출처: “Programming in 오브젝티브-C,” Copyright © 2004 출판사 Sams Publishing. 허가 받고 사용함
• Fraction.h
  view plaincopy to clipboardprint?

  1. ...  
  2. -(Fraction*) initWithNumerator: (int) n denominator: (int) d;  
  3. ...  
• Fraction.m
  view plaincopy to clipboardprint?

  1. ...  
  2. -(Fraction*) initWithNumerator: (int) n denominator: (int) d {  
  3. self = [super init];  
  4.   
  5. if ( self ) {  
  6. [self setNumerator: n andDenominator: d];  
  7. }  
  8.   
  9. return self;  
  10. }  
  11. ...  
• main.m
  view plaincopy to clipboardprint?

  1. #import <stdio.h>  
  2. #import "Fraction.h"  
  3.   
  4. int main( int argc, const char *argv[] ) {  
  5. // create a new instance  
  6. Fraction *frac = [[Fraction alloc] init];  
  7. Fraction *frac2 = [[Fraction alloc] init];  
  8. Fraction *frac3 = [[Fraction alloc] initWithNumerator: 3 denominator: 10];  
  9.   
  10. // set the values  
  11. [frac setNumerator: 1];  
  12. [frac setDenominator: 3];  
  13.   
  14. // combined set  
  15. [frac2 setNumerator: 1 andDenominator: 5];  
  16.   
  17. // print it  
  18. printf( "The fraction is: " );  
  19. [frac print];  
  20. printf( "\n" );  
  21.   
  22. printf( "Fraction 2 is: " );  
  23. [frac2 print];  
  24. printf( "\n" );  
  25.   
  26. printf( "Fraction 3 is: " );  
  27. [frac3 print];  
  28. printf( "\n" );  
  29.   
  30. // free memory  
  31. [frac release];  
  32. [frac2 release];  
  33. [frac3 release];  
  34.   
  35. return 0;  
  36. }  
• 결과

  The fraction is: 1/3
  Fraction 2 is: 1/5
  Fraction 3 is: 3/10

• @interface선언은 다른 함수들과 동일하다.
• @implementation에 새로운 키워드 super가 등장했다.
• 자바와 마찬가지로 오브젝티브-C에는 오직 한 개의 부모 클래스만을 가진다.
• 부모의 생성자를 호출하기 위해서는 [super init]을 호출한다. 적절하게 상속을 하기 위해서 반드시 해야 한다.
• 여기에 self라는 또 다른 키워드가 등장한다. self는 자기 자신에 대한 인스턴스를 가리킨다. self는 자바나 C++에서의 this와 유사하다.
• if ( self ) 라고 쓰는 것은 if ( self != nil ) 와 동일하다. 부모 클래스의 생성자로부터 성공적으로 새 객체를 생성해서 받아왔다는 것을 보장하기 위해서 사용한 것이다. 오브젝티브-C에서의 nil은 C/C++의 NULL과 같다. NSObject를 포함함으로써 추가되었다.
• 값들을 초기화 한 후에는 return self;를 통해서 자기 자신의 객체를 반환해야 한다.
• 초기 생성자는 -(id) init; 이다.
• 오브젝티브-C에서의 생성자는 단순한 “init” 메소드이다. C++이나 자바에서처럼 특별한 생성자가 있는 것은 아니다.

접근 권한

• 기본 권한은 @protected이다.
• 자바에서는 개별 메소드와 변수 앞에 public/private/protect라고 표시를 한다. 오브젝티브-C는 C++과 유사한 방식이다.
• Access.h
  view plaincopy to clipboardprint?

  1. #import <Foundation/NSObject.h>  
  2.   
  3. @interface Access: NSObject {  
  4. @public  
  5. int publicVar;  
  6. @private  
  7. int privateVar;  
  8. int privateVar2;  
  9. @protected  
  10. int protectedVar;  
  11. }  
  12. @end  
• Access.m
  view plaincopy to clipboardprint?

  1. #import "Access.h"  
  2.   
  3. @implementation Access  
  4. @end  
• main.m
  view plaincopy to clipboardprint?

  1. #import "Access.h"  
  2. #import <stdio.h>  
  3.   
  4. int main( int argc, const char *argv[] ) {  
  5. Access *a = [[Access alloc] init];  
  6.   
  7. // works  
  8. a->publicVar = 5;  
  9. printf( "public var: %i\n", a->publicVar );  
  10.   
  11. // doesn't compile  
  12. //a->privateVar = 10;  
  13. //printf( "private var: %i\n", a->privateVar );  
  14.   
  15. [a release];  
  16. return 0;  
  17. }  
• 결과

  public var: 5

• 위에서 본 바와 같이 C++에서는 private: [list of vars] public: [list of vars]와 같이 표시하는 것을 여기에서는 @private, @protected, 등등으로 표시한다.

클래스 수준 접근성

• 종종 클래스 수준에서 변수와 함수를 조절할 수 있는 것이 필요할 때가 있다. 예를 들어, 객체가 인스턴스화 된 횟수를 추적하고자 할 때와 같은 경우이다.
• ClassA.h
  view plaincopy to clipboardprint?

  1. #import <Foundation/NSObject.h>  
  2.   
  3. static int count;  
  4.   
  5. @interface ClassA: NSObject  
  6. +(int) initCount;  
  7. +(void) initialize;  
  8. @end  
• ClassA.m
  view plaincopy to clipboardprint?

  1. #import "ClassA.h"  
  2.   
  3. @implementation ClassA  
  4. -(id) init {  
  5. self = [super init];  
  6. count++;  
  7. return self;  
  8. }  
  9.   
  10. +(int) initCount {  
  11. return count;  
  12. }  
  13.   
  14. +(void) initialize {  
  15. count = 0;  
  16. }  
  17. @end  
• main.m
  view plaincopy to clipboardprint?

  1. #import "ClassA.h"  
  2. #import <stdio.h>  
  3.   
  4. int main( int argc, const char *argv[] ) {  
  5. ClassA *c1 = [[ClassA alloc] init];  
  6. ClassA *c2 = [[ClassA alloc] init];  
  7.   
  8. // print count  
  9. printf( "ClassA count: %i\n", [ClassA initCount] );  
  10.   
  11. ClassA *c3 = [[ClassA alloc] init];  
  12.   
  13. // print count again  
  14. printf( "ClassA count: %i\n", [ClassA initCount] );  
  15.   
  16. [c1 release];  
  17. [c2 release];  
  18. [c3 release];  
  19.   
  20. return 0;  
  21. }  
• 결과

  ClassA count: 2
  ClassA count: 3

• static int count = 0; 이렇게 클래스 변수를 선언한다. 이 방법이 변수를 보관하는 가장 좋은 방법은 아니다. 자바에서 구현하는 것이 조금 더 좋은 해결책으로 생각되지만, 이 방법도 된다.
• +(int) initCount; 이 함수가 실제로 객수를 반환한다. 눈여겨볼 차이점이 하나가 있는데 형 앞에 -를 쓴 대신 +를 사용했다. +는 클래스 레벨 함수라는 뜻이다.
• 클래스 레벨의 변수를 접근 하는 방식은 일반 멤버 변수를 접근 하는 방식과 동일하다. ClassA의 생성자에 있는 count++를 보면 된다.
• +(void) initialize 메소드는 오브젝티브-C가 프로그램을 시작할 때 호출된다. 그리고 이 모든 클래스에서 호출된다. 따라서 이 예제의 count와 같은 클래스 레벨의 변수를 초기화 하기에 좋은 위치이다.

예외처리

• 참고: 예외 처리는 오직 맥 OS X 10.3에서 지원됩니다.
• 예제의 출처: “Programming in 오브젝티브-C,” Copyright © 2004 출판사 Sams Publishing. 허가 받고 사용함
• CupWarningException.h
  view plaincopy to clipboardprint?

  1. #import <Foundation/NSException.h>  
  2.   
  3. @interface CupWarningException: NSException  
  4. @end  
• CupWarningException.m
  view plaincopy to clipboardprint?

  1. #import "CupWarningException.h"  
  2.   
  3. @implementation CupWarningException  
  4. @end  
• CupOverflowException.h
  view plaincopy to clipboardprint?

  1. #import <Foundation/NSException.h>  
  2.   
  3. @interface CupOverflowException: NSException  
  4. @end  
• CupOverflowException.m
  view plaincopy to clipboardprint?

  1. #import "CupOverflowException.h"  
  2.   
  3. @implementation CupOverflowException  
  4. @end  
• Cup.h
  view plaincopy to clipboardprint?

  1. #import <Foundation/NSObject.h>  
  2.   
  3. @interface Cup: NSObject {  
  4. int level;  
  5. }  
  6.   
  7. -(int) level;  
  8. -(void) setLevel: (int) l;  
  9. -(void) fill;  
  10. -(void) empty;  
  11. -(void) print;  
  12. @end  
• Cup.m
  view plaincopy to clipboardprint?

  1. #import "Cup.h"  
  2. #import "CupOverflowException.h"  
  3. #import "CupWarningException.h"  
  4. #import <Foundation/NSException.h>  
  5. #import <Foundation/NSString.h>  
  6.   
  7. @implementation Cup  
  8. -(id) init {  
  9. self = [super init];  
  10.   
  11. if ( self ) {  
  12. [self setLevel: 0];  
  13. }  
  14.   
  15. return self;  
  16. }  
  17.   
  18. -(int) level {  
  19. return level;  
  20. }  
  21.   
  22. -(void) setLevel: (int) l {  
  23. level = l;  
  24.   
  25. if ( level > 100 ) {  
  26. // throw overflow  
  27. NSException *e = [CupOverflowException  
  28. exceptionWithName: @"CupOverflowException"  
  29. reason: @"The level is above 100"  
  30. userInfo: nil];  
  31. @throw e;  
  32. } else if ( level >= 50 ) {  
  33. // throw warning  
  34. NSException *e = [CupWarningException  
  35. exceptionWithName: @"CupWarningException"  
  36. reason: @"The level is above or at 50"  
  37. userInfo: nil];  
  38. @throw e;  
  39. } else if ( level < 0 ) {  
  40. // throw exception  
  41. NSException *e = [NSException  
  42. exceptionWithName: @"CupUnderflowException"  
  43. reason: @"The level is below 0"  
  44. userInfo: nil];  
  45. @throw e;  
  46. }  
  47. }  
  48.   
  49. -(void) fill {  
  50. [self setLevel: level + 10];  
  51. }  
  52.   
  53. -(void) empty {  
  54. [self setLevel: level - 10];  
  55. }  
  56.   
  57. -(void) print {  
  58. printf( "Cup level is: %i\n", level );  
  59. }  
  60. @end  
• main.m
  view plaincopy to clipboardprint?

  1. #import "Cup.h"  
  2. #import "CupOverflowException.h"  
  3. #import "CupWarningException.h"  
  4. #import <Foundation/NSString.h>  
  5. #import <Foundation/NSException.h>  
  6. #import <Foundation/NSAutoreleasePool.h>  
  7. #import <stdio.h>  
  8.   
  9. int main( int argc, const char *argv[] ) {  
  10. NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];  
  11. Cup *cup = [[Cup alloc] init];  
  12. int i;  
  13.   
  14. // this will work  
  15. for ( i = 0; i < 4; i++ ) {  
  16. [cup fill];  
  17. [cup print];  
  18. }  
  19.   
  20. // this will throw 예외처리  
  21. for ( i = 0; i < 7; i++ ) {  
  22. @try {  
  23. [cup fill];  
  24. } @catch ( CupWarningException *e ) {  
  25. printf( "%s: ", [[e name] cString] );  
  26. } @catch ( CupOverflowException *e ) {  
  27. printf( "%s: ", [[e name] cString] );  
  28. } @finally {  
  29. [cup print];  
  30. }  
  31. }  
  32.   
  33. // throw a generic exception  
  34. @try {  
  35. [cup setLevel: -1];  
  36. } @catch ( NSException *e ) {  
  37. printf( "%s: %s\n", [[e name] cString], [[e reason] cString] );  
  38. }  
  39.   
  40. // free memory  
  41. [cup release];  
  42. [pool release];  
  43. }  
• 결과

  Cup level is: 10
  Cup level is: 20
  Cup level is: 30
  Cup level is: 40
  CupWarningException: Cup level is: 50
  CupWarningException: Cup level is: 60
  CupWarningException: Cup level is: 70
  CupWarningException: Cup level is: 80
  CupWarningException: Cup level is: 90
  CupWarningException: Cup level is: 100
  CupOverflowException: Cup level is: 110
  CupUnderflowException: The level is below 0

• NSAutoreleasePool은 메모리 관리 클래스이다. 지금은 일단 넘어가자.
• 전달 받은 예외를 처리하기 위해서 NSException을 확장할 필요는 없다. 간단히 id를 사용하면 된다. @catch ( id e ) { … }
• 마지막 부분에 finally 블럭이 있다. 자바와 유사하게 작동하는데, finally 블럭에 있는 구문은 반드시 호출되게 되어있다.
• Cub.m에 있는 문자열 @”CupOverflowException”은 NSString 상수 객체이다. 오브젝티브-C에서의 @표시는 언어의 확장을 의미한다. C스트링은 C나 C++과 유사하다. 문자열 상수이고 모두 char*로 만들어져 있다.