Calls +alloc on the class, then -init on the resulting instance, and returns the result.

Allocates, clears, and returns a pointer to memory for a new instance of the receiver. Returns nil on failure.

Returns self. The runtime calls this method before any instances of the receiving class are created. Override to perform class-specific setup.

Returns self. This is the designated initializer for Object.

Calls -shallowCopy then -deepen on the resulting instance, and returns the result. In Object this is the same as -shallowCopy.

Returns a copy of the receiver. Fields that are pointers are not traversed, just duplicated in the new copy.

Returns self. Override to replace all fields that are pointers with new values. Otherwise, -deepCopy and -copy won’t function correctly.

Calls -copy and returns the result.

Releases the memory occupied by the receiver. Also zeroes the isa pointer of the object. If the object is sent a message at this stage, an immediate runtime error will occur. (Once the memory has been reused, anything can happen.) Override to release other resources held by the receiver.

Returns the name of the receiver’s class.

Returns the receiver. You can get a class object from the class’s name with this method:

Classclassobj = [MyClass self];

Returns an integer that can be used to store the object in a hash table. If two objects are equal (as reported by -isEqual:) they will have the same hash value. However, two unequal objects may also share the same hash value.

Returns YES if the receiver and obj are equal as pointers, otherwise returns NO. Override to implement another relation, such as equality of contents.

Returns one of the following values:

Override this method if you want to compare your objects in a different way.

Returns YES if the receiver is a regular object, otherwise NO.

Returns YES if the receiver is a class object, otherwise NO.

Returns YES if the receiver is a metaclass object, otherwise NO.

Same as -isKindOf:, but takes as a parameter the name of a class instead of a class object.

Same as -isMemberOf:, but takes as a parameter the name of a class instead of a class object.

Returns YES if the class of the receiver adopts the protocol directly, or if that class directly or indirectly inherits from another class that does.

Returns YES if instances of the receiving class respond to the selector sel, otherwise NO. Does not take forwarding into account.

Returns YES if the receiver responds to the selector sel, otherwise NO. Does not take forwarding into account.

If instances of the receiving class handle the method specified by sel, this method returns a pointer to a description of the method; otherwise it returns a NULL pointer.

The return type is defined as follows in objc-api.h:

struct objc_method_description {
  SEL name;
  char* types;
};

The first member of the structure will be of little use since you already have the selector. The second points to a zero-terminated character string. The string takes the form of type specifiers (as returned by the @encode directive) for the return and parameter types, interleaved with numbers describing offsets of the parameters in the stack frame.

If the receiver handles the method specified by sel, this method returns a pointer to a description of the method; otherwise it returns a NULL pointer.

If instances of the receiving class handle the method specified by sel, this method returns a pointer to the implementation of the specified method; otherwise a NULL pointer. You can use this to get a pointer to a method you want to call directly. See Section 1.15 for an example.

If the receiver handles the method specified by sel, this method returns a pointer to the method’s code; otherwise a NULL pointer.

Sends to the receiver the message specified by the selector sel. Since selectors can be assigned to variables, one part of your code can tell another which message to send.

The same as -perform: but also provides the argument obj1 to the method being called.

The same as -perform: but also provides two arguments to the method being called.

Like the -perform: methods, but takes a variable-length parameter list. Call this method inside your class’s -forward:: method to delegate the message to another object.

The return type is a typedef for void *. The second parameter describes the parameter types and values. You can treat this as an opaque type; its declaration is in encoding.h.

Invokes -doesNotRecognize. Override as described in Section 1.11 to implement message forwarding. The parameter types are the same as for -performv::.

Substitutes the receiver for the class represented by classObj. The receiver must be a subclass of the class represented by classObj. The receiver can’t declare any new fields. Call this method before creating any instances of the class represented by classObj or sending it any messages.

This is a way, similar to using categories, to add or override methods to an existing class. In contrast with a category, the posing class can send a message to super , which will execute the method in the class represented by classObj.

Sets the isa pointer of the receiver to classObj, and returns the previous value of the pointer. This effectively converts the receiver to an instance of the class represented by classObj. This will only work if the receiver’s class is a descendant of the class represented by classObj, and instances of the two classes have the same size. If the call fails, it returns nil.

