Функция сравнения Qsort

Ответ 1

Это все еще работает и дает те же результаты. Может ли кто-нибудь объяснить мне, что я удалил, и почему он все еще работает?

Вы вызываете поведение undefined в C. См. C99. 6.3.2.3 Указатели /8:

Указатель на функцию одного типа может быть преобразован в указатель на функцию другого тип и обратно; результат сравнивается с исходным указателем. Если преобразованный указатель используется для вызова функции, тип которой несовместим с указанным типом, поведение undefined.

В С++ эта программа плотно сформирована: http://ideone.com/9zRYSj

Он по-прежнему "работает", потому что функция compare ожидает пару указателей; и на вашей конкретной платформе sizeof(void*) совпадает с sizeof(int*), поэтому вызов указателя функции типа int(void *, void *), который на самом деле содержит указатель на функцию типа int(int *, int *), фактически тот же, что и тип указателя вашей конкретной платформы в этот конкретный момент времени.

Кроме того, действительно ли нужно использовать указатели? Почему я не могу просто сравнить "a" и "b" прямо так (это НЕ работает):

Потому что qsort берет общую функцию сравнения для любых двух типов; а не только int. Таким образом, он не знает, к какому типу, по которому указатель разыменован.

По какой-то причине, с многомерным массивом, я смог уйти с НЕ с помощью указателей, и по какой-то причине он сработает! что происходит!

Это связано с тем, что следующие прототипы одинаковы:

• int foo(int *a, int *b);
• int foo(int a[], int b[])

То есть, массив переходит в указатель при передаче функции. Явное указание длины массива, как вы это делали:

int foo(int a[2], int b[2])

заставляет компилятор делать sizeof и другие биты времени компиляции для обработки элемента как массива из двух элементов; но функция по-прежнему принимает пару указателей, когда она переходит на уровень машины.

В любом из этих случаев передача функции сравнения, которая не принимает пару void *, приводит к поведению undefined. Один из действительных результатов "undefined поведения" - это "похоже, что это работает". Другим допустимым результатом будет "работает по вторникам" или "форматирует жесткий диск". Не полагайтесь на это поведение.

Ответ 2

Я не понимаю, зачем вам все лишние вещи в сравнении, поэтому я упростил это для этого

Используете ли вы const квалификатор для вас. Потому что вы не должны изменять значения в компараторе. Но можно отбросить const и сломать обещание, которое вы приложите к компилятору.

qsort ожидает указатель на функцию, который принимает два const void * в качестве параметров, поэтому передаются указатели для функции компаратора:

   void qsort(void *base, size_t nmemb, size_t size,
                  int(*compar)(const void *, const void *));

Таким образом, передача a и b приведет к интерпретации значений в качестве указателей, что очевидно неверно.

Он работает без указания указателей на многомерные массивы, потому что, когда вы передаете массивы, они распадаются на указатели. Итак, следующий компаратор у вас в порядке.

int compare (int a[2], int b[2])
{
    return a[1] - b[1];
}

Ответ 3

Ответ очень прост: из руководства qsort http://pubs.opengroup.org/onlinepubs/009695399/functions/qsort.html прототип указателя функции:

int comp(const void *a, const void *b)

Типед, связанный с этим прототипом, может быть объявлен таким образом

typedef int (*comp_qsort_funct_t) ( const void *, const void * )

Где comp_qsort_funct_t - тип указателя функции

Прототипом функции сравнения qsort является использование переменной const, поскольку это хорошая практика/дизайн, поскольку данные не будут изменены.

Использование другого прототипа может привести к неожиданному результату в зависимости от компилятора/платформы. Или просто не скомпилировать, пример приведен в комментарии: http://ideone.com/9zRYSj

Поэтому вы не должны использовать другой прототип.

Ответ 4

Я хотел бы подтвердить наблюдения Длинета, который задал первоначальный вопрос.

Компилятор C действительно примет все формы функции сравнения, даже без const, и даже используя int * вместо void *. Однако мой компилятор С++ отклоняет варианты и принимает форму const void *.

Компилятор C даже принимает форму int, не используя указатели. Я проверил и обнаружил, что int form функции сравнения принимает значения указателя, а не ints массива. И результат состоит в том, что массив не отсортирован, а остается в том же порядке. И я думаю, что все это то, что вы ожидаете.

Таким образом, кажется, что вы можете использовать int * вместо void * в определении функции, а затем не нужно вводить внутри функции.

Является ли это хорошая практика программирования является спорным, с некоторыми программисты говорят да, некоторые говорят нет. Кажется мне, хорошее программирование или нет, сокращение беспорядка было бы точкой в ​​пользу использования int * вместо void *. Но тогда компилятор С++ не позволяет вам это делать.