4

I want to set an object to 'nil' as I enumerate through an array, as follows:

for(Object* object in array){
    object = nil;
}

Xcode then tells me 'Fast enumeration variables can't be modified in ARC by default; declare the variable __strong to allow this.'

Which means doing this:

for(Object __strong* object in array){
    object = nil;
}

This seems to be redundant. As far as I understand, declaring a strong reference to an object increases its retain count by one, and nil-ing it decreases the retain count by one. So how, then, do I set an object to nil while enumerating through an array?

I am using ARC.

Fitzy
  • 1,871
  • 6
  • 23
  • 40
  • What are you trying do do here? Setting the loop variable to nil is pointless. I you want to clear memory then set the array to nil or remove all of the objects from the array. – rmaddy Jan 08 '13 at 06:04
  • Removing objects from the array doesn't necessarily delete the objects though, does it? – Fitzy Jan 08 '13 at 06:06
  • What do you mean by "delete the objects"? Removing them from the array decreases the retain count. If nothing else is retaining the object then it will be deallocated. – rmaddy Jan 08 '13 at 06:08
  • Please explain your larger goal more clearly, because the route you are using to achieve it is most certainly the wrong one. – jscs Jan 08 '13 at 06:20
  • I am attempting to free the memory at which each object in the array is stored. By simply calling `removeAllObjects` on the array, I don't know for sure if the memory is being freed, as I am not entirely sure if the objects are referenced elsewhere. – Fitzy Jan 08 '13 at 06:31
  • 1
    First, trying to force other, unknown, objects to lose their ownership of an object is a very bad idea. Second, under ARC, I don't think you can't do it. If you want the objects to go away and the array is retaining them, release the array or use `removeAllObjects`. Let other objects that need the contents of the array deal with their memory management themselves. – jscs Jan 08 '13 at 06:37
  • Ahh I see. Thanks a lot for the help, if you turned that into an answer I'd accept it. – Fitzy Jan 08 '13 at 06:44

3 Answers3

3

See Fast enumeration iteration variables in the Clang "Objective-C Automatic Reference Counting" documentation:

If a variable is declared in the condition of an Objective-C fast enumeration loop, and the variable has no explicit ownership qualifier, then it is qualified with const __strong and objects encountered during the enumeration are not actually retained.

Rationale
This is an optimization made possible because fast enumeration loops promise to keep the objects retained during enumeration, and the collection itself cannot be synchronously modified. It can be overridden by explicitly qualifying the variable with __strong, which will make the variable mutable again and cause the loop to retain the objects it encounters.

So by default, the loop variable is immutable, and the retain count of the current object is not increased for performance reasons.

If you explicitly declare the loop variable as __strong, it is a mutable strong reference, and the retain count of the current object is increased, and setting the loop variable to nil decreases the retain count again. But doing so does not deallocate the object or remove it from the array, because the array holds another strong reference to the object.

Martin R
  • 529,903
  • 94
  • 1,240
  • 1,382
  • So, as I thought, it's redundant to declare a strong reference to the object and then set it to `nil`. So how, then, does one free the memory of the objects in the array? Calling `removeAllObjects` on the array does not necessarily mean the object does not hold a strong reference anymore, as there may be other objects referencing it. – Fitzy Jan 08 '13 at 06:39
  • @dreamlax yes, so I've gathered. I'm still getting used to memory management; I have turned a blind eye on it for far too long now.... – Fitzy Jan 08 '13 at 06:48
  • @Fitzy: " So how, then, does one free the memory of the objects in the array?" - You can't, as explained by rmaddy and Josh Caswell. Setting a strong reference to `nil` is not a replacement for `dealloc` (which is forbidden under ARC), it just decreases the retain count of the object. The object will be deallocated when the last strong reference is gone. – Martin R Jan 08 '13 at 06:55
2

A shortcut:

[array removeAllObjects];

If you want your array to still contain x number of items but just not the items that are currently in it, you can use the NSNull placeholder:

for (NSUInteger i = 0; i < [array count]; i++)
    [array replaceObjectAtIndex:i withObject:[NSNull null]];

Remember that the array only holds references to its objects. Memory management will kick in and deallocate the objects if the array no longer holds a reference to them (but only if nothing else does either).

dreamlax
  • 93,976
  • 29
  • 161
  • 209
0

In the comments, you've revealed that your intention here is to deallocate the objects that are in the array whether or not something else also has an ownership claim on them. This is a violation of a core memory management principle: you must not free memory that you don't own. It is A Bad Idea to do what you want to do.

You must allow other objects to manage their own memory. Perhaps one of the items in the array is a piece of data that a UI object is displaying. When the UI object needs to refresh itself, and looks for the data which has been deallocated out from under it, your application will likely crash.

There are two things that you are allowed to do, from the perspective of this array. You can deallocate the array as a whole, which will give up the array's claims on the contained objects; if they are not owned by anything else, they will be deallocated. If you want to keep the array itself, but release all its items, use removeAllObjects; again, the items will be deallocated if nothing else owns them.

The important point is that if something else does own them, it's probably for a good reason, and you should not be doing an end run around it.

jscs
  • 63,694
  • 13
  • 151
  • 195