7

I have a situation where I'd like to be able to maintain an array of pointers that might all possibly point to nil.

Equipment *equipment[19];

However, I've found that I cannot set an array of pointers, or a double-pointer, as a property of an object.

My workaround when I can't use C-style arrays is to use the NSArray objects. So I attempted to do something like the following:

NSMutableArray *equipment = [NSMutableArray arrayWithCapacity: NUM_EQUIPSLOTS];
for (int i=0; i<NUM_EQUIPSLOTS; i++) {
    [equipment setObject: nil atIndexedSubscript: i];
}

The idea here being I have an array of empty pointers that will later point to stuff.

*** Terminating app due to uncaught exception 'NSInvalidArgumentException', reason: '*** -[__NSArrayM insertObject:atIndex:]: object cannot be nil'
*** First throw call stack:
(0x246e012 0x1e4be7e 0x2421b6a 0x2421a20 0xebd02 0xde82b 0xc9d5a 0xcb6bd 0x4d525 0xc94fa 0xc8b6a 0xa18157 0xa18747 0xa1994b 0xa2acb5 0xa2bbeb 0xa1d698 0x3176df9 0x3176ad0 0x23e3bf5 0x23e3962 0x2414bb6 0x2413f44 0x2413e1b 0xa1917a 0xa1affc 0xc8526 0x1fa5)
libc++abi.dylib: terminate called throwing an exception

I know I can do this very easily using C-style arrays, and with individual objects. I'd rather do it this way than something dumb like:

Equipment *equipment0 = nil;
Equipment *equipment1 = nil;
Equipment *equipment2 = nil;
// ...
Equipment *equipment18 = nil;

This probably has to do with the structure of the NSArray model itself. Would someone explain to me why this is, and why I can't simply add or set nil objects in NSArray? Thank you in advance.

Improve this question
6
  • 8
    Use NSNull to simulate nil, or an NSPointerArray for actual NULL in a collection. Commented Mar 28, 2013 at 0:52
  • 1
    If you're writing for iOS6+ or OS X 10.5+, then might consider NSPointerArray. developer.apple.com/library/mac/#documentation/Cocoa/Reference/… Commented Mar 28, 2013 at 0:55
  • 1
    If you want to know why, decompile Core Foundation and see what CFArray does when it adds an object to itself. You'll see exactly why if you can wade through enough of the inline asm and obscure CF functions. Commented Mar 28, 2013 at 1:30
  • @CodaFi I'm totally ok with doing that, actually! In the end, I've solved the problem I was having, but in order to really answer my question, I'll have to do exactly as you suggest. Thanks for the direction! :) Commented Mar 28, 2013 at 2:14
  • 1
    There's no reason to decompile Core Foundation. Much of it is open source. opensource.apple.com/source/CF/CF-744.12/CFArray.c Commented Mar 29, 2013 at 0:48

2 Answers 2

Reset to default
10

The "why" is both trivial and unsatisfying. It is because NSMutableArray holds objects, and nil is not an object. ObjC has a strong distinction between objects and primitive types. nil is a primitive type. As CodaFi notes, you can use NSNull or NSPointerArray to address these. The typical solution is NSNull.

Improve this answer
Sign up to request clarification or add additional context in comments.

9 Comments

I've even known some people to allocate empty NSMutableArrays where nil objects should be. He doesn't need NSNull, just some delimiting type.
The "deep" "why" is that ObjC is SmallTalk concepts layered on top of C. Many things are not objects because it would be inefficient or inconvenient to implement in the underlying C. That's the nature of a hybrid language like ObjC. For all the very wonderful things of Cocoa, ObjC stil is just a thin object-veneer on top of a fundamentally C-based language.
"It is because NSMutableArray holds objects" Not true. NSMutableArray holds pointers to objects. All manipulation with "objects" in Objective-C must be through pointers to objects. "Objects" are not values in themselves.
@newacct, it's a good comment, but it can be more confusing. When you say "it holds pointers to objects," that suggests that a NULL pointer should be acceptable (as it would be for a C++ vector of pointers to objects). But in ObjC this is not true; arrays cannot hold arbitrary pointers to objects; they can only hold actually instantiated object references (which are generally called "objects" in ObjC). But I agree for some students, your way of saying it is more clear. Eventually all students should understand the distinction, it's just challenging to know when to introduce which concept.
@RobNapier: when you say "arrays cannot hold arbitrary pointers to objects", do you mean NSArray? It would be trivial (and more consistent) to make an array class that allowed nil. As for arbitrary non-nil pointers, the only impediment is you cannot send the retain and release messages to them. However, you can send retain and release messages to nil, so for all the array cares, it behaves no different than a pointer to an active object. There is no particular reason to make an extra rule to disallow nil.
|
5

There is no good reason. NSArray and NSMutableArray stores pointers to objects. nil is a decent pointer to an object. The Java equivalent is ArrayList, which does permit null elements. It was just a design choice.

One possible historical reason for this design choice is that the most common way to create an array and fill it with elements is to use the -initWithObjects:... or +arrayWithObjects:... methods, which use varargs to take as many arguments as the user wants to give and put it in the array. Since with varargs in C, it is impossible to determine the number of arguments, the way they chose to indicate how many was to use nil as a "terminator" to signal the end of the list. (There are other ways to indicate the number, e.g. pass the number as the first argument.) The disadvantage of this method was that you cannot put nil as one of the "arguments" that you wanted to put in the array, since it would terminate the list.

However, those methods were not the only ways to create an array and fill it with elements. You could create an empty array and add each one separately, or you could use the -initWithObjects:count: or +arrayWithObjects:count: methods, which are not varargs and thus did not have the nil terminator issue. Now, there is also the array literal syntax (which calls -initWithObjects:count: internally) which makes it even easier. It is perfectly conceivable to have NSArray and NSMutableArray that allows nil elements; just that you cannot use -initWithObjects:... or +arrayWithObjects:... to add the nil elements. However, they chose not to do this.

Improve this answer

1 Comment

As I read the first paragraph here, I see exactly the confusion that I discussed :D (It's not wrong; it's just can make things more confusing for those coming from other languages.)

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.