iOS autorelease pool blocks

Question

I was reading the documentation from apple about memory management when I got to autorelease pool blocks and something got me thinking.

 Any object sent an autorelease message inside the autorelease pool block is  
 released at the end of the block.

I am not sure I fully understand this. Any object created inside an autorelease pool block gets released at the end of the block anyway because that is it's life span. Why would you need to call autorelease to the object when it is going to get released anyway when it reaches the end of the block?

To be clearer, I will give an example, of what I am thinking:

   @autoreleasepool {

    MyObject *obj = [[MyObject alloc] init]; // no autorelease call here

    /* use the object*/
   //....
   // in the end it should get deallocated because it's lifespan ends, right?
   // so why do we need to call autorelease then?!
  }

PS: Please don't tell me that because of ARC we don't need to do some things because ARC takes care of them. I am fully aware of that, but I want to leave ARC aside for just a few moments to understand the mechanism of memory management.

Answer 1

Autorelease just removes a retain count from the object it does not "free" the memory immediately like in c. When the autorelease pool ends all auto released objects with a count of 0 will have their memory freed up.

Sometimes you create a lot of objects. An example would be a loop that is creating new strings every time it iterates and adds new data to the string. You may not need the previous versions of the string and will want to free up memory used by those. You can accomplish this by explicitly using the autorelease pool instead of waiting for it to be done naturally.

//Note: answers are psudocode

//Non Arc Env
@autoreleasepool 
{

    MyObject *obj = [[MyObject alloc] init]; // no autorelease call here
    //Since MyObject is never released its a leak even when the pool exits

}
//Non Arc Env
@autoreleasepool 
{

    MyObject *obj = [[[MyObject alloc] init] autorelease]; 
    //Memory is freed once the block ends

}
// Arc Env
@autoreleasepool 
{

    MyObject *obj = [[MyObject alloc] init]; 
    //No need to do anything once the obj variable is out of scope there are no strong pointers so the memory will free

}

// Arc Env
MyObject *obj //strong pointer from elsewhere in scope
@autoreleasepool 
{

    obj = [[MyObject alloc] init]; 
    //Not freed still has a strong pointer 

}

Answer 2

(Mostly just giving some additional background; @Kibitz503 is getting you to the right answer.)

@autoreleasepool {

  MyObject *obj = [[MyObject alloc] init]; // no autorelease call here

  /* use the object*/
  //....
  // in the end it should get deallocated because it's lifespan ends, right?
  // so why do we need to call autorelease then?!
}

PS: Please don't tell me that because of ARC we don't need to do some things because ARC takes care of them. I am fully aware of that, but I want to leave ARC aside for just a few moments to understand the mechanism of memory management.

OK, let's not consider ARC. In the above, without ARC, obj would not be deallocated. Only because ARC adds additional release calls does possibly get deallocated (given your example, we actually have no idea since we don't know what happens in use the object).

As @Kibitz503 explains, "release" does not mean "deallocate." At the end of the block, the autorelease pool drains, which means any pending autorelease calls are sent as release at the end of the block. If that leads to the object reaching a 0 retain count, then it is deallocated.

But whether the above is in a block or not, without ARC it is a leak.

Answer 3

Autorelease pools defer release of the object till the end of the pool which avoids the possibility of it being released before it reaches the end. So basically, it is to make sure the object will not be released before the end of the pool.