Смарт ТВ 

Язык си switch. Особенности использования операции break в операторе switch. Создаем собственные типы с помощью enumeration

Сегодня мы научимся пользоваться этой полезной конструкцией языка 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 using namespace std; void playgame() { cout << "Play game called"; } void loadgame() { cout << "Load game called"; } void playmultiplayer() { cout << "Play multiplayer game called"; } int main() { int input; cout<<"1. Play game\n"; cout<<"2. Load game\n"; cout<<"3. Play multiplayer\n"; cout<<"4. Exit\n"; cout<<"Selection: "; cin>> input; switch (input) { case 1: playgame(); break; case 2: loadgame(); break; case 3: playmultiplayer(); break; case 4: cout<<"Thank you for playing!\n"; break; default: cout<<"Error, bad input, quitting\n"; break; } cin.get(); }

Эта программа показывает простой способ обработки вводимых пользователем данных.

Минус данной программы в том, что она дает только одну попытку, без права на ошибку 🙂 . Это легко исправить, заключив весь блок switch-case в . Но может возникнуть вопрос: внутри switch-case есть break, не прервет ли он выполнение цикла? Нет, break прервет только выполнение блока switch.

Сравнение switch-case с if-else

Если у вас возникают проблемы с пониманием того, как работает 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, придется внимательно читать каждое условие.

Создаем собственные типы с помощью enumeration

Иногда при написании программ могут понадобится переменные, которые могут принимать только строго определенные значения, которые известны вам заранее. Например, вы можете задать ограниченный набор цветов, которые пользователь может выбрать. Очень удобно иметь сразу и набор доступных констант и тип переменной, который связан с этим набором. Более того, подобные переменные хорошо подходят для использования в switch-case, так как вы знаете все возможные значения заранее.

Тип enum (сокращение от «enumerated type «, ) содержит перечисление различных значений, например цветов радуги:

Enum RainbowColor { RC_RED, RC_ORANGE, RC_YELLOW, RC_GREEN, RC_BLUE, RC_INDIGO, RC_VIOLET };

Несколько важных моментов:

  • Для объявление перечисляемого типа используйте ключевое слово enum .
  • Имя нового типа вы задаете сами, например RainbowColor.
  • Все возможные значения для данного типа перечислены в фигурных скобках.
  • После объявления перечисления необходима точка с запятой.

Теперь вы можете объявлять переменные с типом 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 */ }

Теперь все гораздо понятнее 🙂 .

На этом всё! Подписывайтесь и не пропустите новые уроки! 🙂

Условные операторы

Условные операторы позволяют управлять потоком выполнения программы, чтобы не выполнялась каждая строка кода, как она следует в программе. Давайте рассмотрим все условные операторы языка C#:

Оператор if

Для организации условного ветвления язык C# унаследовал от С и С++ конструкцию if...else. Ее синтаксис должен быть интуитивно понятен для любого, кто программировал на процедурных языках:

if (условие)
оператор (операторы)
else
оператор (операторы)

