如何在 function - ANSI C 中使用本地数组？

Question

I want to add something to the end of the array passed to the function.
Which is better, declaring a new larger array or using alloc ()?
1.

void array_append(int *block, size_t size)
{
   int new_block[size + 2];
   memcpy(new_block, block, size);
   (...append)

}

void array_append(int *block, size_t size)
{
   int *new_block = calloc(1, sizeof(int) + 2);
   memcpy(new_block, block, size);

   (...append)

   free(new_block);
}

I am not returning the newly created array anywhere.

I only use new_block inside functions.
Does not modify the original array in the function.
Declaring new_block as static is omitted.
I know how calloc() / malloc() works, I know that this operation has to be validated.
new_block is only meant to live in a function.
I just wonder which solution is better and why...

regards

Answer 1

You should dynamically allocate an array instead of using a variable length array because in general in the last case the code can be unsafe due to a comparatively big size of the array that can lead to the stack overflow.

Answer 2

I want to add something to the end of the array

But you cannot really. Unless with realloc() . This is how your ...append trick can be done, whatever it means.

If you need a temporary array to work with and then copy into your array (but not at the end,). then all methods for allocation are allowed - it really depends on how often and with which sizes.

If it is called very often with limited sizes, it could be a static array.

There is no easy solution for growing arrays (or for memory management in general). At the extreme you allocate every element individually and link them together: a linked list.

--> avoid reaching the end of your arrays. Define a higher maximum or then implement a linked list.

In certain situations realloc() also makes sense (big changes in size, but not often). Problem is sometimes the whole array has to be memcopied to keep the larger array contiguous: "realloc", not "append". So it is "expensive".

I am not returning the newly created array anywhere.

That is part of the problem. You actually seem to be doing half of what realloc() does: allocate the new space, memcpy() the old contents...and then free the old and return the new array(-pointer) to the caller.

First version can not return the array pointer, because end of function is also end of local auto arrays, VLA or not.

Answer 3

If the append can be done to the existing array (which it can if the caller expects this and the memory of the array has room), you can merely append to the existing array.

Otherwise, you need a new array. In this case, the array must be returned to the caller. You can do this by returning a pointer to its first element or by having the caller pass a pointer to a pointer, and you modify the pointed-to pointer to point to the first element of the new array.

When you provide a new array, you must allocate memory for it with malloc or a similar routine. You should not use an array defined inside your function without static , as the memory for such an array is reserved only until execution of the function ends. When your function returns to the caller, that memory is released for other uses. (Generally, you also should not use an array declared with static , but for reasons involving good design, reducing bugs, and multiple serial or parallel calls to the function.)