c pointers to struct issue - c

Question

Would someone please help me with thhis c pointers issue. It seems to me like it should work but there must be something im not understanding as the code doesnt compile. On the line where is says this: ERROR<<<<>>>>>>>>. I think the problem is with function getDynArr which is at the tag: GETDYNARR<<<<<<<<<<<<<<<<<<<<>>>>>>>>>>>>>>>>. I think getDynArr(da, i) may be returning int for some reason?
/* dynArr.c: Dynamic Array implementation. */
#include <assert.h>
#include <stdlib.h>
#include <stdio.h>
#ifndef KEYTYPE
#define KEYTYPE char *
#endif
#ifndef VALUETYPE
#define VALUETYPE double
#endif
#ifndef TYPE
#define TYPE struct association
//# define TYPE int
#endif
struct association
{
KEYTYPE key;
VALUETYPE value;
};
struct DynArr
{
TYPE *data; /* pointer to the data array */
// struct association *data;
int size; /* Number of elements in the array */
int capacity; /* capacity ofthe array */
};
///////////////////dictionary Section
void dyArrayDictionaryPut(struct DynArr *vec, KEYTYPE key, VALUETYPE val)
{
struct association *ap;
if (dyArrayDictionaryContainsKey(vec,key))
dyArrayDictionaryRemove(vec, key);
ap = malloc(sizeof(struct association));
assert(ap != 0);
ap->key = key;
ap->value = val;
//dyArrayAdd(vec, ap);
addDynArr(vec, ap);
}
VALUETYPE dyArrayDictionaryGet(struct DynArr *da, KEYTYPE key, VALUETYPE *valptr)
{
struct association *ap;
int i = 0;
if(dyArrayDictionaryContainsKey(da, key))
{
for ( i = 0; i < da->size; i++)
{
//if(da->data[i]->key == key)
if(da->data[i].key == key)
{
//return da->data->value;
struct association temp3;
temp3 = getDynArr(da, i); //ERROR<<<<<ERROR>>>>>>>>>incompatible types when assigning to type 'struct association' from type 'int'
//ap = getDynArr(da, i);
//*valptr = ap->value;
}
}
}
}
int dyArrayDictionaryContainsKey(struct DynArr *da, KEYTYPE key)
{
int i = 0;
for (i = 0; i < da->size; i++)
{
if(da->data[i].key == key)
{
return 1;
}
}
return 0;
}
void dyArrayDictionaryRemove(struct DynArr *da, KEYTYPE key)
{
for (int i = 0; i < da->size; i++)
{
if(da->data[i].key == key)
{
removeAtDynArr(da, i);
return;
}
}
}
////
void _initDynArr(struct DynArr *v, int capacity)
{
assert(capacity > 0);
assert(v!= 0);
v->data = malloc(sizeof(TYPE) * capacity);
assert(v->data != 0);
v->size = 0;
v->capacity = capacity;
}
struct DynArr* createDynArr(int cap)
{
struct DynArr *r;
assert(cap > 0);
r = malloc(sizeof( struct DynArr));
assert(r != 0);
_initDynArr(r,cap);
return r;
}
void freeDynArr(struct DynArr *v)
{
assert(v!=0);
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;
}
void deleteDynArr(struct DynArr *v)
{
assert (v!= 0);
freeDynArr(v);
free(v);
}
void _dynArrSetCapacity(struct DynArr *v, int newCap)
{
int i;
TYPE *oldData;
int oldSize = v->size;
oldData = v->data;
printf("========Resizing========\n");
/* Create a new dyn array with larger underlying array */
_initDynArr(v, newCap);
for(i = 0; i < oldSize; i++){
v->data[i] = oldData[i];
}
v->size = oldSize;
/* Remember, init did not free the original data */
free(oldData);
#ifdef ALTERNATIVE
int i;
/* Create a new underlying array*/
TYPE *newData = (TYPE*)malloc(sizeof(TYPE)*newCap);
assert(newData != 0);
/* copy elements to it */
for(i = 0; i < v->size; i++)
{
newData[i] = v->data[i];
}
/* Delete the oldunderlying array*/
free(v->data);
/* update capacity and size and data*/
v->data = newData;
v->capacity = newCap;
#endif
}
int sizeDynArr(struct DynArr *v)
{
assert(v!=0);
return v->size;
}
void addDynArr(struct DynArr *v, TYPE val)
{
assert(v!=0);
/* Check to see if a resize is necessary */
if(v->size >= v->capacity)
_dynArrSetCapacity(v, 2 * v->capacity);
v->data[v->size] = val;
v->size++;
}
//GETDYNARR<<<<<<<<<<<<<<<<<<<<<GETDYNARR>>>>>>>>>>>>>>>>>
//type is struct association
//TYPE getDynArr(struct DynArr *v, int pos )
struct association getDynArr(struct DynArr *v, int pos)
{
assert(v!=0);
assert(pos < v->size);
assert(pos >= 0);
struct association returned = v->data[pos];
return returned;
}
void putDynArr(struct DynArr *v, int pos, TYPE val)
{
assert(v!=0);
assert(pos < v->size);
assert(pos >= 0);
v->data[pos] = val;
}
void swapDynArr(struct DynArr *v, int i, int j)
{
TYPE temp;
assert(v!=0);
assert(i < v->size);
assert(j < v->size);
assert(i >= 0);
assert(j >= 0);
temp = v->data[i];
v->data[i] = v->data[j];
v->data[j] = temp;
}
void removeAtDynArr(struct DynArr *v, int idx){
int i;
assert(v!= 0);
assert(idx < v->size);
assert(idx >= 0);
//Move all elements up
for(i = idx; i < v->size-1; i++){
v->data[i] = v->data[i+1];
}
v->size--;
}
int main()
{
// struct DynArr *dictionary = createDynArr(2);
// dyArrayDictionaryPut(dictionary, "key1", 2);
//double result = dyArrayDictionaryGet(dictionary, "key1");
//dyArrayDictionaryContainsKey(struct DynArr *da, KEYTYPE key)
//dyArrayDictionaryRemove(struct DynArr *da, KEYTYPE key)
//printf("%f\n",result);
}

