Xcode Objective-C Text Macro Cheatsheet For iPhone Programmers

 





출처 : http://blog.naver.com/PostView.nhn?blogId=hextrial&logNo=60119241862
Posted by 오늘마감
역시 ... 아직 회원분들이 많이 안계신 관계로 저부터 썰을 풀기로 했습니다 ㅋㅋㅋ


사례1. 아... 아이폰 어플개발을 할랴는데 맥북이 필요하다는데 맥북부터 질르자.
개발자 전모씨는 일단 성급한 마음에 맥북이랑 아이폰 책을 질러버렸다.
그 없는돈에도..ㅠㅠ

아..한 100 깨지니까 정신이 혼미하네..
큰맘먹고산 맥북을 열고 xcode 도 깔았는데...
아이폰 책은 따라하기 식이긴한데..
문법을 몰르니 ..쩝.. 접어야지

사례2. 맥북을 열긴열었는데.. 복사는 어케하는거야? 'End'키는 어디있는거야.
개발자 전모씨는 프로그램 개발에 앞서서 매킨토시 사용법부터 익히기로했다.
아이폰 어플개발은.. 저기..멀리 날아가나..

ㅎㅎ 음. 뭔가 사례를 들라고했는데 재미가없군요.
눈치채셨다시피..개발자 전모씨는 접니다 -.-;

일단 아이폰 어플개발하기전에 Objective-C 언어를 익혀야되는데요.
제가 경험한 바로는 Objective-C 기초를 익히는 단계에선 아직 맥북이
필요 없다는겁니다.

첨부터 괜히 질른거죠.
Window 환경에서 Objective-C를 먼저 익히고 그담에 맥으로 넘어갑시다.

윈도우 환경설정 시작합니당.~~

1. 필요한 파일을 다운받읍시당
GNUstep System  0.24.0
 -
http://ftpmain.gnustep.org/pub/gnustep/binaries/windows/gnustep-system-0.24.0-setup.exe
GNUstep Core 0.23.1
-
http://ftpmain.gnustep.org/pub/gnustep/binaries/windows/gnustep-core-0.23.1-setup.exe

