Что означает этот код в C qsort?

Где бы вы ни нашли этот код, вы, вероятно, скопировали его неправильно. Я нашел очень похожий код в libutil от Canu:

c.swaptype = ((char *)a - (char *)0) % sizeof(long) || \
  es % sizeof(long) ? 2 : es == sizeof(long)? 0 : 1;

Этот код, вероятно, был незаконно (поскольку условия авторского права нарушены) скопирован из libc FreeBSD:

//__FBSDID("$FreeBSD: src/lib/libc/stdlib/qsort.c,v 1.12 2002/09/10 02:04:49 wollman Exp $");

Итак, я предполагаю, что вы получили его из реализации *BSD libc. Реализация быстрой сортировки Indeedd FreeBSD содержит элемент SWAPINIT макрос (не SWAPINT):

#define SWAPINIT(TYPE, a, es) swaptype_ ## TYPE =       \
        ((char *)a - (char *)0) % sizeof(TYPE) ||       \
        es % sizeof(TYPE) ? 2 : es == sizeof(TYPE) ? 0 : 1;

После синтаксического анализа вы должны обнаружить, что приведенный выше код примерно такой же, как

condition_one   = ((char *)a - (char *)0) % sizeof(long);
condition_two   = es %  sizeof(long);
condition_three = es == sizeof(long);
c.swaptype = (condition_one || condition_two) ? 2 : condition_three ? 0 : 1;

Обратите внимание, что condition_two в качестве условия не совпадает с es % sizeof(long) == 1, а скорее с es % sizeof(long) != 0. Кроме того, ваш перевод был правильным.

Цель этих условий выглядит следующим образом:

• condition_one равно true, когда a не выровнено по long.
• condition_two равно true, когда es не кратно long.
• condition_three равно true, когда es равно long.

Как результат,

• swaptype == 2 - это когда у вас недостаточно гарантий относительно элементов, чтобы умничать при замене,
• swaptype == 1 предназначен для массивов с элементами, выровненными по long границам (примечание: но не обязательно выровненными по longs!), и
• swaptype == 0 предназначен для массивов, соответствующих предыдущему описанию, которые также имеют элементы размера long.

В этом случае происходит явное преобразование типов, поскольку a имеет тип void*, для которого арифметика типов не определена. Однако также обратите внимание, что ((char *)a - (char *)0) тоже не определено:

Когда два указателя вычитаются, оба должны указывать на элементы одного и того же объекта массива или один после последнего элемента объекта массива; результатом является разница индексов двух элементов массива.

(Черновик C11 N1570, раздел 6.5.6. , пункт 9 на стр. 93 и 94.)

Это не совсем точно указано в C11, но нулевой указатель не является частью того же массива, что и объект, на который указывает a, поэтому основные правила арифметики указателей нарушаются, поэтому поведение не определено.

Макросы пытаются переносимо проверить выравнивание на языке C, который на самом деле не позволяет проводить такой тест. Итак, мы вычитаем нулевой указатель из нашего указателя, чтобы получить целое число, а затем берем модуль размером с тип long. Если результат равен нулю, данные выровнены по длине, и мы можем получить доступ как longs. Если это не так, мы можем попробовать какую-то другую схему.

Как отмечено в комментариях, определение макроса, которое вы представляете, не расширяется до действительного кода C, поскольку оно включает вычисление (char*)0 % sizeof(long), где левый операнд % имеет тип char *. Это не целочисленный тип, но оба операнда % должны иметь целочисленный тип.

Кроме того, расширение макроса имеет несбалансированные круглые скобки. Это не является по сути неправильным, но делает этот макрос сложным в использовании. Кроме того, даже там, где приоритет оператора дает разумный результат, использование скобок и дополнительных пробелов может помочь человеку интерпретировать код без ущерба для скорости выполнения и незначительных дополнительных затрат на компиляцию.

Итак, я думаю, что желаемый макрос будет примерно таким:

#define SWAPINT(a,es) swaptype = (                                  \
    ((((char*)a - (char*)0) % sizeof(long)) || (es % sizeof(long))) \
        ? 2                                                         \
        : ((es == sizeof(long)) ? 0 : 1))                           \
)

Вместо этого я бы предпочел написать предпоследнюю строку как

        : (es != sizeof(long))

чтобы уменьшить сложность выражения за счет небольшой потери его понятности. В любом случае намерение состоит в том, чтобы установить swaptype на:

• 2, если a не выровнено по границе n байт, где n — количество байтов в long, или если es не является целым числом, кратным размеру long; в противном случае
• 1, если es не равно размеру long; в противном случае
• 0

Это похоже, но не идентично вашей интерпретации. Обратите внимание, однако, что даже этот код имеет неопределенное поведение из-за (char*)a - (char*)0. Оценка этой разницы определила поведение только в том случае, если оба указателя указывают на один и тот же объект или сразу за его концом, а (char *)0 не указывает (в) на конец какого-либо объекта или сразу за его концом.

Вы спросили конкретно:

Но я не понимаю, зачем реализовано преобразование типов, (char*)a.

Это выполняется, потому что арифметика указателя определяется в терминах типа, на который указывает указатель, поэтому (1) соответствующая программа не может выполнять арифметику с void *, и (2) код хочет, чтобы результат вычитания был в тех же единицах. как результат оператора sizeof (байт).

И что значит эта строка?

(char*)a- (char*)0)% sizeof(long)==1

Эта строка не появляется в макросе, который вы представили, и это не полное выражение из-за несбалансированных скобок. Похоже, он пытается определить, указывает ли a на единицу за границей n байт, где n определено выше, но опять же, оценка разницы указателей имеет неопределенное поведение. Также обратите внимание, что для целого числа x значение x % sizeof(long) == 1, оцениваемое в логическом контексте, имеет другое значение, чем x % sizeof(long), оцениваемое в том же контексте. Последнее имеет больше смысла в контексте, который вы описали.