Switch case: метка case не сводится к целочисленной константе

Хотя выражение ((struct my_struct) { 4 }).my_int действительно оценивается во время выполнения как 4, оно не является константой. Switch-case нуждается в постоянном выражении.

Я вижу, что вы объявили my_int как const. Но это означает только то, что его нельзя изменить позже. Это не означает, что выражение ((struct my_struct) { 4 }).my_int постоянно.

Если вы используете if-statement вместо switch-case, все будет в порядке.

if (((struct my_struct) { 4 }).my_int == 4) {
    printf("Hey there!\n");
}

Метка case в операторе switch требует целочисленное константное выражение, который определяется как:

An integer constant expression shall have integer type and shall only have operands that are integer constants, enumeration constants, character constants, sizeof expressions whose results are integer constants, _Alignof expressions, and floating constants that are the immediate operands of casts. Cast operators in an integer constant expression shall only convert arithmetic types to integer types, except as part of an operand to the sizeof or _Alignof operator.

Выражение ((struct my_struct) { 4 }).my_int не квалифицируется как целочисленное константное выражение по этому определению, даже если это целочисленное выражение, значение которого может быть определено во время компиляции.

Это наименьший общий знаменатель.

Стандарт C говорит, что ((struct my_struct) { 4 }).my_int не удовлетворяет ограничениям, наложенным на метки case (а именно, что они являются целочисленными константными выражениями), поэтому совместимые компиляторы C не обязаны быть достаточно умными, чтобы иметь возможность оптимизировать его.

Стандарт не запрещает компилятору запретить оптимизировать его. Действительно, оптимизация — это то, что делает clang.

Ваша программа:

#include <stdio.h>
struct my_struct {
    const int my_int;
};

int main()
{
    switch (4) {

        case ((struct my_struct) { 4 }).my_int:

            printf("Hey there!\n");
            break;

    }
}

просто работает на clang, хотя вы получите предупреждение, если скомпилируете его с помощью -pedantic.

В других случаях, например, при различении VLA и обычных массивов, различие между целочисленными константными выражениями и другими целочисленными выражениями также влияет на другие конструкции, такие как переходы на основе switch или goto, которые становятся запрещенными, если они переходят в область действия VLA. Опять же, компилятор может свернуть его и разрешить такие переходы, если сделана хотя бы одна диагностика (clang предупреждает о свертывании, а не о переходе).

Если вы используете эти конструкции и ваш компилятор вас не остановит, ваша программа не будет переносимой.

Наконец, константность целых чисел во время компиляции также может влиять на типы в определенном случае.

Ядро Linux, как мне кажется, использует что-то похожее на

#define IS_CEXPR(X) _Generic((1? (void *) ((!!(X))*0ll) : (int *) 0), int*: 1, void*: 0)

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

Это основано на стандартном правиле C, согласно которому целочисленное константное выражение, равное 0, приведенное к (void*), является константой нулевого указателя, тогда как регулярное целочисленное выражение, приведенное к (void*), является просто пустым указателем, даже если значение выражения известно. быть равным 0. Затем правила определения типа тернара различают выражения (void*) и константу нулевого указателя, в результате чего (1? (void *) ((!!(X))*0ll) : (int *) 0) типизируется int *, если X является целочисленным константным выражением, и void * в противном случае.

Большинство компиляторов, вероятно, не позволят вам так легко обойти нарушения системы типов (особенно внутри _Generic).

Что касается вопроса Зачем, стандарт C не позволяет компилятору принимать

case ((struct my_struct) { 4 }).my_int:

... мы не можем ответить на этот вопрос с уверенностью, потому что здесь никого нет в комитете C (насколько я знаю, во всяком случае), и это дизайнерское решение было принято где-то 30 лет назад, так что есть неплохая вероятность, что никто из тех, кто там был помнит обоснование.

Но мы можем сказать следующее:

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

   Функция, о которой вы просите, примерно так же сложна для реализации, как

   static const int CONSTANT = 123;
   ...
   switch (x) { case CONSTANT: ... }
   

   который также не требуется для работы в C (хотя он есть в C++).

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

Это лучший ответ, который я могу вам дать.

Хорошо. Почему это невозможно, кажется, было подробно объяснено... ...Тогда я просто оставлю это здесь.

case ((int)((struct my_struct) { 4 }).my_int):

лязг 9, архлинукс, x86_64