dev c++
- 파일첨부 확인(http://www.appsnext.com/work_data/devcpp-4.9.9.2_nomingw_setup.exe)

2. 파일을 설치합니다
GNUstep System  ->GNUstep Core  ->dev c++  순서로 설치하심다.

1. GNUstep System  설치1 -걍 agree


2. GNUstep System  설치2-걍 next 후 설치 화면 지지지직~~



3. GNUstep System  설치3-완료



4. GNUstep Core 설치1-역시 계속 next



5. GNUstep Core 설치2-또...지지지직~~



6. GNUstep Core 설치3- 완료



7.Dev-C++ 설치 첫번째..
얼레..이상한게 뜨네요... 그래도 걍 Go~~



8.Dev-C++ 설치 두번째.. -뭐가있는 지 살펴볼려다가 역시 귀차니즘.. 다음~



9.Dev-C++ 설치 세번째.. -완료

자....다음장에서 계속 이어짐다~~ ^^;


http://www.junapps.com/bbs/board.php?bo_table=03_5&wr_id=3


*<본 강좌는 AppsNext에서 제공되는 강좌입니다. 블로그에 퍼가시거나 카페에 퍼가셔도 좋으나, 반드시 하단에 출처에 AppsNext 를 명시해주시고. 링크도 걸어주셔요>



출처 : http://blog.naver.com/PostView.nhn?blogId=yesing1&logNo=70101949324
Posted by 오늘마감
오브젝트C2011.04.09 10:46
커널패닉 채널에서 peniar님과 xcode 예기를 하다가 xcode가 gcc를 사용한다는 소리를
듣고서 gcc를 사용한다면 리눅스에서도 obj-c 개발 환경 구성이 가능하지 않을까 싶어
검색해보았습니다.

참고한 사이트 :: [ http://ubuntuforums.org/showthread.php?t=1064045 ]

우분투 리눅스에서는 obj-c 관련 패키지가 gobjc더군요

$sudo apt-get install gobjc

하시게되면 관련 패키지가 여럿 설치가 됩니다.

objc 소스코드를 컴파일 하는 방법은
$gcc -o -Wall 실행파일 소스코드.m -lobjc

편집기로 vim을 사용하시는 분은 .vimrc 파일에 key mapping을 통해서 
vim 내에서 컴파일이 가능하게 할 수 있습니다.

.vimrc 파일 설정
filetype on
au FileType objc map <F2> : !gcc -o -Wall %< % -lobjc
au FileType objc map <F3> : !./%<


이렇게 지정 해두시면 F2를 누르면 컴파일, F3을 누르면 실행이 됩니다.

뭐 이렇게 설정한다고 해도 리눅스에서 아이폰/아이패드 개발이 가능한 것은 아닙니다 
흣 그저 간단히 obj-c 개발이 가능할 뿐이죠 =_=


출처 : http://blog.naver.com/PostView.nhn?blogId=nsjkim&logNo=140115657293
Posted by 오늘마감
오브젝트C2010.10.12 13:04
[objective-c] Objective-C Tutorial: NSArray [영어주의]

Objective-C Tutorial: NSArray

Here at iCodeblog, we have been showing you guys how to create many different types of applications from the ground up.  Well, today I decided to do something different and get down to some of the nitty gritty of a structure we rely heavily on in objective-C.

The NSArray is a huge workhorse that we use quite frequently without even thinking about it.  The NSArray class isn’t just your ordinary array.  Not only does it provide random access, but it also dynamically re-sizes when you add new objects to it and has many methods to make our lives easier.  While I won’t go over every method in NSArray (there are quite a few), I will discuss some of the more important ones that are most commonly used.  Let’s take a closer look at this class.

Factory Methods

Factory methods are static methods that build new instances of NSArrays from given parameters and return them.  The table below details on all of the factory methods for the NSArray class.

+ (id)array Creates and returns an empty array
+ (id)arrayWithArray:(NSArray *)anArray Creates and returns an array containing the objects in another given array.
+ (id)arrayWithContentsOfFile:(NSString *)aPath Creates and returns an array containing the contents of the file specified by a given path. *The file must be of type .plist for this method to work
+ (id)arrayWithContentsOfURL:(NSURL *)aURL Similar to arrayWithContentsOfFile except it will load the .plist remotely from a given website. This would be a very simple way to get data from a web service.
+ (id)arrayWithObject:(id)anObject Creates and returns an array containing a given object. This will just be a 1 element array
+ (id)arrayWithObjects:(id)firstObj, … This method is used when you have multiple objects on hand and want easily insert them into an array. Make sure the last element you add is nil or this method won’t work.
+ (id)arrayWithObjects:(const id *)objects count:(NSUInteger)count Creates and returns an array that includes a given number of objects from a given C array.

Here is some example usage of building NSArrays with these factory methods…

// I am using strings, but you can add just about any object to an NSArray   // Creates an NSArray with one object NSArray * myArray = [NSArray arrayWithObject:@"foo"];   // Creates an NSArray with multiple objects. Don't forget to add nil as the last object NSArray * myArray2 = [NSArray arrayWithObjects:@"foo",@"bar",@"baz",nil];   // Creates an NSArray from another NSArray NSArray * myArray3 = [NSArray arrayWithArray:myArray2];   // This will create an NSArray from data on iCodeBlog. Go ahead and try it out, this file exists on our servers and contains valid data. NSArray * myArray4 = [NSArray arrayWithContentsOfURL:[NSURL URLWithString:@"http://icodeblog.com/wp-content/uploads/2009/08/foo.plist"]];

You can also choose not to use factory methods and just use the normal NSArray initializers. They are pretty much the same as the factory methods only you do the allocation yourself. An example of this might be:

NSArray * foo = [[NSArray alloc] initWithObjects:@"foo",@"bar",@"baz",nil];

Accessing The NSArray

Apple has provided us with many great methods for getting data out of an NSArray as well as information about it.  Here is a table of methods and their descriptions.

- (BOOL)containsObject:(id)anObject Returns true if a given object is found in the array, false otherwise
- (NSUInteger)count Returns the size of the array
- (id)lastObject Returns the last object in the array (the one with the highest index)
- (id)objectAtIndex:(NSUInteger)index Gives you random access to the array. Returns the object at a given index.

These are just a few of the accessor methods of NSArray and most likely the only ones you will need to use.

Searching The Array

If you are looking for the index of an object in an array, there is really only one method you need to use. That method is indexOfObject: . An example of usage might be:

NSString * f = @"foo"; NSString * b = @"bar"; NSString * z = @"baz"; NSArray * myArray2 = [NSArray arrayWithObjects:f,b,z,nil]; NSInteger idx = [myArray2 indexOfObject:b]; // This would return 1 (since NSArrays are 0 - indexed)

This is much cleaner code than looping over the entire array to find an object. It’s probably more efficient too as Apple is pretty clean in how they code things.

Sending Message To Objects In The Array

Ok, so this is pretty cool.  Say you have an array of objects that all need to do something.  For example, an array of bullets, and you want all of the bullets to move forward one pixel. Rather than looping over each bullet object in the bullets array and calling [bullet move], you can do it in one method call on the array.  This method is called – (void)makeObjectsPerformSelector:(SEL)aSelector and here is an example of usage.

// Lets pretend the bullet object has a method called move // and there is an array of 50 bullets   [bullets makeObjectsPerformSelector:@selector(move)];
ADVERTISEMENT

 

And that’s it… The move method will now be called on every bullet object in the array with this one method call. Very clean and easy to use. Now, if the method you want to call takes an argument, there is the – (void)makeObjectsPerformSelector:(SEL)aSelector withObject:(id)anObject method. This will allow you to pass an object to each method being called.

Sorting Arrays

Apple has provided us with some very slick ways to sort an NSArray. I will not go into too much detail here as I have a full tutorial planned dedicated to sorting arrays. For now, I will just show you how to sort an NSArray of NSStrings. The method we will be using is sortedArrayUsingSelector. Here is the example usage.

NSArray *sortedArray = [myArray2 sortedArrayUsingSelector:@selector(caseInsensitiveCompare:)]; // This will return a sorted array that looks like [@"bar",@"baz",@"foo"]

You can plug in any of the string compare functions there to compare the strings. If you are sorting an NSArray of custom objects (like users), you can overwrite the compare method for that object and pass compare in for the selector. Just make sure you remember the : at the end of the method.

Looping Through Arrays

So if you are reading this, I assume you have seen a for loop before. ex: for(int x=0; x < … This would most likely not be a good way to enumerate an NSArray as Apple has provided a much nice way for doing so. There are some situations where this method would be preferred (like when u need to calculate the indices or something). But in most cases, you will want to use the special for loop provided by Apple. If you have ever coded PHP, it is much like the foreach loop. Here is an example:

for(NSString * myStr in myArray2) { NSLog(myStr); }

This will loop over myArray2 and pring each element in that array. Very clean and efficient.

Saving Arrays For Later

There is an Array of ways to save data on the iPhone (Pun intended). One way is to simply dump the array to a file. This will write out the NSArray to a plist file on disk that can be loaded later using the arrayWithContentsOfFile method of NSArray. That method is rightfully named writeToFile. The example usage for it is as follows.

NSArray * myArray2 = [NSArray arrayWithObjects:@"foo",@"bar",@"baz",nil]; [myArray2 writeToFile:filePath atomically:YES];

And there you have it! You are probably wondering what the atomically variable means. Me too… Just kidding. If YES, the file will be written to a temp location and then renamed to its final destination. This is put in place to guarantee that the file won’t be corrupted even if the system crashes (rename will be much faster than write). Why is this needed you ask? Consider this scenario.

You want to write a huge array to disk to save it for later. When your app starts it checks the disk to see if this file exists, if it does it loads an NSArray from it. If it doesn’t it creates a new NSArray. Say the last time the app ran, the system crashed while the file was being written. If atomically was set to NO, the original file would be corrupt and now the application would be loading corrupt data every time it starts from now on (most likely causing a crash). However, if you set atomically to YES, the temp file would get corrupted and the app would never see it. That way, the next time the app starts it will create a new fresh NSArray and all will be good.

Good rule of thumb, set atomically to YES.

That concludes our tutorial on NSArray. If you have any questions or comments, feel free to post them in the comments section or write me on twitter.

This entry was posted in iPhone ArticlesiPhone Programming Tutorialsiphone and tagged . Bookmark the permalinkPost a comment or leave a trackback: Trackback URL.
Posted by 오늘마감
오브젝트C2010.10.12 04:46
[objective-c] Objective-C Tutorial: NSArray

Objective-C Tutorial: NSArray

Posted by 오늘마감
오브젝트C2010.09.03 01:14
Objective-C 간단 정리.

■ 오브젝트의 생성 (원문)


모든 오브젝트는 메모리의 Heap에 할당된다.
스택에 저장되는 오브젝트는 없다.  => Objective-C는 심플함을 추구하기 때문에.


이 강의에 OOP의 간략한 개념과 용어가 나오지만 다른언어와 같기때문에 생략한다.


 

■ 용어
Message expression
[receiver method: argument] <= 이 전체를 메세지 표현이라고 한다.
Message
[receiver method: argument] <= 메소드 이후를 메세지라고 한다.
Selector
[receiver method: argument] <= 메소드와 무슨차이냐고 한다면... 메소드를 셀렉터라고도 한다.
Method
The code selected by a message

■ 셀렉터 정의
Selector는 메소드를 인식할 수 있는 이름으로 SEL 이라는 타입으로 정의할수 있다.
SEL action = [button action];


함수포인터와 비슷한 개념이라고 생각하면 된다.


셀렉터의 이름에는 콜론을 포함하여야 한다.

-(void)setName:(NSString *)name age:(int)age;
위의 메소드를 셀렉터로 정의하려면 아래와 같이 된다.
SEL sel = @selector(setName:age:);


■ 셀렉터 활용

오브젝트가 셀렉터에 응답하는지 알아볼 수 있다. 강의1-과제B의 4번에 해당하는 내용이다.
id obj;
SEL sel = @selector(start:);
if ([obj respondsToSelector:sel]) {
    [obj performSelector:sel withObject:self]
}


셀렉터를 이용한 아래와 같은 디자인패턴을 코코아에서 많이 찾아볼 수 있다.
-(void)setTarget:(id)target;
-(void)setAction:(SEL)action;


 

■ description 메소드

모든 오브젝트의 슈퍼클래스인 NSObject안에 구현되어 있다.
- (NSString *)description;


이 메소드를 오버라이드하여 클래스의 상세 내용을 돌려주도록 하면
디버깅할때 매우 유용하다.

[NSString stringWithFormat: @”The answer is: %@”, myObject];


아래와 같이 로그로 출력할 수 있다.
NSLog([anObject description]);


 

■ Foundation Framework


코코아 프레임워크는 많은 유용한 소스들의 집합체이다.
Foundation Framework는 그중 가장 기초가 되는 부분이며 아래 내용을 포함한다.


• 값와 컬렉션 클래스
• User 디폴트
• 아카이빙
• 통지 (Notifications)
• Undo 매니져
• Tasks, 타이머, 스래드
• 파일 시스템, 파이프, I/O, 번들


NSObject - 루트클래스이며 메모리관리, 오브젝트 비교, introspection 을 구현한다.
NSString - 유니코드를 지원하기 때문에 코코아에서 “char *” 대신 사용한다.

 * 편집 가능한 String은 NSMutableString이다.

정수 - NSString은 편집이 불가능 하기 때문에 NSString의 인스턴스가 바로 정수이다.

NSNumber - int, double, float 등을 캡슐화한 클래스이다. 
 * 숫자를 컬렉션에 저장하기 위해선 NSNumber로 생성해야 한다.

NSData / NSMutableData - 임의의 바이트집합
NSDate / NSCalendarDate - 시간과 날짜 관리

Objective C에서는 편집 가능 불가능 두가지 오브젝트를 따로 두고 있다.


예를 들어 컬렉션에는 Array/Dictionary/Set 이 있는데 이 세가지 모두 편집 가능 타입과 불가능 타입이 있다.


편집 불가능: NSArray, NSDictionary, NSSet
편집 가능: NSMutableArray, NSMutableDictionary, NSMutableSet


편집 불가능 컬렉션은 위험부담없이 공유할 수 있으며 원치않는 변경을 방지할 수 있다.
편집 가능 컬렉션들은 대체로 약간의 퍼포먼스 오버헤드가 있다.

<컬렉션>
Array - 오브젝트를 순차적으로 저장
Dictionary - 키/값의 세트로 저장
Set - 유니크 오브젝트가 비순차적으로 저장되어 있는 구조

더 자세한 내용은 아래 링크를 참조하라고 나와있다.

http://developer.apple.com/documentation/Cocoa/Conceptual/ObjectiveC



출처 : http://blog.naver.com/PostView.nhn?blogId=katchup00&logNo=10075952516
Posted by 오늘마감
오브젝트C2010.08.31 11:43
다른언어와 다른 Objective-C 만의 특징

Objective-C는 표준 ANSI C를 확장한 객채지향 언어이다.
* 문법에 대해서는 별도 문서 참조. 
확장자
 .h  헤더파일
 .m  소스파일(C, Objective-C를 기술 가능)
 .mm  소스파일(Objective-C에서 c++클래스를 호출하고자 하는경우에만 사용할것)
* 헤더 파일을 소스에 임포트 할때는 #include대신 #import를 사용할 것.
클래스 선언
클래스의 interface 는 .h에 정의하고 implementation은 .m에 정의 한다.
인터페이스 정의는 @interface로 시작하며 @end로 끝난다.
Strong typing과 Weak typing

MyClass *myObject1;  //Strong typing앞에는 *를 붙여준다
id       myObject2; 
Strong typing 만 사용해온 개발자들은 id와 같은 불확실한 타입을 사용함으로써 많은 문제점이 생길꺼라 생각하지만 
사실 이는 Objective-c 프로그래밍을 유연하게 만들어주는 장점중 하나이다.
메소드 정의 방법
 (-) 기호로 시작되는 메소드 타입 식별자는 인스턴트 메소드 임을 의미한다. (+)로 적으면 클래스 메소드.
 메소드명 뒤의 (:)콜론은 이 메소드가 파라매터를 가진다는 것을 의미한다.
 파라매터가 없는 경우 (:)콜론 이후는 생략 가능하다. (아하, API문서 읽기가 어렵더라니... 이런 뜻이었구나)
<호출 하는 예>
[myArray insertObject:anObject atIndex:0];
또한, Objective-C에서는 쓸모없는 임시 변수를 선언하지 않아도 되게끔 메소드의 리턴값을 파라메터로 직접 넘길 수 있다.
괄호 안에 괄호([ [] ])를 넣는 방법.
<예>
[[myAppObject theArray] insertObject:[myAppObject objectToInsert] atIndex:0];
.(도트) 문법도 제공하는데, accessor methods(단순히 클래스 멤버에 억세스 하기 위해 만들어진 메소드, getter or setter)를 호출할때 사용된다.
위의 예제를 .(도트) 문법으로 표현해 보면 아래와 같아진다.
[myAppObject.theArray insertObject:[myAppObject objectToInsert] atIndex:0];
물론 .(도트) 문법은 myAppObject.theArray = aNewArray; 와 같이 사용할 수도 있다.
클래스 implementation 
<예>
@implementation MyClass
- (id)initWithString:(NSString *)aName
{
    if (self = [super init]) {
        name = [aName copy];
    }
    return self;
}
+ (MyClass *)createMyClassWithString: (NSString *)aName
{
    return [[[self alloc] initWithString:aName] autorelease];
}
@end
프로퍼티 선언
프로퍼티란 accessor methods(클래스 멤버에 접근하기 위한 메소드)를 편하게 implementation 하는 방법이다.
인터페이스안에 메소드와 같이 정의 하면 된다.
<예>
@property BOOL flag;
@property (copy) NSString *nameObject;  // Copy the object during assignment.
@property (readonly) UIView *rootView;  // Declare only a getter method.
위와 같이 선언하면 같은 이름으로 데이터를 꺼내올수 있고, 앞에 set을 붙인 이름으로 데이터를 세팅 가능하다.
set을 붙일때는 프로퍼티명의 첫글자는 대문자가 된다. 예: nameObject 는 setNameObject로 접근.
그리고 나서 클래스 implementation 에서 아래와 같은 선언을 하면 컴파일러에 의해 메소드가 자동 생성된다.
<예>
@synthesize flag;
@synthesize nameObject;
@synthesize rootView;
또는 붙여 쓸수도 있다.
<예>
@synthesize flag, nameObject, rootView;
결국 이런 기능을 이용함으로써 개발자는 accessor methods를 위한 불필요한 코딩을 줄일 수 있다.

String
위에서 언급한 바와 같이 Objective-C는 c의 확장임으로 c의 String을 그대로 사용할 수 있다.
하지만 대부분의 Objective-C 프레임워크에서는 c-style String대신 NSString이라는 독자적인 클래스를 사용한다.
이는 가변길이 문자의 사용, 유니코드 대응, printf와 같은 포멧기능 등의 많은 이점이 있으며 자주 사용하는 클래스이기 때문에
단지 "(더블 쿼테이션) 앞에 @만 붙여줌으로써 생성이 가능하다.
<예>
NSString *myString = @"My String\n";
NSString *anotherString = [NSString stringWithFormat:@"%d %s", 1, @"String"];
// Create an Objective-C string from a C string
NSString *fromCString = [NSString stringWithCString:"A C string" encoding:NSASCIIStringEncoding];

Protocols와 Delegates
프로토콜은 다른 클래스에 의해 implement되는 인터페이스로써 그 자체는 클래스가 아니다. 
프로토콜은 필수 또는 옵션 메소드를 선언 할 수 있으며,
아래와 같이 클래스의 인터페이스 선언과 매우 비슷하나 다만 슈퍼클래스를 가지지 않는다.
<예>
@protocol MyProtocol
    - (void)requiredMethod;
@optional
    - (void)anOptionalMethod;
    - (void)anotherOptionalMethod;
@required
    - (void)anotherRequiredMethod;
@end
프로토콜을 사용한다는 것은 그가 가지는 인터페이스를 준수하겠다는 선언이며, 
주로 클래스간의 데이터 전달을 목적으로 하는 클래스에 사용된다.
프로토콜에 대한 자세한 내용은 별도 문서로 있으며, 후에 읽어볼 필요가 있을것이다. (Protocols 문서)

이상이 Objective-C에 대한 간단한 소개였으며 앞으로 읽어볼 문서들중에 쉽게 접하게 될 특징들이다. 
물론 이것이 전부는 아니며 자세한 내용은 The Objective-C Programming Language에 나와있다.


출처 : http://blog.naver.com/PostView.nhn?blogId=katchup00&logNo=10075365123
Posted by 오늘마감
오브젝트C2010.06.24 14:13
The Objective-C 2.0 Programming Language
Ch1. Objects, Classes, and Messaging

In Objective-C, it is valid to send a message to nil - it simply has no effect at runtime and returns nil.


A crucial difference between function calls and messages is that a function and its arguments are joined together in the compiled code, but a message and a receiving object aren’t united until the program is running and the message is sent. Therefore, the exact method that’s invoked to respond to a message can only be determined at runtime, not when the code is compiled.


Objective-C provides a dot (.) operator that offers a compact and convenient syntax you can use as an alternative to square bracket notation ([]s) to invoke accessor methods.

Despite appearances to the contrary, the dot syntax therefore preserves encapsulation—you are not accessing an instance variable directly.


If you want to access a property of self using accessor methods, you must explicitly call out self


class object -> class instance

A class that doesn’t need to inherit any special behavior from another class should nevertheless be made a subclass of the NSObject class.

myRectangle = [[Rectangle alloc] init];

Every class object has at least one method (like alloc)that enables it to produce new objects, and every instance has at least one method (like init) that prepares it for use.


Unlike C++, there is no static class member variable, instead you should define static variable in the@implementation file.


class method vs. instance method?

The runtime system sends an initialize message to every class object before the class receives any other messages and after its superclass has received the initialize message.


When a class object receives a message that it can’t respond to with a class method, the runtime system determines whether there’s a root instance method that can respond.


The class name can stand for the class object only as a message receiver.

ex) [anObject isKindOfClass:[Rectangle class]]

It would have been illegal to simply use the name “Rectangle” as the argument.


class equality test

[objectA class] == [objectB class]


Ch2. Defining a Class

+ class method

- instance method

If a return or argument type isn’t explicitly declared, it’s assumed to be the default type for methods and messages — an id.


#import directive is identical to #include, except that it makes sure that the same file is never included more than once.


@class Rectangle, Circle;

The @class directive minimizes the amount of code seen by the compiler and linker, and is therefore the simplest way to give a forward declaration of a class name.


** typical interface (.h file) **

#import "ItsSuperclass.h"

@interface ClassName : ItsSuperclass

{

    instance variable declarations

}

method declarations

@end


** typical implementation (.m file) **

@implementation ClassName : ItsSuperclass

{

    instance variable declarations

}

method definitions

@end


** simple implementation by importing header file **

#import "ClassName.h"

@implementation ClassName

method definitions

@end


By default, all unmarked instance variables are @protected. (private in C++ class, public in C++ struct)


self - class of the object that is sending message. If it is called in a inherited method, self is the class of the derived object.

super - class above the class where the method is defined.


Ch3. Allocating and Initializing Objects

Because an init... method might return an object other than the newly allocated receiver, or even return nil, it’s important that programs use the value returned by the initialization method.


** dangerous **

id anObject = [SomeClass alloc];

[anObject init];

[anObject someOtherMessage];

** safe **

id anObject = [[SomeClass alloc] init];

[anObject someOtherMessage];

-- or --

id anObject = [[SomeClass alloc] init];

if ( anObject )// check for nil is needed.

    [anObject someOtherMessage];

else

    ...


In general, if there is a problem during an initialization method, you should call [self release] and return nil.

You should only call [self release] at the point of failure. If you get nil back from an invocation of the super class’s initializer, you should not also callrelease.


You should typically not use exceptions to signify errors of initializer.


General Principle:The designated initializer in a class must,through a message to super, invoke the designated initializer in a superclass.


Ch4. Declared Properties

@interface MyClass : NSObject

{

    NSString *value;

}

@property(copy, readwrite) NSString *value;

@end

---

@implementation MyClass

@synthesize value;

@end

---

@synthesize age = yearsOld; // accessor: age, instance variable: yearsOld


When you synthesize a property, the compiler only creates any absent accessor methods.


attributes = (readwrite | readonly) | (assign | retain | copy) | (nonautomic) | (setter=) | (getter=)


You cannot specify the retain attribute for non-objecttypes.


informal decorator = (IBOutlet) | (__weak | __strong)


With @dynamic, you notify the compiler that you would provide the methods.


// assume using garbage collection

@implementation MyClass

@dynamic value;

- (NSString *)value {

    return value;

}

- (void)setValue:(NSString *)newValue {

    if (newValue != value) {

        value = [newValue copy];

    }

}

@end


You can re-declare a property in a subclass, but (with the exception of readonly vs. readwrite) you must repeat its attributes in whole in the subclasses.

If you declare a property in one classas readonly, you can redeclare it as readwrite in a class extension.

- a mutable subclass of an immutable class

- read only in public API, readwrite in private implentation file


the copy method returns an immutable version of the collection. You have to provide your own setter to set mutable object property.


@interface MyClass : NSObject {

    NSMutableArray *myArray;

}

@property (nonatomic, copy) NSMutableArray *myArray;

@end


@implementation MyClass

@synthesize myArray;

- (void)setMyArray:(NSMutableArray *)newArray {

    if (myArray != newArray) {

        [myArray release];

        myArray = [newArray mutableCopy];

    }

}

@end


You can look for all the property declarations in your header file and make sure that object properties not marked assign are released, and those marked assign are not released.


You should use invoke the accessor method on modern runtime.


- (void)dealloc {

    [self setProperty:nil];

    [super dealloc];

}


** property declaration meaning **

// assign

property = newValue;

// retain

if (property != newValue) {

    [property release];

    property = [newValue retain];

}

// copy

if (property != newValue) {

    [property release];

    property = [newValue copy];

}

// atomic

[_internal lock]; // lock using an object-level lock

id result = [[value retain] autorelease];

[_internal unlock];

return result;


Simply making all the properties in your class atomic does not mean that your class or more generally your object graph is “thread safe”.


The modern runtime supports instance variable synthesis whereas the legacy runtime does not.


Ch5. Categories and Extensions

A category allows you to add methods to an existing class—even to one to which you do not have the source.

Class extensions are similar, but allow additional required API to be declared for a class in locations other than within the primary class @interface block.


Category methods can do anything that methods defined in the class proper can do. At runtime, there’s no difference. The methods the category adds to the class are inherited by all the class’s subclasses, just like other methods.


#import "ClassName.h"

@interface ClassName ( CategoryName )

// method declarations

@end


A category implementation (in a file named ClassName+CategoryName.m) might therefore look like this:


#import "ClassName+CategoryName.h"

@implementation ClassName ( CategoryName )

// method definitions

@end


Normally, class objects can perform only class methods. But instance methods defined in the root class are a special case.


Class extensions are like “anonymous” categories, except that the methods they declare must be implemented in the main @implementation block for the corresponding class.


Ch6. Protocols

A protocol is simply a list of method declarations, unattached to a class definition.


@protocol MyXMLSupport

- initFromXMLRepresentation:(NSXMLElement *)XMLElement;

@property (nonatomic, readonly) (NSXMLElement *)XMLRepresentation;

@end


Unlike class names, protocol names don’t have global visibility. They live in their own namespace.


The default is @required.

@protocol MyProtocol

- (void)requiredMethod;

@optional

- (void)anOptionalMethod;

- (void)anotherOptionalMethod;

@required

- (void)anotherRequiredMethod;

@end


** On Mac OS X v10.5, protocols may not include optional declared properties.


** sender **

Source code can refer to a Protocol object using the @protocol() directive.

Protocol *myXMLSupportProtocol = @protocol(MyXMLSupport);


** receiver **

Adopting a formal protocol:

@interface ClassName : ItsSuperclass < protocol list >

Categories adopt protocols in much the same way:

@interface ClassName ( CategoryName ) < protocol list >


A class is said to conform to a formal protocol if it adopts the protocol or inherits from another class that adopts it.

if (![receiver conformsToProtocol:@protocol(MyXMLSupport)]) {...


conformsToProtocol: is both class and instance method.


Protocols can’t be used to type class objects. Only instances can be statically typed to a protocol, just as only instances can be statically typed to a class.


One protocol can incorporate other protocols:

@protocol ProtocolName < protocol list >


A class can conform to a protocol without formally adopting it simply by implementing the methods declared in the protocol.


circular dependency between protocols (x) -> forward reference (o)

@protocol B;

@protocol A

- foo:(id <B>) anObject;

@end


Ch7.Fast Enumeration

for ( Type newVariable in expression ) { statements }

: expression should adopt NSFastEnumeration protocol.


Since mutation of the object during iteration is forbidden, you can perform multiple enumerations concurrently.


Ch8. Enabling Static Behavior

Static typing also doesn’t affect how the object is treated at runtime. Messages sent to statically typed objects are dynamically bound, just as objects typed id are.Static typing allows for compile-time type checking.


Methods in different classes that have the same selector must also share the same return and argument types.


Ch9. Selectors

Compiled selectors are assigned to a special type, SEL.

The @selector() directive lets you refer to the compiled selector.

SEL setWidthHeight;

setWidthHeight = @selector(setWidth:height:);


To convert a character string to a selector at runtime:

setWidthHeight = NSSelectorFromString(aBuffer);


Conversion in the opposite direction is also possible:

NSString *method;

method = NSStringFromSelector(setWidthHeight);


Compiled selectors identify method names, not method implementations. It lets you send the same message to receivers belonging to different classes.


Except for messages sent to statically typed receivers, dynamic binding requires all implementations of identically named methods to have the same return type and the same argument types.


[friend performSelector:@selector(gossipAbout:)withObject:aNeighbor];

is equivalent to:

[friend gossipAbout:aNeighbor];


The receiver and message can vary at runtime:

id      helper = getTheReceiver();

SEL    request = getTheSelector();

[helper performSelector:request];


Ch10. Exception Handling

Just like the C++ / Java language.

@try {

    ...

}

@catch (CustomException *ce) {// 1

    ...

}

@catch (NSException *ne) {// 2

    // Perform processing necessary at this level.

    ...

}

@catch (id ue) {

    ...

}

@finally {// 3

    // Perform processing necessary whether an exception occurredor not.

    ...

}


** Throwing exceptions **

NSException *exception = [NSException exceptionWithName:@"HotTeaException"reason:@"The tea is too hot"userInfo:nil];

@throw exception;


Exceptions are resource-intensive in Objective-C. You should not use exceptions for general flow-control, or simply to signify errors.

Inside a @catch()block, you can re-throw the caught exception using the @throw directive without an argument.


Ch11. Threading

To turn on support for thread sync. and exception handling, use the -fobjc-exceptions switch. Itrenders the application runnable only in Mac OS X v10.3 and later.


The @synchronized() directive takes as its only argument any Objective-C object, including self.

- (void)criticalMethod

{

    @synchronized(self) {

        // Critical code.

        ...

    }

}

When code in an @synchronized() block throws an exception, the Objective-C runtime catches the exception, releases the semaphore (so that the protected code can be executed by other threads), and re-throws the exception to the next exception handler.


Ch12. Remote Messaging

A remote receiver is typically anonymous.an object that’s designated to receive remote messages advertises its inter face in a formal protocol.


// asynchronous

- (oneway void)waltzAtWill;         

// information is being passed in a message 

- setTune:(in struct tune *)aSong;

// an argument is being used to return information by reference

- getTune:(out struct tune *)theSong;

// an argument is used both to provide information and to get  information back

- adjustTune:(inout struct tune *)aSong;

// composite value, not a simple pointer

- getTuneTitle:(out char **)theTitle;

// send an object, not a proxy

- danceWith:(bycopy id)aClone;

// objects passed or returned by reference

byref


Ch13. C++ with ObjC

You can include pointers to Objective-C objects as data members of C++ classes, and you can include pointers to C++ objects as instance variables of Objective-C classes.

Xcode requires that file names have a “.mm” extension for the Objective-C++ extensions to be enabled by the compiler.


C++ classes defined within an Objective-C interface are globally-scoped, not nested within the Objective-C class.

C++ classes that have virtual member function cannot serve as an ObjC instance variable.


** preprocessor constants **

__cplusplus

__OBJC__


Objective-C++ does not allow you to inherit C++ classes from Objective-C objects, nor does it allow you to inherit Objective-C classes from C++ objects. The layout of Objective-C and C++ objects in memory is mutually incompatible.


Objective-C does not have a notion of nested namespaces. You cannot declare Objective-C classes within C++ namespaces, nor can you declare namespaces within Objective-C classes.


Objective-C classes, protocols, and categories cannot be declared inside a C++ template, nor can a C++ template be declared inside the scope of an Objective-C interface, protocol, or category.


However, Objective-C classes may serve as C++ template parameters. C++ template parameters can also be used as receivers or parameters (though not as selectors) in Objective-C message expressions.


You cannot use Objective-C syntax to call a C++ object, you cannot add constructors or destructors to an Objective-C object.


An exception thrown in Objective-C code cannot be caught in C++ code and, conversely, an exception thrown in C++ code cannot be caught in Objective-C code.



출처 : http://blog.naver.com/PostView.nhn?blogId=gonagi&logNo=150045911302

'오브젝트C' 카테고리의 다른 글

Object-C : Declared Properties 에 대한 깔끔한 정리  (0) 2010.08.12
Hello iPhone - 1  (0) 2010.08.11
The Objective-C 2.0 Programming Language  (0) 2010.06.24
Objective-C  (0) 2010.06.22
Objective-C의 기본 문법  (0) 2010.06.22
Objective-C의 특징  (0) 2010.06.22
Posted by 오늘마감
오브젝트C2010.06.22 17:54
Objective-C

강의1를 듣고 과제를 열심히 하고 나서 강의2를 들으니까... 거의 답이 다 나와있다. ㅡㅡ;

하긴 강의2 듣고 풀어도 된다고 했으니까..

대부분의 내용은 [Getting Started] Objective-C의 특징 이나 Objective-C의 기본 문법 와 겹치는 내용이지만

없는 내용 몇가지만 적어보도록 한다.


■ 오브젝트의 생성 (원문)


모든 오브젝트는 메모리의 Heap에 할당된다.
스택에 저장되는 오브젝트는 없다.  => Objective-C는 심플함을 추구하기 때문에.


이 강의에 OOP의 간략한 개념과 용어가 나오지만 다른언어와 같기때문에 생략한다.


 

■ 용어
Message expression
[receiver method: argument] <= 이 전체를 메세지 표현이라고 한다.
Message
[receiver method: argument] <= 메소드 이후를 메세지라고 한다.
Selector
[receiver method: argument] <= 메소드와 무슨차이냐고 한다면... 메소드를 셀렉터라고도 한다.
Method
The code selected by a message

■ 셀렉터 정의
Selector는 메소드를 인식할 수 있는 이름으로 SEL 이라는 타입으로 정의할수 있다.
SEL action = [button action];


함수포인터와 비슷한 개념이라고 생각하면 된다.


셀렉터의 이름에는 콜론을 포함하여야 한다.

-(void)setName:(NSString *)name age:(int)age;
위의 메소드를 셀렉터로 정의하려면 아래와 같이 된다.
SEL sel = @selector(setName:age:);


■ 셀렉터 활용

오브젝트가 셀렉터에 응답하는지 알아볼 수 있다. 강의1-과제B의 4번에 해당하는 내용이다.
id obj;
SEL sel = @selector(start:);
if ([obj respondsToSelector:sel]) {
    [obj performSelector:sel withObject:self]
}


셀렉터를 이용한 아래와 같은 디자인패턴을 코코아에서 많이 찾아볼 수 있다.
-(void)setTarget:(id)target;
-(void)setAction:(SEL)action;


 

■ description 메소드

모든 오브젝트의 슈퍼클래스인 NSObject안에 구현되어 있다.
- (NSString *)description;


이 메소드를 오버라이드하여 클래스의 상세 내용을 돌려주도록 하면
디버깅할때 매우 유용하다.

[NSString stringWithFormat: @”The answer is: %@”, myObject];


아래와 같이 로그로 출력할 수 있다.
NSLog([anObject description]);


 

■ Foundation Framework


코코아 프레임워크는 많은 유용한 소스들의 집합체이다.
Foundation Framework는 그중 가장 기초가 되는 부분이며 아래 내용을 포함한다.


• 값와 컬렉션 클래스
• User 디폴트
• 아카이빙
• 통지 (Notifications)
• Undo 매니져
• Tasks, 타이머, 스래드
• 파일 시스템, 파이프, I/O, 번들


NSObject - 루트클래스이며 메모리관리, 오브젝트 비교, introspection 을 구현한다.
NSString - 유니코드를 지원하기 때문에 코코아에서 “char *” 대신 사용한다.

 * 편집 가능한 String은 NSMutableString이다.

정수 - NSString은 편집이 불가능 하기 때문에 NSString의 인스턴스가 바로 정수이다.

NSNumber - int, double, float 등을 캡슐화한 클래스이다. 
 * 숫자를 컬렉션에 저장하기 위해선 NSNumber로 생성해야 한다.

NSData / NSMutableData - 임의의 바이트집합
NSDate / NSCalendarDate - 시간과 날짜 관리

Objective C에서는 편집 가능 불가능 두가지 오브젝트를 따로 두고 있다.


예를 들어 컬렉션에는 Array/Dictionary/Set 이 있는데 이 세가지 모두 편집 가능 타입과 불가능 타입이 있다.


편집 불가능: NSArray, NSDictionary, NSSet
편집 가능: NSMutableArray, NSMutableDictionary, NSMutableSet


편집 불가능 컬렉션은 위험부담없이 공유할 수 있으며 원치않는 변경을 방지할 수 있다.
편집 가능 컬렉션들은 대체로 약간의 퍼포먼스 오버헤드가 있다.

<컬렉션>
Array - 오브젝트를 순차적으로 저장
Dictionary - 키/값의 세트로 저장
Set - 유니크 오브젝트가 비순차적으로 저장되어 있는 구조

더 자세한 내용은 아래 링크를 참조하라고 나와있다.

http://developer.apple.com/documentation/Cocoa/Conceptual/ObjectiveC



출처 : http://blog.naver.com/PostView.nhn?blogId=katchup00&logNo=10075952516

'오브젝트C' 카테고리의 다른 글

Hello iPhone - 1  (0) 2010.08.11
The Objective-C 2.0 Programming Language  (0) 2010.06.24
Objective-C  (0) 2010.06.22
Objective-C의 기본 문법  (0) 2010.06.22
Objective-C의 특징  (0) 2010.06.22
[Objective-C]Interface Builder 기본 사용  (0) 2010.06.22
Posted by 오늘마감
오브젝트C2010.06.22 09:48
Objective-C - @protocol 예제

protocol 은 일반적으로 통신에서 규약으로 많이 들었는데  objective-C 에서 지사자로 @protocol 이 있다.

주된 목적은 Class 에서 Mthod 공유이다.  좀더 공부 해야 겠지만 델리게이트 구현이 이게 아닌가 싶다.

문법은

@ protocol 프로토콜 이름 "부모 프로토콜 1, ..."
프로토콜 본체 ...
@ end

다음 protocol 로 하나의 method를 선언하고 다른 Class에서 method 이름은 같지만 다른 기능을 가지
예를 만들어 본다.
protocol은 상속도 가능한데 우선 상속 없이 해본다.


/*

 Objective C Program 

  protocol  example

*/


#import <Foundation/Foundation.h>



@protocol ProtocolTest

-(id)ToString;

@end


@interface AClass:NSObject

{

char *name;

}

-(id)init;

-(id)free;

@end


@implementation AClass

-(id)init

{

[super init];

name = (char *)malloc(255);

        sprintf(name,"%s @%d",__FILE__,self);

returnself;

}


-(id)free

{

free(name);

[super release];

}


-(id)ToString

{

return (id)name;

}

@end



@interface BClass:NSObject

@end


@implementation BClass

-(id)ToString

{

return (id)"This is BClass";

}

@end


int main(int argc, constchar *argv[])

{


        id  objA = [[AClass alloc]init];

        id  objB = [[BClass alloc]init];


NSAutoreleasePool * pool = [[ NSAutoreleasePool alloc] init];

   

        printf("objA =%s\n",[objA ToString]);

        printf("objB =%s\n",[objB ToString]);


        [objA release];

        [objB release];

[pool drain];


return0;


}

 
@implementation 에서 구현하여 인스턴스 메소드로 사용하는 것이 기본적으로
@protocol을 사용하는 방법이다.
 
 
 
 


출처 : http://blog.naver.com/PostView.nhn?blogId=inetami&logNo=20101918615
Posted by 오늘마감