Применение в подобных случаях такого подхода, как предлагался в предыдущем разделе, чревато излишним насыщением кода вложенными блоками:

if (varl == 1) {

Выполнение какого-нибудь действия.

else

if (varl == 2) {

Выполнение какого-то другого действия.

else {

if (varl == 3 I I varl == 4) {

Выполнение еще какого-то действия.

else {

Выполнение еще какого-нибудь другого действия.

Одной из типичных ошибок является написание условий, вроде третьего условия в этом коде, в виде if (varl == 3 \ \ 4). При таком варианте первой операцией, согласно приоритетам, будет обрабатываться ==, из-за чего операции \ \ будет оставаться для работы, соответственно, булевский и числовой операнд, что и будет приводить к возникновению проблем.

В таких ситуациях лучше применять нескольку иную схему отступов и сжимать блок кода для else (т.е. использовать после else одну строку кода, а не блок). Такой подход приводит к получению в конечном итоге структуры с операторами else if:

if (varl == 1) {

Выполнение какого-нибудь действия.

else if (varl == 2) {

Выполнение какого-то другого действия.

else if (varl == 3 I I varl == 4) {

Выполнение еще какого-то действия.

else {

Выполнение еще какого-нибудь другого действия.

Эти операторы else if на самом деле являются двумя отдельными операторами, а код по функциональности полностью идентичен предыдущему, но зато более удобен для восприятия. При выполнении множества сравнений, как в этом примере, в качестве альтернативной структуры ветвления можно также использовать оператор switch.

Оператор switch

Оператор switch похож на if тем, что тоже умеет условно выполнять код на основании проверяемого значения. Однако в отличие от него, switch позволяет проверять переменную сразу на предмет соответствия множеству различных значений, а не с помощью множества отдельных условий. В таких проверках разрешено использовать только дискретные значения, а не конструкции вроде больше чем X , поэтому и способ применения этого оператора немного отличается.

Базовая структура оператор switch выглядит следующим образом:

switch (< проверяемая переменная>)

case <значение для сравпения 1 >:

<код, подлежащий выполнению, если <проверяемая пер€менная> == <значену£ для сравнения 1

breaks-case <значение для сравнения 2>:

<код, подлежащий выполнению, если <проверяемая переменная> == <значение для сравн€ния 2

breaks-case < значение для сравнения М>:

<код, подлежащий выполнению, если<проверяемая перем£Пная> == <значение для сравН£ния М breaks-default:

<код, подлежащий выполнению, есяи <проверяемая переменная> != <значение для сравнения Х break;

Значение в <проверяемая переменная> сравнивается с каждым из значений <зна-чение для сравнения Х> (задаваемых с помощью операторов сазе) и если удается обнаружить совпадение, тогда выполняется тот код, который содержится в разделе, соответствующем обнаруженному совпадению. Если не удается обнаружить ни одного совпадения, выполняется тот код, который содержится в разделе default, при условии, что такой раздел существует.

В конце кода в каждом разделе обязательно добавляется такая дополнительная команда, как break, исключающая вероятность перехода после обработки одного блока сазе к обработке следующего оператора сазе, потому что это недопустимо.

Такое поведение относится к одному из отличий языка С# от С++, в котором разрешено переходить от обработки одного оператора case к другому.

В данном случае оператор break просто завершает работу оператора switch, после чего процесс обработки продолжается с оператора, следующего после данной структуры.

Существуют и альтернативные способы для предотвращения в коде С# перехода потока выполнения от одного оператора case к следующему. Первый подразумевает применение оператора return, приводящего к завершению работы текущей функции, а не только структуры switch (о нем более подробно будет рассказываться в главе 6), а второй - использование оператора goto. Операторы goto (которые рассматривались ранее в главе) пригодны для подобных случаев, поскольку операторы case фактически определяют метки в коде. Ниже приведен пример:

switch (< проверяемая переменная>)

case < значение для сравненш 1 >:

<код, подлежащий выполнению, есяи<проверяемая переменная> == <значение для сравнения 1 goto case <значение для сравнения 2>;

case <значение для сравненш 2>:

<код, подлежащий выполптию, если <проверяемая переменная> == <значение для сравненуя 2 break;

Важно обратить внимание на одно исключение из правила, состоящего в том, что выполнение одного оператора case не может свободно переходить на следующий: в случае размещения нескольких операторов case вместе (в виде стопки) перед одиночным блоком кода, по сути, обеспечивается проверка одновременно нескольких условий. Удовлетворение любого из этих условий будет приводить к выполнению кода. Например:

switch {<проверяемая перемепная>) {

case <значение для сравнения 1>: case <знач€ние для сравпенуя 2>:

<код, подлежащий выполнению, если <проверяемая переменная> == <значение для сравнения 1>

<проверяшая переменная> == <значение для сравне}{ия 2 break;

Следует также обратить внимание и на то, что все эти условия будут применяться и к оператору default. Правила, гласящего, что данный оператор должен быть обязательно последним в списке сравнений, не существует, поэтому при желании его можно помещать в одну стопку с операторами case. Добавление точки прерывания с помощью оператора break, goto или return будет гарантировать наличие безопасного пути выполнения кода в структуре во всех случаях.

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

switch (mylnteger) {

case 1:

<код, подлежащий выполнению, если mylnteger == 1> break; case -1:

<код, подлежащий выполнению, eaiu mylnteger == -1> break; default:

<код, подлежащий выполнению, если mylnteger ! = сравниваемым значениям> break;

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

Объявляются константные переменные путем указания перед назначаемым им типом ключевого слова const, а также обязательного присваивания им значения, как показано ниже:

const int intTwo = 2;