Question

Please complete the following functions using C.

------------------------------------------------------------

#include

#include "dynarray.h"

/*

* This is the definition of the dynamic array structure you'll use for your

* implementation. Importantly, your dynamic array implementation will store

* each data element as a void* value. This will permit data of any type to

* be stored in your array. Because each individual element will be stored in

* your array as type void*, the data array needs to be an array of void*.

* Hence it is of type void**.

*

* You should not modify this structure.

*/

struct dynarray {

void** data;

int size;

int capacity;

};

/*

* This function should allocate and initialize a new, empty dynamic array and

* return a pointer to it. The array you allocate should have an initial

* capacity of 2.

*/

struct dynarray* dynarray_create() {

return NULL;

}

/*

* This function should free the memory associated with a dynamic array. In

* particular, while this function should up all memory used in the array

* itself (i.e. the underlying `data` array), it should not free any memory

* allocated to the pointer values stored in the array. In other words, this

* function does not need to *traverse* the array and free the individual

* elements. This is the responsibility of the caller.

*

* Params:

* da - the dynamic array to be destroyed. May not be NULL.

*/

void dynarray_free(struct dynarray* da) {

return;

}

/*

* This function should return the size of a given dynamic array (i.e. the

* number of elements stored in it, not the capacity).

*/

int dynarray_size(struct dynarray* da) {

return 0;

}

/*

* This function should insert a new value to a given dynamic array. For

* simplicity, this function should only insert elements at the *end* of the

* array. In other words, it should always insert the new element immediately

* after the current last element of the array. If there is not enough space

* in the dynamic array to store the element being inserted, this function

* should double the size of the array.

*

* Params:

* da - the dynamic array into which to insert an element. May not be NULL.

* val - the value to be inserted. Note that this parameter has type void*,

* which means that a pointer of any type can be passed.

*/

void dynarray_insert(struct dynarray* da, void* val) {

return;

}

/*

* This function should remove an element at a specified index from a dynamic

* array. All existing elements following the specified index should be moved

* forward to fill in the gap left by the removed element. In other words, if

* the element at index i is removed, then the element at index i+1 should be

* moved forward to index i, the element at index i+2 should be moved forward

* to index i+1, the element at index i+3 should be moved forward to index i+2,

* and so forth.

*

* Params:

* da - the dynamic array from which to remove an element. May not be NULL.

* idx - the index of the element to be removed. The value of `idx` must be

* between 0 (inclusive) and n (exclusive), where n is the number of

* elements stored in the array.

*/

void dynarray_remove(struct dynarray* da, int idx) {

return;

}

/*

* This function should return the value of an existing element a dynamic

* array. Note that this value should be returned as type void*.

*

* Params:

* da - the dynamic array from which to get a value. May not be NULL.

* idx - the index of the element whose value should be returned. The value

* of `idx` must be between 0 (inclusive) and n (exclusive), where n is the

* number of elements stored in the array.

*/

void* dynarray_get(struct dynarray* da, int idx) {

return NULL;

}

/*

* This function should update (i.e. overwrite) the value of an existing

* element in a dynamic array.

*

* Params:

* da - the dynamic array in which to set a value. May not be NULL.

* idx - the index of the element whose value should be updated. The value

* of `idx` must be between 0 (inclusive) and n (exclusive), where n is the

* number of elements stored in the array.

* val - the new value to be set. Note that this parameter has type void*,

* which means that a pointer of any type can be passed.

*/

void dynarray_set(struct dynarray* da, int idx, void* val) {

return;

}

Answer 1

Hi following are the function implementations............................................

struct dynarray{
void** data;
int size ;
int capacity;
};

struct dynarry* dynarra_create(){
struct dynarray * array= malloc(sizeof(struct dynarray));
array->data=malloc(2 *sizeof(void *));
array->capacity=2;
return array;
};

void dynarray_free(struct dynarray* da){
free(*(da->data));
}

int dynarray_size(struct dynarray* da){
return da->size;
}

// how to double the size of array
void dynarray_insert(struct dynarray * da,void *val){
da->size=da->size+1;
//If there is not enough space in the dynamic array to store the element being inserted,
//,this function should double the size of the array.
if(da->size > da->capacity){

void** temp=malloc(2*da->capacity*sizeof(void *));
for(int i=0;i<=da->size;i++){
*(temp +i)= *(da->data+i);
}
da->data=temp;
}

*(da->data + da->size)=val;
}

void dynarray_remove(struct dynarray* da,int idx){
while(idx <= da->size){
*(da->data+idx)=*(da->data+idx+1);
idx=idx+1;
}
da->size=da->size-1;
}

void* dynarray_get(struct dynarray* da,int idx){
return *(da->data+idx);
}

void dynarry_set(struct dynarray* da,int idx,void*val){
*(da->data +idx)=val;
}