Question

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?

Answer 1

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).