Call this in a method that you require subclasses to override and implement.

Call this in a method that you have deliberately left unfinished.

Call this in a method that you inherit (and override) but that makes no sense for your subclass to support.

Generates a runtime error by invoking the -error : method on self. The runtime sends this message to an object when the object has failed to respond to, or forward, a message.

Writes an error message to the system log (via the syslog( ) call) and exits the program. The runtime calls this method on self for a variety of error conditions. Override as described in Section 1.8 to customize error handling for a class.

Does nothing and returns self. Called by the runtime when an object has been reconstructed. Override to customize behavior when your objects are restored.

Writes the receiver to the specified stream.

Sets the receiver’s fields by reading from the specified stream.

Sets the class version number.

Returns the class’s version number, or zero if it has never been set.

Returns the version number of the typed stream.

Allocates, clears, and returns a pointer to memory for a new instance of the receiver. Memory comes from the default zone. Returns nil on failure. (NSObject class)

Same as alloc, but uses a specific region of memory. NSZone is not a class but a C type that you should treat as opaque. You can get the zone of an object with the -zone method. You may improve cache performance by creating related objects in the same zone. Passing in a nil parameter means memory will be allocated from the default zone. (NSObject class)

Sent by the runtime before the class or any of its descendants is sent a message by the program. Each class gets the message exactly once, and superclasses get the message before subclasses. The NSObject implementation does nothing. Override (first passing the call to super) to perform per-class setup. (NSObject class)

Returns self. This is the designated initializer for NSObject. The Section 1.7 discusses overriding this method. (NSObject class)

Calls +alloc, then -init on the resulting instance, and returns the result. (NSObject class)

Returns the receiver since class objects are unique. Ignores the parameter. Don’t override. (NSObject class)

Returns the receiver since class objects are unique. Ignores the parameter. Don’t override. (NSObject class)

Calls -copyWithZone : with a nil zone parameter. NSObject doesn’t implement that method (only the class method of the same name) but many Cocoa classes do. Your class will have to implement -copyWithZone: in order to use -copy. The Section 1.7 discusses how to do this.

Calls -mutableCopyWithZone: with a nil zone parameter. NSObject doesn’t implement that method (only the class method of the same name) but many Cocoa classes do. Your class will have to implement -mutableCopyWithZone in order to use -mutableCopy. The Section 1.7 discusses how to do this. (NSObject class)

Deallocates the memory used to store the receiver. Override to release any additional resources managed by your object. Don’t call -dealloc directly if you are using retain/release memory management. (See Section 1.12.) (NSObject class)

Called by the runtime when a class or category is set up for use by the runtime. Deprecated in favor of the +initialize method. (NSObject class)

Returns the class object for the receiver’s class. (NSObject protocol)

Returns the class object of the receiver’s parent class. (NSObject protocol)

Returns a string describing the state of the receiver. The NSObject implementation prints the class name and the runtime address of the instance. Override to provide a string the runtime will use when you print an object using the %@ formatting descriptor with NSLog( ). (NSObject protocol)

Returns the receiver. You can get a class object from the class’s name with this method:

ClasscircleClass = [Circle self];

(NSObject protocol)

Returns an integer that can be used to store the object in a hash table. If two objects are equal (as reported by the -isEqual: method) they will have the same hash value. However, two unequal objects may also share the same hash value. (NSObject protocol)

Returns YES if the receiver and object are equal as pointers, otherwise returns NO. Override to provide different semantics, such as equality of contents. (NSObject protocol)

Returns the class object that represents the receiver, not (as you might expect) the metaclass object of the metaclass of the receiver. This means that [MyClass class] and [MyClass self] return the same value; the second expression is probably more clear. (NSObject class)

Returns the name of the class. (NSObject class)

Sets the class version number. (NSObject class)

Returns the class’s version number, or zero if it has never been set. (NSObject class)

Returns the class object representing the receiver’s parent class. (NSObject class)

Returns YES if the receiver adopts prot directly or inherits directly or indirectly from another class that does. (NSObject class)

(NSObject protocol)

Is part of the NSObject protocol, and does one of the following:

(NSObject protocol)

Returns YES if the class of the receiver adopts the protocol directly, or directly or indirectly inherits from another class that does. (NSObject protocol)

