Making a generic mode function in C - c

Question

So I've been trying to make a generic function that calculates the (mathematical) mode of some type.
I've got part of it down but am missing other parts, so it won't compile. I need help on how to fill in those missing parts.
The mode function for integers uses a struct count to determine the element and frequency. Its definition is:
struct count {
int value; // the value of the number
unsigned int freq; // how many times the number has been seen
}
The integer version of mode outputs an array that contains all the ties for the most frequent number along with how many ties there are.
unsigned int mode(int* tiebuf, int* list, size_t listsize)
{
struct count modelist[listsize];
size_t modesize = 0;
// initialize modelist[]
for(int i = 0; i < listsize; i++)
{
int* found = search(list[i], modelist, modesize); // signature: search(key, list, listsize)
if(found == NULL)
{
(modelist[i]).num = &list[i];
(modelist[i]).freq = 0;
modesize++;
}
else
{
(*found).freq++;
}
}
// take the most frequent element (last in modelist)
qsort(modelist, listsize, sizeof(struct count), cmpfreq);
int mode_element = listsize-1;
// see if there are any ties for frequency
size_t tiecount = 1;
for(int i = mode_element-1; i > 0; i--)
{
if((modelist[i]).freq < (modelist[mode_element]).freq)
{
tiecount++; // overshot by 1
break;
}
}
// output the tie as an array
for(int i = 0; i < tiecount; i++)
{
tiebuf[i] = (modelist[mode_element-1-i].number);
}
return tiecount; // returns how many elements are in tiebuf
}
int cmpfreq(const void* obj1, const void* obj2)
{
struct count **t1 = (struct count**)obj1;
struct count **t2 = (struct count**)obj2;
return ( ((*t1)->freq) - ((*t2)->freq) );
}
int cmpnum(const void* obj1, const void* obj2)
{
struct count **t1 = (struct count**)obj1;
struct count **t2 = (struct count**)obj2;
return ( ((*t1)->number) - ((*t2)->number) );
}
int* tiedmode( int* list, size_t listsize, int (*cmp)(const void*, const void*) )
{
// takes the median of all ties in the mode
int ties[listsize];
int tiescount = mode(ties, list, listsize);
qsort(ties, tiescount, cmpnum); // this call doesn't work
// want to call cmpnum with cmp as an argument
// this is why we needed cmpnum
int middle = tiescount/2;
return ties[middle];
}
Now I plan on converting this to a generic notation. The first thing to do is change the definition of
struct count
struct count {
void* object; // some object
unsigned int freq; // how many times that object has appeared
}
The signature for mode must also change to
unsigned int mode(void* tiebuf, size_t tienum, void* list, size_t listsize, size_t objsize, int (*cmp)(const void*, const void*))
The big problem is with the auxiliary function cmpnum and this is where I have trouble. Since qsort requires a function pointer with the signature int (*fnptr)(const void*, const void*), cmpnum also requires that signature. However to compare objects, cmpnum probably also needs another function pointer given by the user on how to compare them. Ideally, the cmpnum function would look like
int cmpnum(const void* obj1, const void* obj2, int (*compare)(const void*, const void*))
{
struct count** t1 = (struct count**)obj1;
struct count** t2 = (struct count**)obj2;
return ( compare(t1->object, t2->object) );
}
So how would I cast a function pointer with 3 arguments to a function pointer with only 2 arguments? Or better yet, how would I solve the problem with the discrepancy between* qsort and cmpnum ?
EDIT: The reason why I need cmpnum in the first place is because of tiedmode. This function takes the mode and outputs the median of the ties. In order to find the median, I have to sort by number. But since this will be made generic, I need the user to let the library know how to sort the object inside struct count.

Answer 1

The comparison function you pass to qsort can only take two arguments.
This is what you do in your top code block.
To do what you want as in your second code block, you'd need to create as many variants of cmpnum as you would have *compare pointers. (e.g. cmpnum_type1, cmpnum_type2, etc.) That's the "clean" way.
Another way [which is slightly messy], is to use your original cmpnum, but have the compare sub-function pointer be a global:
int (*compare) (const void *, const void *);
int
cmpnum(const void *obj1, const void *obj2)
{
struct count **t1 = (struct count **) obj1;
struct count **t2 = (struct count **) obj2;
return (compare(t1->object, t2->object));
}
void
dosort(void)
{
compare = foocmp;
qsort(modelist, listsize, sizeof(struct count), cmpnum);
compare = barcmp;
qsort(modelist, listsize, sizeof(struct count), cmpnum);
}