Answer 1

getDynArr is not declared before it is used, the declaration is further down in the file. The compiler should warn you about that.
Since the getDynArr is undeclared, the compiler doesn't know what parameters it takes or what it returns. The compiler then assumes some defaults, like a return type int, which leads to the error you're seeing.
To fix the problem, declare the function before you try to use it.

Answer 2

I'm not going to discuss the implementation as you haven't asked for it.
In order to compile you'll need to fix the following:
Missing function declarations for: getDynArr, dyArrayDictionaryRemove, dyArrayDictionaryContainsKey, addDynArr, removeAtDynArr; So you need to add the function signature just below the struct declarations, like:
struct association
{
KEYTYPE key;
VALUETYPE value;
};
struct DynArr
{
TYPE *data; /* pointer to the data array */
// struct association *data;
int size; /* Number of elements in the array */
int capacity; /* capacity ofthe array */
};
///////////////////dictionary Section
struct association getDynArr(struct DynArr *v, int pos);
void dyArrayDictionaryRemove(struct DynArr *da, KEYTYPE key);
int dyArrayDictionaryContainsKey(struct DynArr *da, KEYTYPE key);
void addDynArr(struct DynArr *v, TYPE val);
void removeAtDynArr(struct DynArr *v, int idx);
...
inside the function dyArrayDictionaryPut you need to call addDynArr passing the struct by value according to the function signature, so the call at line 54 would be:
addDynArr(vec, *ap);
You need to compile it as c99 code, otherwise you need to remove the variable initialization on every for loop (the gcc option is -std=c99 for instance);
Then let me give you a couple of suggestions you may find useful:
You may want to consider using typedef instead of define to create an alias for the struct association;
typedef struct
{
KEYTYPE key;
VALUETYPE value;
} association;
Then at this point you can use "association" as a type without the needs to mention it is a struct anymore (I guess you can find a better name for it as well);
Depending on the performance requirements, you may need to avoid returning or passing the struct by value around, using a pointer is much faster.