Слияние типов в Си

[vak]

Согласно грамматике, в Си можно писать: signed short int. Причём в любом порядке. А можно char char char char char. Первое правильно, второе неправильно. Можно писать long long но нельзя shоrt short. Можно long double но нельзя short float. Существуют определённые правила, по которым длинная последовательность элементарных спецификаторов типа сливается в один правильный тип. Или отвергается как неверная. Вот таблица совместимости типов. Я убрал отсюда _Atomic, с ним совсем сложно и лучше рассматривать отдельно. 

            void char short int long float double signed unsigned _Bool _Complex _Imaginary struct union enum MyType
--------------------------------------------------------------------------------------------------------------------
void        ✗    ✗    ✗     ✗   ✗    ✗     ✗      ✗      ✗        ✗     ✗        ✗          ✗      ✗     ✗    ✗
char        ✗    ✗    ✗     ✗   ✗    ✗     ✗      ✓      ✓        ✗     ✗        ✗          ✗      ✗     ✗    ✗
short       ✗    ✗    ✗     ✓   ✗    ✗     ✗      ✓      ✓        ✗     ✗        ✗          ✗      ✗     ✗    ✗
int         ✗    ✗    ✓     ✗   ✓    ✗     ✗      ✓      ✓        ✗     ✗        ✗          ✗      ✗     ✗    ✗
long        ✗    ✗    ✗     ✓   ✓    ✗     ✓      ✓      ✓        ✗     ✗        ✗          ✗      ✗     ✗    ✗
float       ✗    ✗    ✗     ✗   ✗    ✗     ✗      ✗      ✗        ✗     ✓        ✓          ✗      ✗     ✗    ✗
double      ✗    ✗    ✗     ✗   ✓    ✗     ✗      ✗      ✗        ✗     ✓        ✓          ✗      ✗     ✗    ✗
signed      ✗    ✓    ✓     ✓   ✓    ✗     ✗      ✗      ✗        ✗     ✗        ✗          ✗      ✗     ✗    ✗
unsigned    ✗    ✓    ✓     ✓   ✓    ✗     ✗      ✗      ✗        ✗     ✗        ✗          ✗      ✗     ✗    ✗
_Bool       ✗    ✗    ✗     ✗   ✗    ✗     ✗      ✗      ✗        ✗     ✗        ✗          ✗      ✗     ✗    ✗
_Complex    ✗    ✗    ✗     ✗   ✗    ✓     ✓      ✗      ✗        ✗     ✗        ✗          ✗      ✗     ✗    ✗
_Imaginary  ✗    ✗    ✗     ✗   ✗    ✓     ✓      ✗      ✗        ✗     ✗        ✗          ✗      ✗     ✗    ✗
struct      ✗    ✗    ✗     ✗   ✗    ✗     ✗      ✗      ✗        ✗     ✗        ✗          ✗      ✗     ✗    ✗
union       ✗    ✗    ✗     ✗   ✗    ✗     ✗      ✗      ✗        ✗     ✗        ✗          ✗      ✗     ✗    ✗
enum        ✗    ✗    ✗     ✗   ✗    ✗     ✗      ✗      ✗        ✗     ✗        ✗          ✗      ✗     ✗    ✗
MyType      ✗    ✗    ✗     ✗   ✗    ✗     ✗      ✗      ✗        ✗     ✗        ✗          ✗      ✗     ✗    ✗

Заметки о конкретных комбинациях:

void

• Несовместимо со всеми другими спецификаторами, так как `void` является отдельным типом.
• Пример: `void int` недопустимо.

char, short, int, long

• Совместимо с `signed`, `unsigned` (например, `unsigned char`, `signed long`).
• `short` и `int` объединяются как `short int`.
• `long` и `int` объединяются как `long int`.
• `long` может объединяться с `double` (`long double`) и самим собой (`long long`).
• Несовместимо с `float`, `double`, `_Complex`, `_Imaginary`, `struct`, `union`, `enum`, `MyType`.

float, double

• Совместимо с `_Complex`, `_Imaginary` (например, `float _Complex`, `double _Imaginary`).
• `double` с `long` образует `long double`.
• Несовместимо с `signed`, `unsigned`, целочисленными типами, `struct`, `union`, `enum`, `MyType`.

signed, unsigned

