Variable sized arrays in Objective-C?
arrays, objective-c, variable-length-array
Solution
it is legal in C99, although dangerous, and yes -- it is like `alloca`.
because it's like alloca, you want reasonably sized arrays when allocating on the stack. i am not sure if this is defined if the length is zero, but you could definitely cause a stack overflow if the array is 'large enough' to do so.
as far as what is going on -- pulling it out of the loop should make no difference if the sizes are reasonable. i suspect you are seeing undefined behavior because a parameter value is too large (or perhaps 0) -- you should validate the `chunkSize` parameter. the assembly will tell you why pulling it out of the loop makes a difference (assuming everything else in the program is well-formed).
Problem
Okay, so apparently this works: ``` void foo(size_t s) { int myArray[s]; // ... use myArray... } ``` Is this really legal? I mean, it must be, because it compiles (where the C compiler would reject it as non-constant). The first part of my question is: how does this work? I assume it's allocating it on the stack? Is this different from using `alloca()`? Practically, I found some code that does this: ``` void bar(size_t chunkSize) { CFReadStreamRef foo = NULL; // ...some stuff to init foo... while (stuffToDo) { UInt8 buffer[chunkSize]; // ...read some data from stream into buffer // using CFReadStreamRead()... } } ``` This works. However, when I move the buffer allocation from inside the loop to the first line of the function (directly before `foo` is declared), the function... stops working. In the debugger it gets to the first access of local variables and then just... exits. I don't see any exceptions being thrown, it doesn't crash, it just program carries on running (in reality the function returns a string and that return value is `NULL`, which is what the return variable is initialized to). I'm not sure what's going on. The second part of my questions is, in light of the first part, what the heck is going on?