qsort: Прехвърляне на самата функция за сравнение или на параметрите в тялото на функцията за сравнение?

Трябва да избягвате последния случай, защото не е валиден.

За да бъдат съвместими два типа функции, връщаните типове трябва да са съвместими и съответните типове параметри трябва да са съвместими. const void * не е съвместим с const double *, следователно типовете функции не са съвместими. Извикването на функция чрез несъвместим тип указател води до недефинирано поведение.

Имайте предвид, че това, че два типа могат да бъдат косвено преобразувани, не означава, че са съвместими. Като вземем примера с const double * и const void *, преобразуването между двата типа може да се извърши без преобразуване, но не е необходимо представянето на двата типа да е едно и също.

Това означава, че начинът, по който const double * се предава на функция, може да е различен от начина, по който const void * се предава на функция. Така че чрез извикване на функция от тип int (*)(const double*, const double*), сякаш има тип int (*)(const void*, const void*), параметрите могат да бъдат предадени по неправилен начин.

Докато x64 и ARM системите обикновено ще използват едно и също представяне за всички типове указатели, може да се измъкнете с първото, но все още няма гаранция за това. Съвременните компилатори често приемат, че недефинирано поведение няма да се случи и извършват оптимизации въз основа на този факт.

Първият случай е правилният метод, тъй като сигнатурата на функцията е съвместима с това, което функцията qsort очаква.

Като допълнение, има друга стратегия за извикване на qsort: създайте междинна qsort необходима прототипна функция, която извиква функция за сравнение с разрешен тип.

#include <stdlib.h>
#include <stdio.h>

static int double_cmp(const double *d1, const double *d2)
    { return (*d1 > *d2) - (*d2 > *d1); }

static int double_void_cmp(const void *v1, const void *v2)
    { return double_cmp(v1, v2); }

int main(void) {
    double p[] = { 2.18, 6.28, 3.14, 1.20, 2.72, 0.58, 4.67, 0.0, 1, 1.68 };
    const size_t n = sizeof p / sizeof *p;
    size_t i;
    qsort(p, n, sizeof *p, &double_void_cmp);
    for(i = 0; i < n; i++) printf("%s%.2f", i ? ", " : "", p[i]);
    fputs(".\n", stdout);
    return EXIT_SUCCESS;
}

Въпреки че това има своите проблеми, човек може да използва double_cmp като сравнение за други неща, които не са qsort. Освен това не изисква никакви кастинги или изрични присвоявания, според моето тълкуване на ISO 9899 6.3.2.3,

Указател към void може да бъде преобразуван във или от указател към всеки непълен или тип обект. . . и обратно.

В допълнение към отличния отговор на dbush, трябва да се отбележи, че случаят на алтернативна функция за сравнение с прототип на int cmp(const char *s1, const char *s2), като strcmp, не е толкова ясен като този във въпроса. Стандартът C уточнява, че:

6.2.5 Типове

[...] Указател към void трябва да има същите изисквания за представяне и подравняване като указател към символен тип. По същия начин указателите към квалифицирани или неквалифицирани версии на съвместими типове трябва да имат еднакви изисквания за представяне и подравняване. Всички указатели към структурни типове трябва да имат еднакви изисквания за представяне и подравняване един към друг. Всички указатели към типове обединения трябва да имат еднакви изисквания за представяне и подравняване един към друг. Не е необходимо указателите към други типове да имат същите изисквания за представяне или подравняване.

Така че указателите към функции с прототипи int cmp(const void *v1, const void *v2) и int cmp(const char *v1, const char *v2) са несъвместими, но е малко вероятно последователността на извикване да е различна дори при тези изключително редки цели, където int cmp(const double *v1, const double *v2) би било проблематично (ранни Cray системи и процесори без байтова адресируемост) .

Вие не предоставяте кода за функциите за сравнение: често срещана грешка е просто да се върне разликата в стойностите (*d1 - *d2). Това не работи за стойности с плаваща запетая, нито пък за стойности int, тъй като изваждането може да препълни.

Ето една реализация за нарастващ ред, която работи за всички типове числа:

int cmp(const void *v1, const void *v2) {
    const int *p1 = v1, *p2 = v2;
    return (*p1 > *p2) - (*p1 < *p2);
}

За типове с плаваща запетая може да е необходима специална обработка на NaN стойности:

// sort by increasing values, with NaN after numbers
int cmp(const void *v1, const void *v2) {
    const double *p1 = v1, *p2 = v2;
    if (isnan(*p1)) {
        return isnan(*p2) ? 0 : 1;
    } else
    if (isnan(*p2)) {
        return -1;
    } else {
        return (*p1 > *p2) - (*p1 < *p2);
    }
}