CODEWITHSUNDEEP
objective-ccocoamemoryobjectalloc
Greg Steiner
Greg Steiner

Reputation: 767

Memory allocation for an array of Objects - Is my understanding valid?

I have a question regarding memory allocation for Objects in an array. I am looking to create an array of Objects, but at compile time, I have no way of knowing how many objects I will need, and thus don't want to reserve more memory than needed.

What I would like to do is allocate the memory as needed. The way I would like to do this is when the user clicks an "Add" button, the array is increased by one additional object and the needed memory for the new object is allocated.

In my novice understanding of Objective C (I was a professional programmer about 20 years ago, and have only recently begun to write code again) I have come up with the following code segments:

First, I declared my object:

    NSObject *myObject[1000]; // a maximum number of objects.

Then, when the user clicks an Add button it runs a method with the allocation code: (note: the variable i starts out at a value of 1 and is increased each time the Add button is clicked)

    ++i
    myObject[i] = [[NSObject alloc] init];

Thus, I'm hoping to only allocate the memory for the objects actually needed, rather than all 1000 array objects immediately.

Am I interpreting this correctly? In other words, am I correct in my interpretation that the number of arrayed elements stated in the declaration is the MAXIMUM possible number of array elements, not how much memory is allocated at that moment? It this is correct, then theoretically, the declaration:

    NSObject *myObject[10000];

Wouldn't pull any more memory than the declaration:

    NSObject *myObject[5];

Can someone confirm that I'm understanding this process correctly, enlighten me if I've got this mixed up in my mind. :)

Thanks!

Upvotes: 3

Views: 5687

Answers (2)

Ben Harris
Ben Harris

Reputation: 5684

Why not use NSMutableArray? You can initWithCapacity or simply allocate with [NSMutableArray array]. It will grow and shrink as you add and remove objects. For example:

NSMutableArray *array = [NSMutableArray array];
NSObject *object = [[NSObject alloc] init];

[array addObject:object]; // array has one object
[array removeObjectAtIndex:0]; // array is back to 0 objects

// remember to relinquish ownership of your objects if you alloc them
// the NSMutable array was autoreleased but the NSObject was not
[object release];

Upvotes: 4

aroth
aroth

Reputation: 54854

Your understanding is mostly correct. When you do:

NSObject *myObject[1000];

You immediately allocate storage for 1000 pointers to NSObject instances. The NSObject instances themselves are not allocated until you do [[NSObject alloc] init].

However, doing NSObject *myObject[10000] will consume more space than doing NSObject *myObject[5], because 10,000 pointers certainly require more memory to represent than 5 pointers.

Remember that both things consume space, the pointer to the NSObject, and the NSObject instance itself, though in practice the space consumed by an NSObject instance will be significantly larger than the 4 bytes consumed by the pointer that refers to it.

Anyhow, perhaps more importantly, there is a better way to manage dynamic object allocation in Cocoa. Use the built-in NSMutableArray class. Like:

NSMutableArray* objects = [[NSMutableArray alloc] init];
[objects addObject: [[[NSObject alloc] init] autorelease]];

Upvotes: 3

Related Questions