Портативный способ получить int32_t, переданный в функцию с переменным числом аргументов

#define IS_INT_OR_PROMOTED(X) _Generic((X)0 + (X)0, int: 1, default: 0)

Использование:

int32_t x = IS_INT_OR_PROMOTED(int32_t) ? 
              (int32_t)va_arg(list, int) : 
              va_arg(list, int32_t);

С gcc на моем ПК макрос возвращает 1 для int8_t, int16_t и int32_t и 0 для int64_t.

С gcc-avr (16-битная цель) макрос возвращает 1 для int8_t и int16_t и 0 для int32_t и int64_t.

Для long макрос возвращает 0 независимо от того, является ли sizeof(int)==sizeof(long).

У меня нет целей с 64-битными ints, но я не понимаю, почему это не сработает на такой цели.

Я не уверен, что это будет работать с действительно патологическими реализациями На самом деле я почти уверен, что теперь это будет работать с любой соответствующей реализацией.

На самом деле нет хорошего способа сделать это. Я считаю каноническим ответом «не делай этого». Помимо отказа от передачи таких типов в качестве аргументов функциям с переменным числом переменных, избегайте даже использования их в качестве «переменных» и используйте их только в качестве «хранилища» (в массивах и структурах, которые существуют в больших количествах). Конечно, легко сделать ошибку и передать такой элемент/член в качестве аргумента вашей функции с переменным числом аргументов, так что это не очень приятно.

Ваша идея с _Generic работает только в том случае, если эти типы не определены с специфическими для реализации расширенными целочисленными типами, о которых ваш код не знает.

Существует ужасный, но допустимый подход, включающий передачу va_list в vsnprintf с правильным макросом "PRI*", затем синтаксический анализ целого числа из строки, но после этого список находится в состоянии, когда вы не можете использовать его снова, поэтому, если работает только для последнего аргумента.

Ваш лучший выбор, вероятно, попытаться найти формулу для «продвигается ли этот тип по акциям по умолчанию?» Вы можете легко запросить, превышает ли максимальное значение типа INT_MAX или UINT_MAX, но это все равно не поможет формальной правильности, если есть ложный расширенный целочисленный тип с тем же диапазоном.

Что касается решения #if и <limits.h>, я нашел это (6.2.5.8):

Для любых двух целочисленных типов с одинаковым знаком и разным целочисленным рангом преобразования (см. 6.3.1.1) диапазон значений типа с меньшим целочисленным рангом преобразования является поддиапазоном значений другого типа.

А в 6.3.3.1 говорится (выделено мной):

Каждый целочисленный тип имеет целочисленный ранг преобразования, определяемый следующим образом:

• Никакие два целых типа со знаком не должны иметь одинаковый ранг, даже если они имеют одинаковое представление.
• Ранг целочисленного типа со знаком должен быть выше ранга любого целочисленного типа со знаком с меньшей точностью.
• Ранг long long int должен быть выше ранга long int, который должен быть выше ранга int, который должен быть выше ранга short int, который должен быть выше ранга signed char.
• Ранг любого целочисленного типа без знака должен быть равен рангу соответствующего целочисленного типа со знаком, если таковой имеется.
• Ранг любого стандартного целочисленного типа должен быть выше ранга любого расширенного целочисленного типа той же ширины.
• Ранг char должен быть равен рангу signed char и unsigned char.
• Ранг _Bool должен быть меньше ранга всех других стандартных целочисленных типов.
• Ранг любого перечисляемого типа должен быть равен рангу совместимого целочисленного типа (см. 6.7.2.2).
• Ранг любого расширенного целочисленного типа со знаком относительно другого расширенного целочисленного типа со знаком с той же точностью определяется реализацией, но по-прежнему подчиняется другим правилам определения ранга целочисленного преобразования.
• Для всех целочисленных типов T1, T2 и T3, если T1 имеет больший ранг, чем T2, а T2 имеет больший ранг, чем T3, то T1 имеет больший ранг, чем T3.

И вот что говорит 6.5.2.2 6 (выделено мной):

Если выражение, обозначающее вызываемую функцию, имеет тип, не включающий прототип, целочисленные повышения выполняются для каждого аргумента, а аргументы, имеющие тип float, повышаются до double. Они называются продвижением аргументов по умолчанию. Если количество аргументов не равно количеству параметров, поведение не определено. Если функция определена с типом, включающим прототип, и либо прототип заканчивается многоточием (, ...), либо типы аргументов после повышения несовместимы с типами параметров, поведение не определено. Если функция определена с типом, который не включает прототип, а типы аргументов после повышения несовместимы с типами параметров после повышения, поведение не определено, за исключением следующих случаев:

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

• оба типа являются указателями на квалифицированные или неквалифицированные версии символьного типа или пустоты.

Основываясь на этих наблюдениях, я склонен полагать, что

#if INT32_MAX < INT_MAX
    int32_t x = va_arg(va, int);
#else
    int32_t x = va_arg(va, int32_t);

Это связано с тем, что если диапазон int32_t не может содержать диапазон int, то диапазон int32_t является поддиапазоном int, что означает, что ранг int32_t ниже, чем int, и это означает, что целочисленное продвижение выполняется.

С другой стороны, если диапазон int32_t может содержать диапазон int, то диапазон int32_t является диапазоном int или надмножеством диапазона int, и, таким образом, ранг int32_t равен больше или равно рангу int, что означает, что целочисленное продвижение не выполняется.

ИЗМЕНИТЬ

Поправил тест, судя по комментариям.

#if INT32_MAX <= INT_MAX && INT32_MIN >= INT_MIN
    int32_t x = va_arg(va, int);
#else
    int32_t x = va_arg(va, int32_t);

РЕДАКТИРОВАТЬ 2:

Меня сейчас конкретно интересует этот случай:

• int — 32-битное целое число в дополнении к единице.
• int32_t — 32-битное целое число с дополнением до двух (расширенный тип)
• ширина (такая же, как точность?) такая же
• но потому что «ранг любого стандартного целочисленного типа должен быть больше, чем ранг любого расширенного целочисленного типа с той же шириной». ранг int выше, чем у int32_t
• это означает, что необходимо выполнить целочисленное повышение от int32_t до int
• хотя int не может представлять все значения в int32_t (в частности, не может представлять INT32_MIN). Что происходит? Или я что-то упускаю?