• Применяется к `char`, `short`, `int`, `long` (например, `unsigned short`).
• `signed` подразумевается для `int`, если он один.
• Несовместимо с `float`, `double`, `_Bool`, `_Complex`, `_Imaginary`, `struct`, `union`, `enum`, `MyType`.

_Bool

• Несовместимо со всеми другими спецификаторами.

_Complex, _Imaginary

• Сочетается с `float`, `double` (например, `float _Complex`).
• Несовместимо с целочисленными типами, `_Bool`, `struct`, `union`, `enum`, `MyType`.

struct, union, enum

• Несовместимо с базовыми типами, `signed`, `unsigned`, `_Complex`, `_Imaginary`, `MyType`.

MyType (typedef)

• Представляет определенный пользователем тип (например, `typedef int MyType`).
• Несовместимо с другими спецификаторами, так как это полный тип.
• Совместимость зависит от базового типа (например, если `MyType` - это `int`, он ведет себя как `int`).

Самосочетания

• Большинство спецификаторов не могут сочетаться друг с другом (например, `int int` недопустимо).
• `long` является исключением: `long long` допустимо.
• `struct`, `union`, `enum`, `MyType` не могут повторяться.

Comments

[lxe]

Моё любимое просто unsigned

[vak]

Хорошо было в языке Би: нет типов - нет проблем.

[chaource]

Это чудовищно. Забыть немедленно и никогда больше не вспоминать.

[vak]

Куда от Си денешься. Писать на нём регулярно приходится.

[chaource]

Почему приходится? (А тѣмъ болѣе, зачѣмъ языкъ Би для БЭСМ-6?)

Я бы на Хаскелѣ писалъ вмѣсто C. Вотъ сейчасъ я думаю начать новый хобби-проектъ. Выборъ языка, на мой взглядъ, однозначенъ - или Скала или Хаскель или оба вмѣстѣ параллельно. Даже въ голову не пришло бы дѣлать что-то на С. Это же 50 лѣтъ уже прошло, а тамъ до сихъ поръ header files, и #include header files просто текстуально вставляется...

_Bool несовместимо ...

[h1uke]

... со здравым смыслом.
Потому как стандарт не определяет для данных этого типа ни размер ни правила выравнивания.

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

[vak]

Оно ж так не случайно вышло. Си сделан, чтобы позволять максимально эффективную реализацию на любом хардвере. У каждого хардвера имеются свои особые изыски для представления _Bool. Между разными хардверами оно отличается. Настолько отличается, что не находится ничего общего. Нечего записать в Си стандарт. Поэтому написали: делайте как хотите, бог с вами. 😀

[juan_gandhi]

Век живи, век учись. (Когда-то на это всё глядел "интуитивно".)

[vak]

Оно и складывалось интуитивно, по мере написания всё больше количества кода. Поэтому элегантность и симметрия местами отсутствуют. 😀

[straktor]

short / long / signed / unsigned изначально это не типы, а модификаторы типа int, который был дефолтом
заметьте, что они все прилагательные

то есть можно, собирая определение типа по токенам
- short / long класть в модификаторы, остальное в типы
- сочетание модификаторов short short запрещено, long long разрешено, long short запрещено, 3 модификатора ошибка
в конце
- если тип не указан, то примитивный тип = инт
- модификатор long можно ещё применить к double, если что иное -- ошибка

ни у вас, ни у меня неясно, имеют ли смысл long char / short char -- может типа wchar_t?

[vak]

Это всё верно. Как Ритчи с Томпсоном придумали, так и повелось. Потом уже особо не изменишь. 😀
Float, double, _Complex и _Imaginary тоже прилагательные, но плохо прилагаются. 😀
_Complex int не напишешь. Хотя математически почему бы и нет.

На мой взгляд логично было бы сделать long char вместо wchar_t. Не знаю почему так решили.

[spamsink]

Несовместимо с другими спецификаторами, так как это полный тип.
Совместимость зависит от базового типа (например, если `MyType` - это `int`, он ведет себя как `int`).

Когда в ИИшнице согласья нет, на лад её дело не пойдёт.

[vak]

Тут неестественный разум очевидно запутался в разных смыслах термина совместимость.
Арифметическая совместимость - да, определяется базовым типом.
Но к синтаксической совместимости базовый тип не имеет отношения.