Resizing an array with C

Question

I need to have an array of structs in a game I'm making - but I don't want to limit the array to a fixed size. I'm told there is a way to use realloc to make the array bigger when it needs to, but can't find any working examples of this.

Could someone please show me how to do this?

Answer 1

Start off by creating the array:

structName ** sarray = (structName **) malloc(0 * sizeof(structName *)); 

Always keep track of the size separately:

size_t sarray_len = 0; 

To increase or truncate:

sarray = (structName **) realloc(sarray, (sarray_len + offset) * sizeof(structName *)); 

Then set the size:

sarray_len += offset; 

Happy to help and hope that helps.

Answer 2

The realloc function can be used to grow or shrink an array. When the array grows, existing entries retain their value and new entries are uninitialized. This may either grow in-place, or if that was not possible, it may allocate a new block elsewhere in memory (and behind the scenes, copy all the values over to the new block and free the old block).

The most basic form is:

// array initially empty T *ptr = NULL;  // change the size of the array ptr = realloc( ptr, new_element_count * sizeof *ptr );  if ( ptr == NULL ) {     exit(EXIT_FAILURE); } 

The multiplication is because realloc expects a number of bytes, but you always want your array to have the right number of elements. Note that this pattern for realloc means you do not have to repeat T anywhere in your code other than the original declaration of ptr.

If you want your program to be able to recover from an allocation failure instead of doing exit then you need to retain the old pointer instead of overwriting it with NULL:

T *new = realloc( ptr, new_element_count * sizeof *ptr );  if ( new == NULL ) {     // do some error handling; it is still safe to keep using     // ptr with the old element count } else {     ptr = new; } 

Note that shrinking an array via realloc may not actually return memory to the operating system; the memory may continue to be owned by your process and available for future calls to malloc or realloc.