qsort() doesn't sort data from structure - c

Question

I've got a structure:
typedef struct personalData
{
char name[20];
char * remarks;
int age;
float weight;
} personalData;
I need to sort data by weight using qsort(). Here's my weightSort function:
void weightSort(personalData * data[], int len)
{
qsort(data, len, sizeof(struct personalData *), structSortWeight);
}
where len = 10(calculated before using some different functions, but it probably doesn't matter), data[] is defined in main():
struct personalData * data[10];
and finally structSortWeight:
int structSortWeight(const void *a, const void *b)
{
personalData *p1 = (personalData *)a;
personalData *p2 = (personalData *)b;
return (p1->weight - p2->weight);
}
My program crashes when it starts sorting. I want to add that when I change the third argument in qsort() to sizeof(float) it doesn't crash but p1->weight and p2->weight point to some rubbish.
The calling function in main():
weightSort(data, len);
personalData * data[] has some data already assigned.

Answer 1

This array declaration:
struct personalData * data[10];
does not declare an object suitable for use as the first parameter to
void weightSort(personalData data[], int len)
The variable and function parameter have different levels of indirection. Your actual data is an array of pointers to struct personalData, whereas the function parameter is appropriate for an array of the structures themselves. This produces undefined behavior. Probably more functionally relevant, the item size that you pass to qsort() is therefore incorrect: with the data as declared in main(), you want as item size not the size of struct personalData, but rather the size of a pointer to one (sizeof(struct personalData *)).
Furthermore, your comparison function is wrong. In the first place, it must return an int, not a float, but in the second place, since the elements you are sorting are pointers to structures, the arguments presented to the comparison function will be pointers to such pointers. You treat them instead as pointers directly to structures.

Answer 2

Your comparison function receives pointers to two elements of the list, each of which is also a pointer. So the real type of each parameter is personalData **, but you cast them to personalData *. So you're treating a pointer as a structure instance, which is why you're seeing garbage.
You need to add an additional level of indirection in your comparison function:
int structSortWeight(const void *a, const void *b)
{
// no need to cast from void *
const personalData **p1 = a;
const personalData **p2 = b;
return ((*p1)->weight - (*p2)->weight);
}

Answer 3

The signature for the qsort comparison function is
int (*comp)(const void *, const void *)
Returning a float does not work at all.

Answer 4

return (p1->weight - p2->weight); is not a suitable compare. This subtracts 2 float values and converts to int. The compare function must return the sensible consistent results.
Consider weights A,B,C: 1.1, 2.0, 2.9.
Comparing f(A,B) returns int 0.
Comparing f(B,C) returns int 0.
Comparing f(A,C) returns int 1. // This does not make sense if A==B and B==C
This inconsistency can fool qsort() resulting in undefined behavior (UB).
A better compare function
int structSortWeight2(const void *a, const void *b) {
const personalData **p1 = (const personalData **)a;
const personalData **p2 = (const personalData **)b;
// 2 compares are done, each returning an `int`
return ((*p1)->weight > (*p2)->weight) - ((*p1)->weight < (*p2)->weight);
}
Code has other issues as detailed in #John Bollinger