There's often confusion about the difference between the following three declarations in Objective-C:
The first one is the most common. It simply declares a pointer to some Objective-C object (see /usr/include/objc/objc.h).
idgives the compiler no information about the actual type of the object, so the compiler cannot do compile-time type checking for you. Thus, the compiler will let you send any (*) message to objects declared
id. Actually, this is why the common idiom of
[[Foo alloc] init]doesn't cause the compiler to complain.
+allocis declared to return type
id, so the compiler won't yell when you then send the returned object the message
So, objects declared using
idare just dynamically typed at runtime. The compiler has no useful information about the object's real type, so it can't warn you if you send it a message that it may not respond to.
Just because we know that an
idis an Objective-C object does not mean that it points to an object that derives from NSObject, or that it even has common methods like retain and release. One solution is to statically type our variable using
NSObject*as shown in number 2 above. This gives the compiler information about the class of the object pointed to by
foo2so the compiler can warn if you send a message to
NSObjectdoesn't respond to. This means you can safely call retain, release, description, etc., but the compiler will warn if you call
countor anything that an NSObject doesn't respond to.
So, declaring a generic pointer of type NSObject* is very similar to what you would do in other languages, like Java, but it's really a bit too restrictive for a language as flexible as Objective-C. Despite what you may have learned at one point, not all Foundation/Cocoa objects derive from NSObject. As an example, NSProxy is not derived from NSObject, so the
foo2pointer above would not be able to hold an NSProxy subclass, even though NSProxy does implement common methods like retain and release. What you really want is a pointer to any object that behaves like an NSObject. And that's exactly what the third case does.
Declaring an object as
id<NSObject>tells the compiler that you don't care what type the object is, but you do care that it conforms to the specified NSObject protocol**. The compiler will ensure that all objects you assign to that pointer conform to the required protocol. A pointer typed like this can safely hold any NSObject (because NSObject conforms to the NSObject protocol), but it could also hold any NSProxy, because NSProxy also conforms to the NSObject protocol. In english, the declaration
id<NSObject> foo3;says "foo3 is a pointer to an object of any type that behaves like an NSObject". This is very powerful, convenient, and expressive. In reality, we often don't care what type an object is, we just care that it responds to the messages that we want to send it (e.g., retain, release).
So how do you decide which form you want to use? It's pretty easy. If you don't want (or can't have) any type checking, then use a plain
id. This is very common for return types on methods that don't know the type of object they're returning (e.g.,
+alloc). It is also common to declare delegates to be type
id, because delegates are generally checked at runtime with
respondsToSelector:, and they usually aren't retained.
However, if you do want compile-time type checking, you must decide between the second and third cases. Well, let me just help you out—you want the third case! :-) I've very, very, VERY rarely seen a situation where
NSObject *worked but
id<NSObject>would not. And using the protocol form has the advantage that it will work with NSProxys. You may think that you never use NSProxys, but Cocoa's distributed objects system makes heavy use of NSProxy subclasses. Additionally, the common case is that you simply want to ensure that an object can be retained or released, and in that case the protocol form conveys that intent better; you really don't care what class the object is, you only care that it behaves like an NSObject.
* Well, not "any" message. If you send a message using a selector that the compiler has never seen, it may warn that it has never seen that selector. This is nice in the event that you mistype
** Now, when I say "NSObject" here I'm talking about the protocol (
@protocol) named NSObject. There is also a class named NSObject that does indeed conform to the NSObject protocol, but they are two different things.