Dynamic array in C - how to make it work? - c

Question

I'm trying to make function for dynamic arrays in C but I'm not sure, if I'm solving it right way. Could you help me?
Here is my code:
int resizeArray(int array_rows, int **array[])
{
int new_rows = array_rows + 16;
int *pointer;
pointer = realloc(**array, new_rows*sizeof(int));
if (!pointer) {
free(**array);
return 0;
}
**array = pointer;
free(pointer);
return new_rows; // return new rows counter
};
some code....
/* first array definition */
int *data;
int array_rows = 16;
data = (int*)malloc(array_rows*sizeof(int));
if array is full:
array_rows = resizeArray(array_rows,&data);
Thank you very much for your reviews and tips.
EDIT:
int resizeArray(int array_rows, int **array){
int new_rows = array_rows + 16;
int *pointer;
pointer = realloc(**array, new_rows*sizeof(*pointer));
if (!pointer) {
free(**array);
return 0;
}
**array = pointer;
free(pointer);
return new_rows; // return new rows counter
}
some code....
/* first array use */
int *data;
int array_rows = 16;
data = (int*)malloc(array_rows*sizeof(*data));
if array is full:
array_rows = resizeArray(array_rows,&data);
EDIT - CODE WITH STRUCTURES:
struct MyDynamicArray {
int maximumSize = 16;
int length = 0;
int* data;
}
/* first array definition */
MyDynamicArray.data = (int*)malloc(MyDynamicArray.maximumSize*sizeof(int));
int resizeArray(int array_rows, struct MyDynamicArray)
{
int new_rows = MyDynamicArray.maxSize * 2;
int *pointer;
pointer = realloc(MyDynamicArray.data, new_rows*sizeof(int));
if (!pointer) {
free(MyDynamicArray.data);
return 0;
}
MyDynamicArray.maxSize = new_rows; // return new rows counter
};
/* usage */
resizeArray(array_rows,MyDynamicArray);
WORKING SOLUTION:
resizeArray function definition:
/**
* resize array
* - its size resize X 2
* #param max_length
* #param data
* #return
*/
int resizeArray(int max_length, int **data)
{
data = (int *) realloc(**data, max_length * 2 * sizeof(int));
max_length *= 2;
return max_length; // return new rows counter
}
FIRST ARRAY DEFINITION
int *data_i;
int max_length = 16;
int *data;
data = (int *) realloc((void *) data_i, max_length * sizeof(int));
HERE IS USAGE:
int i = 0;
for(i = 0; i < 100; i++)
{
data[i] = i;
if(i == max_length)
{
max_length = resizeArray(max_length, &data);
}
}
I hope, it's right and will help to solve someones problem.

Answer 1

A few things:
It very well may work, but you have pointers going crazy. The second parameter can simply be int* array (and when you call it, there is no need to reference it). This way, the call to realloc will simply take array, as will the calls to free. (and you simply have array = pointer;
You're freeing the newly allocated memory. This will cause a segfault if you try to use the array after resizing. Remove that line, memory management should be the responsibility of function.
Also, in general, dynamic arrays will resize by doubling their size. realloc is expensive, but memory these days is cheap. This noted, it may be beneficial for you to always call resizeArray whenever you write to it, and pass it the length of the array plus the amount of elements you are writing. I'm not certain what you are going to do with your new, dynamic array, but it will likely save you many headaches if you maintain something like:
struct MyDynamicArray {
int maximumSize;
int length;
int* data;
}

Answer 2

There are so many iterations of MyDynamicArray it's hard to discern the final approach taken. One area where there seems to be confusion is over what am I reallocating?. Here, it appears you simply have one MyDynamicArray struct and an int array data member of that struct then needs reallocating. There are a number of approaches to doing this, but a clean approach is to #define an initial array size, allocate your data array to the initial defined size, then when the number of elements reaches initial size - 1 reallocate data.
An example taking the approach is as follows. A typedef to the struct has been created to cut down on typing. Look though the code, understand what it is doing where, and drop a comment if you have additional questions:
#include <stdio.h>
#include <stdlib.h>
#define ARRSZ 5
typedef struct
{
size_t size;
int* data;
} MyDynamicArray;
int *resizeArray (int **mdata, size_t newsize)
{
int *tmp = realloc (*mdata, newsize * sizeof(int));
if (!tmp)
return NULL;
*mdata = tmp;
return *mdata;
}
int main () {
MyDynamicArray *mda = malloc (sizeof (MyDynamicArray));
mda->size = ARRSZ;
mda->data = malloc (ARRSZ * sizeof (int));
int i = 0;
int newsize = 0;
for (i = 0; i < 50; i++)
{
if (i >= mda->size - 1)
{
newsize = 2 * mda->size;
if (resizeArray (&mda->data, newsize))
mda->size = newsize;
else {
fprintf (stderr, "error: reallocation failed at mda->size: %zd\n", mda->size);
exit (EXIT_FAILURE);
}
}
mda->data[i] = i;
}
printf ("\nElements of dynamic array:\n\n");
for (i = 0; i < 50; i++)
printf (" mda->data[%2d] : %d\n", i, mda->data[i]);
if (mda->data) free (mda->data);
if (mda) free (mda);
return 0;
}
Note: you can also assign a newpointer when you realloc if for some reason that is desirable. (e.g. int *newptr = resizeArray (&mda->data, newsize);) However, for simply resizing your array resizeArray (&mda->data, newsize); is sufficient.
output:
$ ./bin/mydynarray
Elements of dynamic array:
mda->data[ 0] : 0
mda->data[ 1] : 1
mda->data[ 2] : 2
mda->data[ 3] : 3
mda->data[ 4] : 4
mda->data[ 5] : 5
mda->data[ 6] : 6
mda->data[ 7] : 7
mda->data[ 8] : 8
mda->data[ 9] : 9
mda->data[10] : 10
mda->data[11] : 11
mda->data[12] : 12
mda->data[13] : 13
mda->data[14] : 14
mda->data[15] : 15
mda->data[16] : 16
mda->data[17] : 17
mda->data[18] : 18
mda->data[19] : 19
mda->data[20] : 20
mda->data[21] : 21
mda->data[22] : 22
mda->data[23] : 23
mda->data[24] : 24
mda->data[25] : 25
mda->data[26] : 26
mda->data[27] : 27
mda->data[28] : 28
mda->data[29] : 29
mda->data[30] : 30
mda->data[31] : 31
mda->data[32] : 32
mda->data[33] : 33
mda->data[34] : 34
mda->data[35] : 35
mda->data[36] : 36
mda->data[37] : 37
mda->data[38] : 38
mda->data[39] : 39
mda->data[40] : 40
mda->data[41] : 41
mda->data[42] : 42
mda->data[43] : 43
mda->data[44] : 44
mda->data[45] : 45
mda->data[46] : 46
mda->data[47] : 47
mda->data[48] : 48
mda->data[49] : 49