Returns NO. (The NSProxy class also implements this method, and returns YES.) (NSObject protocol)

Returns YES if instances of the receiving class respond to the selector sel, otherwise NO. Does not take forwarding into account. (NSObject class)

If instances of the receiving class handle the method specified by sel, returns a pointer to the implementation of the specified method. You can use this to get a pointer to a method you want to call directly. Section 1.15 gives an example.

The Cocoa documentation says that if instances of the receiving class do not handle the specified method, a runtime error occurs. Instead, an apparently valid pointer is returned. You should use code like the following to test for errors:

IMP imp = NULL;
if ([ClassName instancesRespondToSelector:sel])
  imp = [ClassName
         instanceMethodForSelector:sel];

After executing these instructions, imp will still be NULL if the class’s instances do not handle the method specified by sel. (NSObject class)

If instances of the receiving class handle the method specified by sel, returns a description of the method’s signature for the specified method; otherwise returns nil. (NSObject class)

If the receiver handles the method specified by sel, this method returns a pointer to the method’s code. You can use this to get a pointer to a method you want to call directly. Section 1.15 gives an example.

The Cocoa documentation says that if the receiver does not handle the specified method, a runtime error occurs. Instead, an apparently-valid pointer is returned. You should use code like the following to test for errors:

IMP 
                           imp = NULL;
if ([obj respondsToSelector:sel])
  imp = [obj methodForSelector:sel];

After executing these instructions, imp will still be NULL if the receiver does not handle the method specified by sel. (NSObject class)

If the receiver handles the method specified by sel, this method returns a description of the method; otherwise it returns nil. (NSObject class)

Returns YES if the receiver responds to the selector sel; otherwise NO. Does not take forwarding into account. (NSObject protocol)

Sends to the receiver the message specified by the selector sel. Since selectors can be assigned to variables, one part of your code can tell another which message to send.

The same as -performSelector:, but also provides the argument obj1 to the method being called.

The same as -performSelector:, but also provides two arguments to the method being called. If you need to pass more than two parameters, construct an NSInvocation instance. Section 1.11 gives an example. (NSObject protocol)

Invokes -doesNotRecognizeSelector:. Section 1.11 describes how to override this to implement message forwarding. (NSObject class)

Substitutes the receiver for the class represented by classObj. The receiver must be a subclass of the class represented by classObj. The receiver can’t declare any new fields. You should call this method before creating any instances of the class represented by classObj or sending it any messages.

This is a way, similar to using categories, to add or override methods to an existing class. In contrast with a category, the posing class can send a message to super and execute the method in the class represented by classObj. (NSObject class)

Raises an NSInvalidArgument exception. The runtime sends this message to an object when the object has failed to respond to or forward a message.

You can “un-implement” a method as follows:

-(void) methodName {
  [self doesNotRecognizeSelector: _cmd];
}

The class implementing this code will now behave as if it had no methodName.

You could also make an object handle any message without failing by overriding -doesNotRecognizeSelector:, but you should override -forwardInvocation: instead. (NSObject class)

Returns the receiver. Called by NSCoder when it has decoded the receiver. Override this to return some other object. You are responsible for releasing the receiver if you return a different object. (NSObject class)

Returns the receiver’s class. Override to substitute another class during archiving. Called by NSCoder. (NSObject class)

Returns self. Override to substitute another object for the receiver during archiving. Called by NSCoder. (NSObject class)

Increments the receiver’s reference count and returns the receiver. (NSObject protocol)

Returns the receiver’s reference count. (NSObject protocol)

Decrements the receiver’s reference count, and sends it the -dealloc message if the count reaches zero. The oneway keyword specifies that the caller can send the message asynchronously. (See Section 1.6.) (NSObject protocol)

Adds the receiver to the current autorelease pool. Returns the receiver. (NSObject protocol)

Returns the memory zone in which the receiver was allocated. NSZone is not a class but a C type that you should treat as opaque. You can use the value returned by this method as a parameter to -copyWithZone : or -allocWithZone:. Cocoa creates a default zone when a program starts up, and normally you will allocate objects from this zone. You may be able to improve cache behavior by creating related objects in the same zone. See the Cocoa documentation for NSCreateZone( ) and related functions. (NSObject protocol)