Post History

Given that you don't need the flexibility provided by a `char**` but rather need efficiency, plus a fairly large amount of items, it does sound like you need a true 2D array allocated on the heap. 

The char* member isn't ideal either for performance reasons, since it will point at data allocated outside the struct array. Ideally the struct array will be allocated on the heap too, along with the pointed-at data. But if you want this to be truly flexible and realloc:able, you'll probably have to accept that the data is stored elsewhere.

The closest mechanism provided by C are flexible array members. However, these are cumbersome since they don't really support multiple dimensions. Also if we wanted to alloc the whole array on the heap this won't be a good solution since individual array items won't be realloc:able.

So what you already have with the `char*` member is probably not easy to improve. 

You'll either have to use a "mangled" 2D array like:

    baskets[i].items[x*itemcount + y]

Or otherwise cast to an array pointer, which isn't exactly prettier:

    ((char(*)[itemcount])baskets[i].items)[x][y] = something;

It is fine to type pun between a 2D array and a 1D array here as far as strict aliasing is concerned and alignment isn't a problem with char type either.

Using a temporary pointer as middle man is probably the most readable:

```c
for(size_t i=0; i<n; i++)
{
  char (*itemptr)[itemcount] = (char(*)[itemcount]) baskets[i].items;

  for(size_t x=0; x<itemlen; x++)
  {
    for(size_t y=0; y<itemcount; y++)
    {
      itemptr[x][y] = something;
    }
  }
}
```