C中可变大小的数组。可以吗？

Question

My motto is to write some dummy data into the file with minimal load on the system. The size of the data is not known and specified at run time.

For this I can think of 2 solutions.

1) Using Dynamic memory allocation

reserve_size_in_file (int reserve_size, FILE *fp) 
{
    char *p
    p = malloc(reserve_size)
    fwrite(p, sizeof(*p), 1, fp);
    free(p);
}

2) Using arrays

reserve_size_in_file (int reserve_size, FILE *fp) 
{
    char arr[reserve_size];
    fwrite(arr, sizeof(arr), 1, fp);
}

I thought the second method will not work as declaring an array with variable length(ewww...), i thought is not allowed. But it is working. Now my question is, is it ok to use it like this? Also, if there is another better way to do this pls suggest.

Note: I cannot use fallocate() because I have to deal only with stream IO.

Edit:

I just saw that i can use fileno(fp) and use fallocate(). But i donot see many applications using fallocate(). Are there any concerns in using fallocate()

Ex: fallocate(fileno(fp), 0, 0, 100000);

Answer 1

Variable length arrays ( VLA ) are a C99 standard feature and are ok to use as long as you know all the compilers you will use support C99. the C11 standard though made variable length arrays optional. Both gcc and clang support VLAs even outside of C99 mode as an extension. Visual Studio on the other hand did not support C99 until recently and I don't think they support VLA yet.

The alternative if you don't know the size ahead of time is dynamic memory allocation via malloc.

As Jens points out, VLAs do go on the stack and you have limited stack space which can be a problem if the size of your arrays is large, if that is the case then you will have to use dynamic memory.

Answer 2

VLA have two disadvantages

• you don't know how much data you can reserve "on the stack" for them
• there is no error return if the allocation doesn't succeed.

So unless you know for sure that your array will never go beyond some kilo of data, I'd not chose them for this purpose. Otherwise if the allocation fails you'd have spurious errors due to stackoverflow.

Answer 3

I'd do it like this:

reserve_size_in_file (int reserve_size, FILE *fp) 
{
    /* Usual HDDs have a block size of 512, but big
     * block storage is becoming popular. */
    char arr[4096]; 

    /* initialize to 0xff, since runs of NUL bytes might
     * be transparently replaced with sparse file holes. */
    memset(arr, 0xff, sizeof(arr));

    while(reserve_size > sizeof(arr)) {
        fwrite(arr, sizeof(arr), 1, fp);
        reserve_size -= sizeof(arr);
    }
    fwrite(arr, reserve_size, 1, fp);
}

This completely avoids the dynamic memory allocation and operates in nice to work with block sizes.