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

Корень проблемы: switch — это "управляемый goto"

Вы почти правильно поняли суть. switch в C++ действительно работает как структурированный goto: он вычисляет выражение в скобках, находит соответствующую метку case и прыгает туда. Но ключевое отличие от if или for в том, что switch не создаёт новую область видимости — все метки находятся в одной и той же области, которая начинается сразу после открывающей скобки { блока switch.

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

switch (op) {
    case '+':
        int result = a + b;  // Ошибка!
        break;
    case '-':
        // ...
        break;
}

Компилятор видит это так: переменная result объявлена в области видимости блока switch. Но если op равно '-', то выполнение прыгает на метку case '-', минуя инициализацию result. Компилятор не может гарантировать, что result будет инициализирован, если мы когда-нибудь попытаемся к нему обратиться из другого case (например, если бы не было break). Это нарушает правило C++: объект с нетривиальной инициализацией не может быть "перепрыгнут" оператором goto или switch.

Технически, если переменная имеет тривиальный тип (например, int) и не инициализируется, то компилятор может это пропустить. Но как только вы добавляете инициализацию (int result = ...), или если тип имеет конструктор, компилятор обязан выдать ошибку, потому что он не может гарантировать, что конструктор будет вызван.

Правильные решения

1. Обернуть case в фигурные скобки (рекомендуемый способ)

Самый простой и читаемый вариант — создать новую область видимости внутри каждого case:

switch (op) {
    case '+': {
        int result = a + b;
        cout << result;
        break;
    }
    case '-': {
        int result = a - b;  // Можно даже с тем же именем!
        cout << result;
        break;
    }
    default: {
        cout << "Unknown operation";
        break;
    }
}

Фигурные скобки создают локальный блок. Теперь result живёт только внутри этого блока, и никакой другой case не может "перепрыгнуть" через его инициализацию. Это безопасно и понятно.

2. Объявить переменную до switch

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

int result = 0;
switch (op) {
    case '+':
        result = a + b;
        break;
    case '-':
        result = a - b;
        break;
}
cout << result;

Минус: переменная "живёт" дольше, чем нужно, и её можно случайно использовать до инициализации.

3. Использовать отдельную функцию

Для сложной логики можно вынести каждый case в функцию:

int handlePlus(int a, int b) {
    int result = a + b;
    cout << result;
    return result;
}

switch (op) {
    case '+': handlePlus(a, b); break;
    case '-': /* ... */ break;
}

Почему в if/for такой проблемы нет?

Потому что if, for, while гарантируют последовательное выполнение. Когда вы пишете:

if (condition) {
    int x = 10; // x гарантированно инициализируется
}

Управление не может "перепрыгнуть" через объявление x — оно либо войдёт в блок, либо нет. А в switch метки case — это просто точки входа в один и тот же блок, и выполнение может начаться с любой из них.

Итог: всегда используйте фигурные скобки внутри case, если объявляете переменные. Это дешево, безопасно и делает код понятнее.

switch (op) {
    case '+':  // Первый case — работает
        int x = 10;
        break;
    case '-':
        // x здесь видна, но не инициализирована!
        break;
}

switch (int result = 0; op) {
    case '+': result = a + b; break;
    case '-': result = a - b; break;
}