3

When we do self = [super init]; in our subclass's init method implementation,

I don't understand why it's not self= [[super alloc] init];

In the first case, how can you init something that you haven't allocate memory for?

Is this because you're not actually initing a superclass object but instead using the superclass's init method to init yourself first?

If so, where and when did we allocate memory for self?

Is it just assumed that we did the alloc somewhere else in our program before calling this init method?

Is the syntax basically saying [subclass initUsingMySuperClassImplementationFirst] ?

user3142893
  • 63
  • 5

2 Answers2

9

I don't understand why it's not self= [[super alloc] init];

Because when init is called, someone else has already allocated memory.

Note that alloc is a class method, and init is an instance method. When init is called, the object has already been created.

For example:

MyObject *someObject = [[MyObject alloc] init];

alloc creates and returns an allocated MyObject. init just sets things up - initializes any custom properties, etc.

This is equivalent to:

MyObject *someObject = [MyObject alloc];
someObject = [someObject init];

Is it just assumed that we did the alloc somewhere else in our program before calling this init method?

It's not just assumed, it's guaranteed - because it's impossible to get to init without doing so. For example, if you called:

MyObject *someObject = [MyObject init];

This wouldn't work, because init is an instance method, not a class method. (See What is the difference between class and instance methods? if you want to read more about the difference.)

Community
  • 1
  • 1
Aaron Brager
  • 65,323
  • 19
  • 161
  • 287
  • So self in this case is the object created by `[MyObject alloc]` ? Then self goes on to use the superclass's init method in it's own init method before overriding the super's implementation? – user3142893 Dec 28 '13 at 23:17
  • At the beginning of the `init` method, `self` is already allocated. `self = [super init]` allows the super class to perform the needed initialization, if any. But if you skip that part, you'll still start out with `self`, and can initialize objects, etc. – Aaron Brager Dec 28 '13 at 23:19
  • See the documentation for `alloc` for the answer to that question [here](https://developer.apple.com/library/ios/documentation/Cocoa/Reference/Foundation/Classes/NSObject_Class/Reference/Reference.html), @user3142893. But, yes, as `alloc` returns the instantiated object. – SevenBits Dec 28 '13 at 23:20
  • When you refer to self in a method's implementation, you're referring to the object that this method is/will sent to? Am I correct? – user3142893 Dec 28 '13 at 23:23
  • You are referring to the object that "owns" the method, i.e the object that you're calling the method on. – SevenBits Dec 28 '13 at 23:28
0

The reason is because by the time your subclass's init method has been called, memory has already been allocated for it. You don't need to allocate memory for the superclass, as you are not instantiating it - you are calling the superclass's init method which already exists. There is a difference between allocation and instantiation.

This is the same paradigm as in other languages like Java. alloc is a class method, not an instance method, so the only way init can ever be called is if alloc has been called already.

Actually, calling [[super alloc] init] would likely produce an unnecessary leaked object, as you have allocated memory that will go out of scope at the end of init, which is a bad thing.

SevenBits
  • 2,836
  • 1
  • 20
  • 33