Почему в C++ switch-case нельзя объявлять переменные без фигурных скобок?

Причина ограничения: область видимости и переходы меток

Проблема, с которой вы столкнулись, связана с тем, как C++ обрабатывает switch. В отличие от языков с более простой семантикой, switch в C++ — это не структурированный блок с изолированными case-ветками, а таблица переходов (jump table). Метки case и default — это просто точки входа в единый блок кода. Управление может "провалиться" (fall-through) из одной метки в другую, если не поставить break.

Когда вы пишете:

case 1:
    int x = 10;

компилятор видит это как объявление переменной в середине блока, но с возможностью "перепрыгнуть" через её инициализацию. Если управление попадёт в case 2 напрямую (минуя case 1), то переменная x окажется в области видимости, но не будет инициализирована. Это нарушает правило C++: нельзя переходить через инициализацию переменной с нетривиальным конструктором или даже простой инициализацией, так как это может привести к использованию неинициализированной памяти.

Для простых типов (int, float) это тоже запрещено, потому что компилятор не может гарантировать, что переменная будет инициализирована до первого использования — ведь case 2 может быть выполнен без прохода через case 1.

Решение: фигурные скобки для каждого case

Самый простой и рекомендуемый способ — создать искусственную область видимости с помощью фигурных скобок { } внутри каждого case. Это изолирует переменные и решает проблему:

switch (value) {
    case 1: {
        int x = 10;
        std::cout << "Case 1: " << x << std::endl;
        break;
    }
    case 2: {
        int y = 20;
        std::cout << "Case 2: " << y << std::endl;
        break;
    }
    default: {
        std::cout << "Default" << std::endl;
        break;
    }
}

Теперь каждая переменная живёт только внутри своего блока { }. Даже если управление "провалится" (например, вы уберёте break), компилятор не даст обратиться к x из case 2, так как он вне области видимости. Это также улучшает читаемость и предотвращает случайное использование переменной из другого case.

Почему нельзя просто объявить до switch?

Если переменная нужна только в одном case, вынос её объявления перед switch — плохая практика:

• Загрязняет область видимости (переменная доступна во всех case).
• Увеличивает риск ошибок (например, случайное использование неинициализированной переменной).
• Снижает читаемость (переменная объявлена далеко от места использования).

Специальный случай: инициализация перед case

Если вам нужно объявить переменную, которая будет использоваться в нескольких case (например, для общего результата), можно объявить её перед switch, но инициализировать внутри case:

int result;
switch (value) {
    case 1:
        result = 10;
        break;
    case 2:
        result = 20;
        break;
    default:
        result = -1;
}
std::cout << result;

Но это работает только для простых типов. Для объектов с конструкторами лучше использовать std::optional или вынести логику в отдельную функцию.

Итог

Ограничение существует для защиты от неопределённого поведения. Используйте фигурные скобки внутри case — это стандартная идиома C++, которая делает код безопасным и понятным. Компиляторы (GCC, Clang, MSVC) все поддерживают это с C++98.

// Хороший стиль:
switch (cmd) {
    case 'a': {
        std::string name = "Alice";
        process(name);
        break;
    }
    case 'b': {
        std::string name = "Bob";
        process(name);
        break;
    }
}

void handleCase1() {
    int x = 10;
    std::cout << "Case 1: " << x;
}

void handleCase2() {
    int y = 20;
    std::cout << "Case 2: " << y;
}

int main() {
    int value = 2;
    switch (value) {
        case 1: handleCase1(); break;
        case 2: handleCase2(); break;
        default: std::cout << "Default";
    }
}

switch (value) {
    case 1: {
        auto action = []() {
            int x = 10;
            std::cout << x;
        };
        action();
        break;
    }
}