Если по каждому из условий нужно выполнить более одного оператора, эти операторы должны быть объединены в блок с помощью фигурных скобок {...}. (Это также касается других конструкций C#, в которых операторы могут быть объединены в блок - таких как циклы for и while .)

Стоит обратить внимание, что в отличие от языков С и С++, в C# условный оператор if может работать только с булевскими выражениями, но не с произвольными значениями вроде -1 и 0.

В операторе if могут применяться сложные выражения, и он может содержать операторы else, обеспечивая выполнение более сложных проверок. Синтаксис похож на применяемый в аналогичных ситуациях в языках С (С++) и Java. При построении сложных выражений в C# используется вполне ожидаемый набор логических операторов . Давайте рассмотрим следующий пример:

Using System; using System.Collections.Generic; using System.Linq; using System.Text; namespace ConsoleApplication1 { class Program { static void Main(string args) { string myStr; Console.WriteLine("Введите строку: "); myStr = Console.ReadLine(); if (myStr.Length = 5) && (myStr.Length

Как видите количество else if, добавляемых к единственному if, не ограничено. Один момент, который следует отметить касательно if: фигурные скобки применять не обязательно, если в условной ветви присутствует только один оператор, как показано в исходном примере.

Оператор switch

Вторым оператором выбора в C# является оператор switch , который обеспечивает многонаправленное ветвление программы. Следовательно, этот оператор позволяет сделать выбор среди нескольких альтернативных вариантов дальнейшего выполнения программы. Несмотря на то что многонаправленная проверка может быть организована с помощью последовательного ряда вложенных операторов if, во многих случаях более эффективным оказывается применение оператора switch. Этот оператор действует следующим образом. Значение выражения последовательно сравнивается с константами выбора из заданного списка. Как только будет обнаружено совпадение с одним из условий выбора, выполняется последовательность операторов, связанных с этим условием. Ниже приведена общая форма оператора switch:

switch(выражение) { case константа1: последовательность операторов break; case константа2: последовательность операторов break; case константаЗ: последовательность операторов break; ... default: последовательность операторов break; }

Хотя оператор switch...case должен быть знаком программистам на С и С++, в C# он немного безопаснее, чем его эквивалент С++. В частности, он запрещает "сквозные" условия почти во всех случаях. Это значит, что если часть case вызывается в начале блока, то фрагменты кода за последующими частями case не могут быть выполнены, если только не используется явно оператор goto для перехода к ним. Компилятор обеспечивает это ограничение за счет того, что требует, чтобы за каждой частью case следовал оператор break , в противном случае он выдает ошибку.

Важно отметить, что заданное выражение в операторе switch должно быть целочисленного типа (char, byte, short или int), перечислимого или же строкового . А выражения других типов, например с плавающей точкой, в операторе switch не допускаются. Зачастую выражение, управляющее оператором switch, просто сводится к одной переменной. Кроме того, константы выбора должны иметь тип, совместимый с типом выражения. В одном операторе switch не допускается наличие двух одинаковых по значению констант выбора.

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 управление передается оператору, следующему за прерванным.

  • 2. Общая форма описания оператора выбора switch . Ключевые слова switch , case , break , default
1. Назначение оператора выбора switch

Оператор выбора switch позволяет выбрать один вариант хода решения задачи из нескольких в зависимости от значения выражения. Таким образом, обеспечивается многонаправленное разветвление в программе.

Оператор switch может быть заменен . Однако, в некоторых случаях использование оператора switch может быть более эффективным, чем использование .

2. Общая форма описания оператора выбора switch . Ключевые слова switch , case , break , default

Общая форма записи оператора switch следующая

switch (выражение ) { case константа1 : последовательность_операторов1 ; break ; case константа2 : последовательность _операторов2 ; break ; ... case константа N : N ; break ; default последовательность_операторов ; }
  • выражение – некоторое выражение целочисленного (int ) или символьного типа (char );
  • константа1 , константа2 , …, константа N – константные значения, с которыми сравнивается значение выражения. Константные значения должны быть целочисленного или символьного типа;
  • последовательность _операторов1 , последовательность _операторов2 , …, последовательность _операторов N – соответствующая последовательность операторов (инструкций), которые связаны с соответствующим условием;
  • последовательность_операторов – последовательность операторов, которая выполняется в случае, если не найдено ни одно совпадение значения выражения со значением констант.

Оператор switch работает следующим образом. Сначала вычисляется значение выражение. Потом это значение последовательно сравнивается с константами из заданного списка. Как только найдено совпадение для одного из условий сравнения (ветвь case ), выполняется последовательность инструкций, которые связаны с этим сравнением. Если не найдено ни одного совпадения, то выполняются операторы, которые следуют после ключевого слова default .

Ключевое слово case используется для того, чтобы указать значение константы, при совпадении с которой значения выражения, будет выполняться соответствующая последовательность операторов.

Операция break прерывает (заканчивает) выполнение кода, который определен инструкцией switch .

Операции, которые размещены после ключевого слова default , выполняются в том случае, если ни одна из case-констант не совпадает с результатом вычисления switch -выражения.

Ключевое слово default и соответствующая последовательность операторов могут быть опущены. В этом случае, если не выполняется ни одна из ветвей после слова case , выполнение передается следующему оператору, который следует за оператором switch .

3. Примеры использования оператора выбора switch

Пример 1. Даны значения n = 1..7, что есть номером дня недели. По значению n определить, выходной этот день или рабочий. Результат записать в переменную fDayOff типа bool .

Фрагмент кода, который решает данную задачу.

int day; bool fDayOff; day = 3; switch (day) { case 1: fDayOff = false ; break ; case 2: fDayOff = false ; break ; case 3: fDayOff = false ; break ; case 4: fDayOff = false ; break ; case 5: fDayOff = false ; break ; case 6: fDayOff = true ; break ; case 7: fDayOff = true ; break ; }

Другой, более компактный вариант решения данной задачи.

int day; bool fDayOff; day = 7; switch (day) { case 1: case 2: case 3: case 4: case 5: fDayOff = false ; break ; case 6: case 7: fDayOff = true ; break ; }

Еще один вариант решения данной задачи

int day; bool fDayOff; day = 7; switch (day) { case 6: case 7: fDayOff = true ; break ; default : fDayOff = false ; }

Пример 2. Дано целое число n = 1..3, которое есть номером функции. По значению переменной n вычислить значение соответствующей функции:

1) -2x 2 -4; 2) 5x+2; 3) 15-3x.

Фрагмент кода, который решает данную задачу с помощью сокращенной формы оператора switch .

int n; float f, x; n = 3; x = 3; switch (n) { case 1: f = -2*x*x-4; break ; case 2: f = 5*x+2; break ; case 3: f = 15-3*x; break ; }
4. Особенности использования операции break в операторе switch

В операторе switch операция break не является обязательной.

Если операция break присутствует, то происходит выход из оператору switch и выполнение следующего за ним оператора. Если операция break в case -ветви отсутствует, тогда выполняются все операторы, которые связаны с данной case -ветвью, а также все операторы, которые следуют сразу после нее до тех пор, пока не встретится другая инструкция break или не будет достигнут конец switch -оператора.

Хотя конструкция if-else-if может выполнять многочисленные проверки, она не очень элегантна. Код очень труден для восприятия и в нем может запутаться даже автор через некоторое время. С этой целью С имеет оператор принятия решений switch, выполняющий действия, основываясь на сравнении значения со списком констант символов или целых чисел. При обнаружении совпадения выполняется оператор или операторы, ассоциированные с данным значением. Оператор switch имеет следующий вид:

switch (выражение) {
case константа1:

break;
case константа2:
последовательность операторов
break;
case константа3:
последовательность операторов break;
...
default:
последовательность операторов
}

Оператор default выполняется, если не найдено соответствий, default необязателен и, если его нет, то в случае отсутствия совпадений ничего не происходит. Когда обнаруживается совпадение, операторы, ассоциированные с соответствующим case, выполняются до тех пор, пока не встретится оператор break. В случае default (или последнего case, если отсутствует default), оператор switch заканчивает работу при обнаружении конца.

Следует знать о трех важных моментах оператора switch:

  1. switch отличается от if тем, что он может выполнять только операции проверки строгого равенства, в то время как if может вычислять логические выражения и отношения.
  2. Не может быть двух констант в одном операторе switch, имеющих одинаковые значения. Конечно, оператор switch, включающий в себя другой оператор switch, может содержать аналогичные константы.
  3. Если в операторе switch используются символьные константы, они автоматически преобразуются к целочисленным значениям.

Оператор switch часто используется для обработки команд клавиатуры типа работа с меню. Как показано ниже, функция menu() отображает меню для программы проверки орфографии и вызывает соответствующие процедуры:

Void menu(void)
{
char ch;

Printf("1. Check Spelling\n");
printf("2. Correct Spelling Errors\n");
printf("3. Display Spelling Errors\n");
printf("Strike Any Other Key to Skip\n");
printf (" Enter your choice: ");

Ch = getche(); /* чтение клавиатуры */

Switch(ch) {
case "1":
check_spelling();
break;
case "2":
correct_errors();
break;
case "3";
display_errors();
break;
default:
printf("No option selected");
}
}

С технической точки зрения операторы break являются необязательными в операторе switch. Они используются для окончания работы последовательности операторов, ассоциированных с данной константой. Если оператор break отсутствует, продолжают выполняться операторы следующего раздела, пока не будет достигнут оператор break или конец оператора switch. О константах выбора можно думать как о метках. Выполнение начинается с метки, соответствующей искомому значению, и продолжается, пока не будет достигнут break или конец оператора switch. Например, функция, показанная ниже, использует данную особенность оператора case для упрощения кода обработчика ввода драйвера устройства:

Void inp_handler(void)
{
int ch, flag;
ch = read_device(); /* чтение какого-то устройства */
flag = -1;
switch(ch) {
case 1: /* данные случаи имеют общую последовательность */
case 2: /* операторов */
case 3:
flag = 0;
break;
case 4:
flag = 1;
case 5:
error(flag);
break;
default:
process(ch);
}
}

Данная подпрограмма иллюстрирует две грани оператора switch. Во-первых, можно иметь пустые условия. В данном случае первые три условия приводят к выполнению одних и тех же операторов:

Во-вторых, выполнение переходит к следующему case, если отсутствует break. Если ch соответствует 4, то flag устанавливается в 1, и, поскольку отсутствует оператор break, выполнение продолжается и выполняется оператор error(flag). В данном случае flag имеет значение 1. Если ch равно 5, то вызывается error(flag), а значение flag будет равно - 1. Способность запускать несколько операторов, соответствующих нескольким условиям при отсутствии оператора break, позволяет создавать эффективный код, поскольку это избавляет от необходимости дублировать код.

Важно понять, что операторы, ассоциированные с каждой меткой, являются не блоками кода, а скорее последовательностью операторов. (Сам оператор switch определяет блок.) Понимание этого необходимо в некоторых специфических ситуациях. Например, следующий фрагмент кода содержит ошибку и не будет компилироваться, поскольку невозможно объявить переменную в последовательности операторов:

/* неверно */

Switch(с) {
case 1:
int t;
...

Тем не менее переменная может быть добавлена:

/* верно */
switch(с) {
int t;
case 1:
...

Имеется возможность создания блока кода как одного из операторов в последовательности и объявление в нем переменной, как показано ниже:

/* Это также корректно */
switch (с) {
case 1:
{ /* create a block */
int t;
...
}