C Dynamic Array; Can't Delete - c

Question

Really stuck on the following problem. I'm creating a dynamic array, but when I re-size (for which the logic is creating a new array, copying the values of the old array into the new array, and then deleting old array). I keep getting a memory error when trying to free the memory of old array. See below; I feel like it's something obvious but my eyes just can't see it right now.
Struct to hold the array:
struct DynArr
{
TYPE *data; /* pointer to the data array */
int size; /* Number of elements in the array */
int capacity; /* capacity ofthe array */
};
Function to create a new array:
DynArr *newDynArr(int cap)
{
assert(cap > 0);
DynArr *r = (DynArr *)malloc(sizeof(DynArr));
assert(r != 0);
initDynArr(r, cap);
return r;
}
Initializing the array:
void initDynArr(DynArr *v, int capacity)
{
assert(capacity > 0);
assert(v != 0);
v->data = (TYPE *)malloc(sizeof(TYPE) * capacity);
assert(v->data != 0);
v->size = 0;
v->capacity = capacity;
}
Function to resize the array:
void _dynArrSetCapacity(DynArr *v, int newCap)
{
struct DynArr *newData;
/*new array to hold new values*/
newData = newDynArr(newCap);
///*Intialize the new array*/
initDynArr(newData,newCap);
/*Copy values from old array into new array*/
for (int a = 0; a < v->size; a++)
{
addDynArr(newData, v->data[a]);
}
/*Free the old array, data and array, Cant get this to work*/
/*freeDynArr(v) */
/*Have v point to new array*/
v = newData;
}
And function to free the memory, which is throwing me the error:
void freeDynArr(DynArr *v)
{
if (v->data!= 0)
{
free(v->data); /* free the space on the heap */
v->data = 0; /* make it point to null */
}
v->size = 0;
v->capacity = 0;
}

Answer 1

Your _dynArrSetCapacity function sets up another DynArr block by allocating it again using malloc. The problem here is that you neither return the newData array nor keep the old array (v).
This causes a problem on the caller side. You could've checked your code by doing a while(TRUE) type of block, before exiting _dynArrSetCapacity, which should show that your code doesn't crash before returning.
You have two solutions:
i) Return newData to the caller: While calling _dynArrSetCapacity, your code should update the DynArr variable being used, something like the following:
DynArr *updatedData = _dynArrSetCapacity(newData, newCapacity);
i) Pass a double pointer to _dynArrSetCapacity: The other way is to allow _dynArrSetCapacity to automatically update the pointer to the old DynArr struct. This would require the caller to pass a pointer to that pointer (resulting a double pointer of course). This is called passing out parameters sometimes.
void _dynArrSetCapacity(DynArr** oldData, int newCapacity);
{
DynArr *orgBuffer;// Our new dynamic array to hold the original
// buffer of data
.... Code that will initialize the buffer, do something cool....
_dynArrSetCapacity(&orgBuffer, NEW_CAPACITY);
}
The error you did while coding is that at the end of _dynArrSetCapacity you wrote v = newData and thought that it will be updated for the caller. That is wrong totally. That is because v is copied in the stack and then passed to the callee, which means any changes to v will not affect the originally passed argument (in code).

Answer 2

You don't need to do the realloation yourself, you can use a function called realloc that help you resize an malloc'd array, so the implementation is simpler.
void _dynArrSetCapacity(DynArr *v, int newCap)
{
if(v==NULL||v->data==NULL){
return; // Return early if they are NULL
}
/* Resize the data to newcap*sizeof(TYPE) bytes */
TYPE* tmp=(TYPE*)realloc(v->data,newCap*sizeof(TYPE));
if(tmp!=NULL){
v->data=tmp;
}
}