macOS [super negotiate]; Is super a variable or not?

Howiieque said:

[super negotiate]; Is super a variable or not?
To do this, you can send a message to super, a special variable in the Objective-C language.
--learning cocoa with objective-c 2nd

super is simply a flag to the compiler telling it where to begin searching for the method to perform; it’s used only as the receiver of a message. But self is a variable name that can be used in any number of ways, even assigned a new
value.
--The Objective-C 2.0 Programming Language

if it is, what type is it? Could someone give an explanation?

Click to expand...

From the Objective-C FAQ:

4.2 What is the difference between self and super ?

self is a variable that refers to the object that received a message
in a method implementation. super refers to the same variable, but
directs the compiler to use a method implementation from the
superclass.

Using pseudo-code, where copy (from super) is the syntax for the copy
implementation of the superclass, the following are equivalent :

myObject = [super copy];

and,

myObject = [self copy (from super)]; // pseudo-code

Click to expand...

It might be easier to think of "super" as a "parent" of your class. Your class is the "child" of the "parent" class.

Also "super" can mean above, the class above you.

Self is a shortcut to mean the class you are inside of now similar to "this" in other object-oriented languages.

Apple also discusses this a bit here:
http://developer.apple.com/DOCUMENT.../ObjectiveC/Articles/chapter_3_section_5.html

super isn't used the same way self is used. self is used as a normal variable that represents the current instance of the class. You can pass self to other methods and access it like any other instance. super is used only for calling the superclass's implementation of a method.

The init method is the default designated initialization method for an object. Once you call alloc (from my understanding), the memory is allocated and all instance variables are initialized to 0. The init method sets up the object with initial values. The return type by default is self but can be different, or could be nil. It's kind of a verification method, to ensure data is valid. For example, if I had an initWithURL: method that takes an NSURL, I could return nil if the url is not a file url.

Normally, when you use the message passing syntax like so


the compiler translates this into a call to the runtime function objc_msgSend(), which dynamically finds the implementation for -message on the given object. It starts looking for the implementation at the object's actual class and moves up the class hierarchy if it can't find an implementation. (If it doesn't find one, it throws an exception.)

When you do this:


the compiler translates this into a call to objc_msgSendSuper(). This does essentially the same thing as objc_msgSend(), except for two things: The object receiving the message is always self, and instead of starting to look for the method implementation in the object's actual class, it beings its search at its superclass.

That's what the second book meant by a 'flag' to the compiler. The compiler knows that when a message is sent to super, it should use objc_msgSendSuper() instead of the regular obj_msgSend().

The compiler only allows the use of super as the receiver of message. It is not a variable at all, which is why you got an error when trying to replace self with super.