Objective-C ARC and passing C arrays of objects

First off: while you don't have NSPointerArray, you do have CFMutableArrayRef and you can pass any callbacks you want for retain/release/description, including NULL. It may be easier (and performance is something you can measure later) to try that first.

Taking your points in order:

• you should define your dimensions as [cacheNumber][days][height], as you expect. Then cache[cacheNumber] is a two-dimensional array of type id *[][]. As you've said performance is important, be aware that the fastest way to iterate this beast is:

  for (/* cacheNumber loop */) {
   for (/* days loop */) {
    for (/* height loop */) {
     //...
    }
   }
  }
  

• it should be of type __strong id ***: that's a pointer to a pointer to a pointer to id, which is the same as array of (array of (pointer to id)).

• your ivar needs to be __strong id **** (!), because it's an array of the above things.

• you guess incorrectly regarding allocating the array.. If you're using a multidimensional array, you need to do this (one dimension elided for brevity):

  - (__strong id * * *)someArray {
      __strong id * * *cache = (__strong id * * *)malloc(x*y*sizeof(void *));
      id hello = @"Hello";
  
      cache[0] = (__strong id * *)malloc(sizeof(void *)); //same for cache[1..x-1]
      cache[0][0] = &hello; // for all cache[x][y]
  
      return (__strong id * * *)cache;
  }
  

• correct, that is how you use such a pointer.

• yeah, the two-D array works in the same way, sans the first dimension.
• I don't think so, you're handing out __strong object pointers so you should be grand. That said, we're at about the limit of my ability with this stuff now so I could well be wrong.

I would think of a different implementation. Unless it is a demonstrable (i.e. you have measured and quantified it) performance issue, trying to store Objective-C objects in plain C arrays is often a code smell.

It seems to me that you need an intermediate container object which we will call a Cache for now. One instance will exist for each cache number, and your object will hold an NS(Mutable)Array of them. Cache objects will have properties for the maximum days and height.

The Cache object would most easily be implemented with an NSArray of the objects in it, using simple arithmetic to simulate two dimensions. Your cache object would have a method -objectAtDay:Height: to access the object by its coordinates.

This way, there is no need at all to worry about memory management, ARC does it for you.

Edit

Given that performance is an issue, I would use a 1D array and roll my own arithmetic to calculate offsets. The type of your instance variable would be:

__strong id* myArray;

You can only use C multilevel subscripts (array[i][j][k]) if you know the range of all the dimensions (except the first one). This is because the actual offset is calculated as

(i * (max_j * max_k) + j * max_k + k) * sizeof(element type)

If the compiler doesn't know max_j and max_k, it can't do it. That's precisely the situation you are in.

Given that you have to use a 1D array and calculate the offsets manually, the Apple example will work fine for you.