CODEWITHSUNDEEP
objective-cmemory-managementautomatic-ref-counting
AlexVPerl
AlexVPerl

Reputation: 8016

Objective-C Proper Memory Management & Clean up with ARC

Coming from the world of managed memory, wondering what would be the proper way to clean up objects when using ARC.

For example: if declaring an instance variable in C#, .NET will allow the GC to pick it up once it leaves scope (method/loop body, etc)

What's the proper way to clean-up in Objective-C? Just set the reference/pointer to nil or call dealloc or will ARC detect that no external references are pointing to the instance once execution leaves scope and do the job for you?

Upvotes: 1

Views: 2470

Answers (3)

bntzio
bntzio

Reputation: 1334

Well, in the past, iOS programmers were responsible for telling the system when they were done using an object that they allocated by sending the object a release message. That was done in accordance with a memory management system known as manual reference counting. As of Xcode 4.2, programmers no longer have to worry about this and can rely on the system to take care of releasing memory as necessary. This is done through a mechanism known as Automatic Reference Counting, or ARC for short. ARC is enabled by default when you compile new applications using Xcode 4.2 or later.

You can also disable ARC, in your Xcode interface, go to your main project (not main.h) your actual Xcode project, and select it, you should see a window in Xcode that displays the settings for your project, there will be one that says 'Objective-C Automatic Reference Counting' and it will be set to 'Yes', deactivate it (to 'No') and you shouldn't worry about the ARC, if you come from the world of data management and memory as you said, but keep in mind that it would be easier to you to keep updated to the iOS new features system, that are easier to the programmer to program, it just makes our life easier.

And now, the 'proper way to clean-up in Xcode' with ARC is with 'alloc' and 'init'.

With ARC in Xcode you do not need to worry for 'cleaning' that's the job of Xcode now, you just need to:

1) Create a variable.

2) Allocate.

3) Initialize.

That's it.

An example here:

int main (int argc, char * argv[])
{
   @autoreleasepool {
      Variable  *myVariable;

      // Create an instance of a Variable and initialize it

      myVariable = [Variable alloc];
      myVariable = [myVariable init];

      // Set variable to 4/20

      [myVariable setNumerator: 4];
      [myVariable setDenominator: 20];

      // Display the variable using the print method

      NSLog (@"The value of myVariable is:");
      [myVariable print];
   }

   return 0;
}

Just allocate and then initialize, yo do not need to do any thing else.

Keep in mind getters and setters.

Upvotes: 0

Julien
Julien

Reputation: 3477

ARC means "Automatic Reference Counting" and is just a way to let the compiler add the calls to retain/release/autorelease for you. It's not the same as GC but in most cases, you can consider that objects lifetime is automatically managed for you, like in GC.

If you want more information, you should read LLVM document on ARC

Last note: never call dealloc yourself. dealloc is the object's finalizer which is called once the ObjC runtime determines that the object reference count has reached 0. This method is only meant to be overriden by subclasses. In ARC mode, you generally don't need to do that, except if your object references non-object ivars that need to be finalized once the object itself is finalized.

Upvotes: 1

matt
matt

Reputation: 535925

will ARC detect that no external references are pointing to the instance once execution leaves scope and do the job for you

Basically, yes, that's exactly what ARC will do. You don't need to clean up objects when you're using ARC; in fact, you can't (it stops you from trying to perform manual memory management).

You might want to consult the relevant discussion in my book:

http://www.apeth.com/iOSBook/ch12.html#_memory_management

It explains what's really happening behind the scenes (how memory is actually managed) and then goes on to describe how ARC shields you from most of it.

Note that (as I explain in the URL referenced above) it mostly isn't done by anything like garbage collection: it's done by inserting invisible explicit memory management throughout your code.

Upvotes: 1

Related Questions