qsort结构降序排列

Question

I have a struct that looks like this

typedef struct id_score{
   int id;
   int score;
} pair;

An array of size 50 holds pointers to these pairs

pair* array[50]

My comparator function looks like this

int struct_cmp(const void *a, const void* b) {
    pair* ia = (pair*)a;
    pair* ib = (pair*)b;
    printf("ia's score: %d ib's score: %d??? \n", ia->score, ib->score);
    return ib->score - ia->score;
}

My qsort function here

size_t arr_len = sizeof(array) / sizeof(pair);
qsort(array, arr_len, sizeof(pair), struct_cmp);

Now my problem is that in the struct_cmp function, my printf shows that the values that I think should be the count in each struct in the array are all interpreted as 0 , thus not sorting the array at all. Outside of the function when I print through the array, the struct's have scores that it should have.

Any suggestions?? thank you!

Answer 1

For one

size_t arr_len = sizeof(array) / sizeof(pair);

The above is wrong, as your array contains pair pointers, and not pair s. Doing it a bit more idiomatically and with less repetition would be:

size_t arr_len = sizeof(array) / sizeof(array[0]);

Another thing to note, is that your comparison function converts to the wrong pointer type, so the behavior of your program is undefined.

Remember that the callback function will receive pointers to array elements, so if the array contains pointers, it should convert the arguments to pointers to pointers:

int struct_cmp(const void *a, const void* b) {
    pair* const * ia = (pair* const *)a;
    pair* const * ib = (pair* const *)b;
    printf("ia's score: %d ib's score: %d??? \n", ia->score, ib->score);
    return (*ib)->score - (*ia)->score;
}

Unlike your original function, I also strove to make it const correct. The compare callback accepts by a pointer to const, so the converted pointer should be to const as well (with const being applied to the element type, which is pair* ).

---

As chux pointed out, as a way to avoid overflow in the subtraction, a major improvement will be to return the following instead:

return ((*ib)->score > (*ia)->score) - ((*ib)->score < (*ia)->score);

Which also has the nice property of always returning -1, 0 or 1 instead of arbitrary numbers.