Оператор выбора switch является очень удобной заменой множественного использования . Оператор switch сравнивает значение одной переменной с несколькими константами. Основной формат для использования оператора множественного выбора switch case показан — ниже. Значение переменной указанной в условии switch сравнивается со значениями, которые следуют за ключевым словом case . Когда значение в переменной, соответствует значению в строке с оператором case , компьютер продолжит выполнение программы с этого места.
Switch (/*variable*/) { case const1: /*Тут находится код, который необходимо выполнить, если переменная variable будет равна const1*/ break; case const2: /*этот код выполнится, если variable будет равна const2*/ break; /*...*/ default: /*Код, который выполнится, если ниодно из константых значению не соответствует значение в переменной variable*/ break; }
Когда сравниваемое значение в переменной variable совпадет с первым значением оператора case , программа начнет выполнять код, который находится между текущим оператором case и . Оператор break используется для того, чтобы прерывать ход программы в операторе switch и передавать управление следующему оператору, после switch . Если не использовать оператор break , то, сразу после того, как выполнится один блок кода, программа переключится на выполнения следующего case , даже, если константное значение не будет равно значению в переменной variable . Поэтому, в операторе выбора switch , блоки кода после case всегда должны предваряться оператором break .
Также стоит обратить в нимание на ключевое слово default , оно не является обязательным, но в то же время оно необходимо для обработки неожидынных ситуаций. Например, когда значение переменной не совпадает ни с одним из значений case , в таком случае выполнится код, который находится в ветке default . Это может быть полезно, в случае, если мы не ожидаем, что ниодно из значений case не совпало со значением переменной в условии switch . В таком случае, мы увидем, что сработал код в ветке default .
Чтобы, все ранее сказанное понять и запомнить, давайте перейдем к рассмотрению простой программы с использованием оператора выбора switch . Хотя, возможно этот пример не самый удачный, но в нем наглядно показывается весь функционал оператора switch .
#include
Итак, как же работает этот код? Для начала, мы сделали небольшое меню (строки5 — 10 ), чтобы как-то информировать пользователя, что необходимо водить в программу. Как вы уже поняли, необходимо ввести число — 1, 2, 3 или 4. В зависимости от введенного числа, программа будет срабатывать поразному. В данном примере очень хорошо видно, что вводимое значение сохраняется в переменную input , и после этого, значение в этой переменной передается в оператор switch , строка 13 .В строках 13 — 29 объявлен оператор множественного выбора switch . Какже он работает? Очень просто, по порядку программа сравнивает переменную input со значениями 1, 2, 3 и 4 . Например, если мы ввели число 3, топрограмма выполнит код, который находится в строках 21-22 , при вводе единицы, программа напечатает сообщение из строки 15.Думаю суть вы уловили. Ну, а, если мы ввели другое число, отличное от заданных, выполнится блок кода в строке 27 . Смотрим результат работы программы. Я ввел значение — 3, сегодня буду смотреть — Ходячих!
Что бы сегодня посмотреть? 1. Стрела(Arrow) 2. Сверхъестественное(Supernatural) 3. Ходячие мертвецы(Walking Dead) 4. Выход Ваш выбор: 3 «Fight the dead. Fear the living»
Вы можете поместить данное меню и ввод значени пользователя в цикл, тогда сможете в цикле делать выбор столько раз, сколько сами захотите. Надеюсь, что описал весь процесс достаточно понятно, тема не сложная, но для закрепления материала, поэксперементируйте с этим кодом. Удачи!
switch (выражение) { [объявление] : [ case константное-выражение1]: [ список-операторов1] [ case константное-выражение2]: [ список-операторов2] : : [ default: [ список операторов ]] }
Выражение, следующее за ключевым словом switch в круглых скобках, может быть любым выражением, допустимыми в языке СИ, значение которого должно быть целым. Отметим, что можно использовать явное приведение к целому типу, однако необходимо помнить о тех ограничениях и рекомендациях, о которых говорилось выше.
Значение этого выражения является ключевым для выбора из нескольких вариантов. Тело оператора smitch состоит из нескольких операторов, помеченных ключевым словом case с последующим константным-выражением. Следует отметить, что использование целого константного выражения является существенным недостатком, присущим рассмотренному оператору.
Так как константное выражение вычисляется во время трансляции, оно не может содержать переменные или вызовы функций. Обычно в качестве константного выражения используются целые или символьные константы.
Все константные выражения в операторе switch должны быть уникальны. Кроме операторов, помеченных ключевым словом case, может быть, но обязательно один, фрагмент помеченный ключевым словом default .
Список операторов может быть пустым, либо содержать один или более операторов. Причем в операторе switch не требуется заключать последовательность операторов в фигурные скобки.
Отметим также, что в операторе switch можно использовать свои локальные переменные, объявления которых находятся перед первым ключевым словом case, однако в объявлениях не должна использоваться инициализация.
Схема выполнения оператора switch следующая:
- вычисляется выражение в круглых скобках;
- вычисленные значения последовательно сравниваются с константными выражениями, следующими за ключевыми словами case;
- если одно из константных выражений совпадает со значением выражения, то управление передается на оператор, помеченный соответствующим ключевым словом case;
— если ни одно из константных выражений не равно выражению, то управление передается на оператор, помеченный ключевым словом default , а в случае его отсутствия управление передается на следующий после switch оператор.
Отметим интересную особенность использования оператора switch: конструкция со словом default может быть не последней в теле оператора switch . Ключевые слова case и default в теле оператора switch существенны только при начальной проверке, когда определяется начальная точка выполнения тела оператора switch . Все операторы, между начальным оператором и концом тела, выполняются вне зависимости от ключевых слов, если только какой-то из операторов не передаст управления из тела оператора switch . Таким образом, программист должен сам позаботится о выходе из case , если это необходимо. Чаще всего для этого используется оператор break .
Для того, чтобы выполнить одни и те же действия для различных значений выражения, можно пометить один и тот же оператор несколькими ключевыми словами case .
Пример:
| 1 2 3 4 5 6 7 8 9 | int i= 2 ; switch (i) { case 1 : i += 2 ; case 2 : i *= 3 ; case 0 : i /= 2 ; case 4 : i -= 5 ; default : ; } |
int i=2; switch (i) { case 1: i += 2; case 2: i *= 3; case 0: i /= 2; case 4: i -= 5; default: ; }
Выполнение оператора switch начинается с оператора, помеченного case 2 . Таким образом, переменная i получает значение, равное 6, далее выполняется оператор, помеченный ключевым словом case 0 , а затем case 4, переменная i примет значение 3, а затем значение -2. Оператор, помеченный ключевым словом default, не изменяет значения переменной.
Рассмотрим ранее приведенный пример, в котором иллюстрировалось использование вложенных операторов if, переписанной теперь с использованием оператора switch .
| 1 2 3 4 5 6 7 8 9 10 | char ZNAC; int x, y, z; switch (ZNAC) { case "+" : x = y + z; break ; case "-" : x = y - z; break ; case "*" : x = y * z; break ; case "/" : x = u / z; break ; default : ; } |
char ZNAC; int x,y,z; switch (ZNAC) { case "+": x = y + z; break; case "-": x = y - z; break; case "*": x = y * z; break; case "/": x = u / z; break; default: ; }
Использование оператора break позволяет в необходимый момент прервать последовательность выполняемых операторов в теле оператора switch, путем передачи управления оператору, следующему за switch .
Отметим, что в теле оператора switch можно использовать вложенные операторы switch , при этом в ключевых словах case можно использовать одинаковые константные выражения. case 2 : f-= 9 ; break ; } case 3 : b-= c; break ; : }
: switch (a) { case 1: b=c; break; case 2: switch (d) { case 0: f=s; break; case 1: f=9; break; case 2: f-=9; break; } case 3: b-=c; break; : }
1.4.6. Оператор break
Оператор break обеспечивает прекращение выполнения самого внутреннего из объединяющих его операторов switch, do, for, while
. После выполнения оператора break управление передается оператору, следующему за прерванным.
Сегодня мы научимся пользоваться этой полезной конструкцией языка c++.
Очень часто в процессе написания программы требуется писать длинные if-else конструкции, например, когда мы получаем какой-либо ключ от пользователя; если вы пишете игру, то придется проверять на какую кнопку нажал игрок (вправо, влево, пробел и т.д.).
В этой статье мы узнаем как удобно оформлять подобные конструкции с помощью switch case , а так же узнаем немного о enum типах, которые хорошо подходят для работы со switch case.
Конструкция switch-case — это удобная замена длинной if-else конструкции, которая сравнивает переменную с несколькими константными значениями, например int или char.
Синтаксис
switch (<переменная>) { case значение1: Выполнить если <переменная> == значение1 break; case значение2: Выполнить если <переменная> == значение2 break; ... default: выполнить, если ни один вариант не подошел break; }Переменная в скобках сравнивается со значениями, описанными после ключевого слова case. После двоеточия находится код, который будет выполнен в случае если переменная оказалась равной текущему значению. break необходим для того, чтобы прервать выполнение switch. Рассмотрим пример, где нет break:
Int a=1;
switch(a)
{
case 1:
a++;
case 2:
a++;
case 3:
a++;
}
cout<<"a= "< Данная программа выведет a = 4. Значения для сравнения, описанные после case могут быть только константами, поэтому следующий вариант использования switch-case — неверен: Int a = 10;
int b = 10;
int c = 20;
switch (a) {
case b:
// Code
break;
case c:
// Code
break;
default:
// Code
break;
}
При попытке скомпилировать данную программу, вы получите подобное сообщение: Test.cpp:9: error: "b" cannot appear in a constant-expression
Блок default — необязателен, но он полезен для обработки исключительных ситуации. Следующая программа демонстрирует один из возможных вариантов использования switch-case:
#include Эта программа показывает простой способ обработки вводимых пользователем данных. Минус данной программы в том, что она дает только одну попытку, без права на ошибку 🙂 . Это легко исправить, заключив весь блок switch-case в . Но может возникнуть вопрос: внутри switch-case есть break, не прервет ли он выполнение цикла? Нет, break прервет только выполнение блока switch. Если у вас возникают проблемы с пониманием того, как работает switch-case, посмотрите на следующую if-else конструкцию, она работает точно так же, как и switch If (1 == input)
{
playgame();
}
else if (2 == input)
{
loadgame();
}
else if (3 == input)
{
playmultiplayer();
}
else if (4 == input)
{
cout << "Thank you for playing!\n";
}
else
{
cout << "Error, bad input, quitting\n";
}
Если мы можем сделать то же самое с помощью if-else, зачем вообще нужен switch? Главное преимущество этой конструкции в том, что нам понятно, как работает программа: единственная переменная контролирует поведение программы. В случае с if-else, придется внимательно читать каждое условие. Иногда при написании программ могут понадобится переменные, которые могут принимать только строго определенные значения, которые известны вам заранее. Например, вы можете задать ограниченный набор цветов, которые пользователь может выбрать. Очень удобно иметь сразу и набор доступных констант и тип переменной, который связан с этим набором. Более того, подобные переменные хорошо подходят для использования в switch-case, так как вы знаете все возможные значения заранее. Тип enum
(сокращение от «enumerated type
«, ) содержит перечисление
различных значений, например цветов радуги: Enum RainbowColor {
RC_RED, RC_ORANGE, RC_YELLOW, RC_GREEN, RC_BLUE, RC_INDIGO, RC_VIOLET
};
Несколько важных моментов: Теперь вы можете объявлять переменные с типом RainbowColor: RainbowColor chosen_color = RC_RED;
И, как уже говорилось, эти переменные хорошо подходят для использования в switch: Switch (chosen_color)
{
case RC_RED: /* paint screen red */
case RC_ORANGE: /* paint screen orange */
case RC_YELLOW: /* paint screen yellow */
case RC_GREEN: /* paint screen green */
case RC_BLUE: /* paint screen blue */
case RC_INDIGO: /* paint screen indigo */
case RC_VIOLET: /* paint screen violet */
default: /* обработка исключений */
}
Так как мы используем перечисления, мы можем быть уверенными, что рассмотрели все возможные значения переменной. Значения констант в перечислении — это простой int, по умолчанию каждое следующее значение больше предыдущего на 1. Для первого — 0, для второго — 1 и т.д. В нашем случае: RC_RED = 0 и RC_ORANGE = 1. Вы также можете задать собственные значения: Enum RainbowColor {
RC_RED = 1, RC_ORANGE = 3, RC_YELLOW = 5, RC_GREEN = 7, RC_BLUE = 9,
RC_INDIGO = 11, RC_VIOLET = 13
};
Преимущество использования перечисляемых типов в том, что вы можете задать имя значениям, которые иначе пришлось бы хард-кодить. Например, если вы пишете игру крестики-нолики, вам нужен способ представления крестиков и ноликов на доске. Это может быть 0 для пустой клетки, 1 для нолика и 2 для крестика. Значит, наверняка придется использовать подобный код: If (board_position == 1)
{
/* do something */
}
Данный код очень сложен для понимания и обслуживания, потому что совсем не понятно, что означает цифра 1. Enum типы позволяют избегать таких ситуаций: Enum TicTacToeSquare { TTTS_BLANK, TTTS_O, TTTS_X };
if (board_position == TTTS_O)
{
/* some code */
}
Теперь все гораздо понятнее 🙂 . На этом всё! Подписывайтесь и не пропустите новые уроки! 🙂 Оператор выбора switch
позволяет выбрать один вариант хода решения задачи из нескольких в зависимости от значения выражения. Таким образом, обеспечивается многонаправленное разветвление в программе. Оператор switch
может быть заменен . Однако, в некоторых случаях использование оператора switch
может быть более эффективным, чем использование . Общая форма записи оператора switch
следующая Оператор switch
работает следующим образом. Сначала вычисляется значение выражение. Потом это значение последовательно сравнивается с константами из заданного списка. Как только найдено совпадение для одного из условий сравнения (ветвь case
), выполняется последовательность инструкций, которые связаны с этим сравнением. Если не найдено ни одного совпадения, то выполняются операторы, которые следуют после ключевого слова default
. Ключевое слово case
используется для того, чтобы указать значение константы, при совпадении с которой значения выражения, будет выполняться соответствующая последовательность операторов. Операция break
прерывает (заканчивает) выполнение кода, который определен инструкцией switch
. Операции, которые размещены после ключевого слова default
, выполняются в том случае, если ни одна из case-констант не совпадает с результатом вычисления switch
-выражения. Ключевое слово default
и соответствующая последовательность операторов могут быть опущены. В этом случае, если не выполняется ни одна из ветвей после слова case
, выполнение передается следующему оператору, который следует за оператором switch
. Пример 1.
Даны значения n
= 1..7, что есть номером дня недели. По значению n
определить, выходной этот день или рабочий. Результат записать в переменную fDayOff
типа bool
. Фрагмент кода, который решает данную задачу. Другой, более компактный вариант решения данной задачи. Еще один вариант решения данной задачи Пример 2.
Дано целое число n
= 1..3, которое есть номером функции. По значению переменной n
вычислить значение соответствующей функции: 1) -2x 2 -4; 2) 5x+2; 3) 15-3x.
Фрагмент кода, который решает данную задачу с помощью сокращенной формы оператора switch
. В операторе switch
операция break
не является обязательной. Если операция break
присутствует, то происходит выход из оператору switch
и выполнение следующего за ним оператора. Если операция break
в case
-ветви отсутствует, тогда выполняются все операторы, которые связаны с данной case
-ветвью, а также все операторы, которые следуют сразу после нее до тех пор, пока не встретится другая инструкция break
или не будет достигнут конец switch
-оператора. Последнее обновление: 30.07.2016 Условные конструкции - один из базовых компонентов многих языков программирования, которые направляют работу программы по одному из путей
в зависимости от определенных условий. В языке C# используются следующие условные конструкции: if..else и switch..case Конструкция if/else проверяет истинность некоторого условия и в зависимости от результатов проверки выполняет определенный код: Int num1 = 8;
int num2 = 6;
if(num1 > num2)
{
Console.WriteLine($"Число {num1} больше числа {num2}");
}
После ключевого слова if ставится условие. И если это условие выполняется, то срабатывает код, который помещен далее в
блоке if после фигурных скобок. В качестве условий выступают ранее рассмотренные операции сравнения. В данном случае у нас первое число больше второго, поэтому выражение num1 > num2 истинно и возвращает
true , следовательно, управление переходит к строке Console.WriteLine("Число {num1} больше числа {num2}"); Но что, если мы захотим, чтобы при несоблюдении условия также выполнялись какие-либо действия? В этом случае мы можем добавить блок else: Int num1 = 8;
int num2 = 6;
if(num1 > num2)
{
Console.WriteLine($"Число {num1} больше числа {num2}");
}
else
{
Console.WriteLine($"Число {num1} меньше числа {num2}");
}
Int num1 = 8;
int num2 = 6;
if(num1 > num2)
{
Console.WriteLine($"Число {num1} больше числа {num2}");
}
else if (num1 < num2)
{
Console.WriteLine($"Число {num1} меньше числа {num2}");
}
else
{
Console.WriteLine("Число num1 равно числу num2");
}
Также мы можем соединить сразу несколько условий, используя логические операторы: Int num1 = 8;
int num2 = 6;
if(num1 > num2 && num1==8)
{
Console.WriteLine($"Число {num1} больше числа {num2}");
}
В данном случае блок if будет выполняться, если num1 > num2 равно true и num1==8 равно true . Конструкция switch/case
аналогична конструкции if/else , так как позволяет обработать сразу несколько условий: Console.WriteLine("Нажмите Y или N");
string selection = Console.ReadLine();
switch (selection)
{
case "Y":
Console.WriteLine("Вы нажали букву Y");
break;
case "N":
Console.WriteLine("Вы нажали букву N");
break;
default:
Console.WriteLine("Вы нажали неизвестную букву");
break;
}
После ключевого слова switch
в скобках идет сравниваемое выражение. Значение этого выражения последовательно сравнивается со значениями, помещенными после оператора
сase
. И если совпадение будет найдено, то будет выполняться определенный блок сase
. В конце каждого блока сase должен ставиться один из операторов перехода:
break
, goto case
, return
или throw
.
Как правило, используется оператор break
. При его применении другие блоки case выполняться не будут. Однако если мы хотим, чтобы, наоборот, после выполнения текущего блока case выполнялся другой блок case, то мы можем использовать вместо break оператор
goto case: Int number = 1;
switch (number)
{
case 1:
Console.WriteLine("case 1");
goto case 5; // переход к case 5
case 3:
Console.WriteLine("case 3");
break;
case 5:
Console.WriteLine("case 5");
break;
default:
Console.WriteLine("default");
break;
}
Если мы хотим также обработать ситуацию, когда совпадения не будет найдено, то можно добавить блок default
,
как в примере выше. Применение оператора return позволит выйти не только из блока case, но и из вызывающего метода. То есть, если в методе Main после конструкции switch..case,
в которой используется оператор return , идут какие-либо операторы и выражения, то они выполняться не будут, а метод Main завершит работу. Оператор throw применяется для выброса ошибок и будет рассмотрен в одной из следующим тем. Тернарную операция имеет следующий синтаксис: [первый операнд - условие] ? [второй операнд] : [третий операнд] . Здесь сразу три операнда.
В зависимости от условия тернарная операция возвращает второй или третий операнд: если условие равно true , то
возвращается второй операнд; если условие равно false , то третий. Например: Int x=3;
int y=2;
Console.WriteLine("Нажмите + или -");
string selection = Console.ReadLine();
int z = selection=="+"? (x+y) : (x-y);
Console.WriteLine(z);
Здесь результатом тернарной операции является переменная z. Если мы выше вводим "+", то z будет равно второму операнду - (x+y). Иначе z
будет равно третьему операнду.Сравнение switch-case с if-else
Создаем собственные типы с помощью enumeration
1. Назначение оператора выбора switch
2. Общая форма описания оператора выбора switch
. Ключевые слова switch
, case
, break
, default
3. Примеры использования оператора выбора switch
4. Особенности использования операции break
в операторе switch
Конструкция if/else
Конструкция switch
Тернарная операция
