Текст книги "Полное руководство. С# 4.0"
Автор книги: Герберт Шилдт
Жанр:
Программирование
сообщить о нарушении
Текущая страница: 7 (всего у книги 58 страниц)
Ниже приведен результат выполнения этой программы. Исходное сообщение: Hi! Зашифрованное сообщение: □1y Расшифрованное сообщение: Hi!
Как видите, в результате выполнения двух последовательностей поразрядных опе раций исключающее ИЛИ получается расшифрованное сообщение. (Еще раз напом ним, что такое шифрование не имеет никакой практической ценности, поскольку оно, в сущности, ненадежно.)
Поразрядный унарный оператор НЕ (или оператор дополнения до 1) изменяет на обратное состояние всех двоичных разрядов операнда. Так, если некоторое целое зна чение А имеет комбинацию двоичных разрядов 1001 0110, то в результате поразрядной операции ~А получается значение с комбинацией двоичных разрядов 0110 1001.
В следующем примере программы демонстрируется применение поразрядного оператора НЕ с выводом некоторого числа и его дополнения до 1 в двоичном коде. // Продемонстрировать применение поразрядного унарного оператора НЕ. using System; class NotDemo { static void Main() { sbyte b = -34; for(int t=128; t > 0; t = t/2) { if((b & t) != 0) Console.Write("1 "); if((b & t) == 0) Console.Write("0 "); } Console.WriteLine(); // обратить все биты b = (sbyte) ~b; for(int t=128; t > 0; t = t/2) { if((b & t) != 0) Console.Write("1 "); if((b & t) == 0) Console.Write("0 "); } } }
Результат выполнения этой программы приведен ниже. 1 1 0 1 1 1 1 0 0 0 1 0 0 0 0 1 Операторы сдвига
В C# имеется возможность сдвигать двоичные разряды, составляющие целое зна чение, влево или вправо на заданную величину. Для этой цели в C# определены два приведенных ниже оператора сдвига двоичных разрядов. << Сдвиг влево >> Сдвиг вправо
Ниже приведена общая форма для этих операторов: значение << число_битов значение >> число_битов
где число_битов – это число двоичных разрядов, на которое сдвигается указанное значение.
При сдвиге влево все двоичные разряды в указываемом значении сдвигаются на одну позицию влево, а младший разряд сбрасывается в нуль. При сдвиге вправо все двоичные разряды в указываемом значении сдвигаются на одну позицию вправо. Если вправо сдвигается целое значение без знака, то старший разряд сбрасывается в нуль. А если вправо сдвигается целое значение со знаком, то разряд знака сохраняется. На помним, что для представления отрицательных чисел старший разряд целого числа устанавливается в 1. Так, если сдвигаемое значение является отрицательным, то при каждом сдвиге вправо старший разряд числа устанавливается в 1. А если сдвигаемое значение является положительным, то при каждом сдвиге вправо старший разряд чис ла сбрасывается в нуль.
При сдвиге влево и вправо крайние двоичные разряды теряются. Восстановить по терянные при сдвиге двоичные разряды нельзя, поскольку сдвиг в данном случае не является циклическим.
Ниже приведен пример программы, наглядно демонстрирующий действие сдвига влево и вправо. В данном примере сначала задается первоначальное целое значение, равное 1. Это означает, что младший разряд этого значения установлен. Затем это це лое значение сдвигается восемь раз подряд влево. После каждого сдвига выводятся во семь младших двоичных разрядов данного значения. Далее процесс повторяется, но на этот раз 1 устанавливается на позиции восьмого разряда, а по существу, задается целое значение 128, которое затем сдвигается восемь раз подряд вправо. // Продемонстрировать применение операторов сдвига. using System; class ShiftDemo { static void Main() { int val = 1; for(int i = 0; i < 8; i++) { for(int t=128; t > 0; t = t/2) { if((val & t) != 0) Console.Write("1 "); if((val & t) == 0) Console.Write("0 "); } Console.WriteLine(); val = val << 1; // сдвиг влево } Console.WriteLine(); val = 128; for(int i = 0; i < 8; i++) { for(int t=128; t > 0; t = t/2) { if((val & t) != 0) Console.Write("1 "); if((val & t) == 0) Console.Write("0 "); } Console.WriteLine(); val = val >> 1; // сдвиг вправо } } }
Результат выполнения этой программы выглядит следующим образом. 0 0 0 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 1
Двоичные разряды соответствуют форме представления чисел в степени 2, и поэто му операторы сдвига могут быть использованы для умножения или деления целых значений на 2. Так, при сдвиге вправо целое значение удваивается, а при сдвиге вле во – уменьшается наполовину. Разумеется, все это справедливо лишь в том случае, если крайние разряды не теряются при сдвиге в ту или иную сторону. Ниже приведен соответствующий пример. // Применить операторы сдвига для умножения и деления на 2. using System; class MultDiv { static void Main() { int n; n = 10; Console.WriteLine("Значение переменной n: " + n); // Умножить на 2. n = n << 1; Console.WriteLine("Значение переменной n после " + "операции n = n * 2: " + n); // Умножить на 4. n = n << 2; Console.WriteLine("Значение переменной n после " + "операции n = n * 4: " + n); // Разделить на 2. n = n >> 1; Console.WriteLine("Значение переменной n после " + "операции n = n / 2: " + n); // Разделить на 4. n = n >> 2; Console.WriteLine("Значение переменной n после " + "операции n = n / 4: " + n); Console.WriteLine(); // Установить переменную n в исходное состояние. n = 10; Console.WriteLine("Значение переменной n: " + n); // Умножить на 2 тридцать раз. n = n << 30; // данные теряются Console.WriteLine("Значение переменной п после " + "сдвига на 30 позиций влево: " + n); } }
Ниже приведен результат выполнения этой программы. Значение переменной n: 10 Значение переменной n после операции n = n * 2: 20 Значение переменной n после операции n = n * 4: 80 Значение переменной n после операции n = n / 2: 40 Значение переменной n после операции n = n / 4: 10 Значение переменной n: 10 Значение переменной n после сдвига на 30 позиций влево: -2147483648
Обратите внимание на последнюю строку приведенного выше результата. Когда целое значение 10 сдвигается влево тридцать раз подряд, информация теряется, по скольку двоичные разряды сдвигаются за пределы представления чисел для типа int. В данном случае получается совершенно "непригодное" значение, которое оказывается к тому же отрицательным, поскольку в результате сдвига в старшем разряде, исполь зуемом в качестве знакового, оказывается 1, а следовательно, данное числовое значение должно интерпретироваться как отрицательное. Этот пример наглядно показывает, что применять операторы сдвига для умножения иди деления на 2 следует очень акку ратно. (Подробнее о типах данных со знаком и без знака см. в главе 3.) Поразрядные составные операторы присваивания
Все двоичные поразрядные операторы могут быть использованы в составных опе рациях присваивания. Например, в двух приведенных ниже операторах переменной х присваивается результат выполнения операции исключающее ИЛИ над первона чальным значением переменной х и числовым значением 127. х = х ^ 127; х ^= 127; Оператор ?
Оператор ? относится к числу самых примечательных в С#. Он представляет со бой условный оператор и часто используется вместо определенных видов конструкций if-then-else. Оператор ? иногда еще называют тернарным, поскольку для него тре буются три операнда. Ниже приведена общая форма этого оператора. Выражение! ? Выражение2 : Выражение3;
Здесь Выражение1 должно относиться к типу bool, а Выражение2 и Выражение3 – к одному и тому же типу. Обратите внимание на применение двоеточия и его место положение в операторе ?.
Значение выражения ? определяется следующим образом. Сначала вычисляется Выражение1. Если оно истинно, то вычисляется Выражение2, а полученный результат определяет значение всего выражения ? в целом. Если же Выражение1 оказывается ложным, то вычисляется Выражение3, и его значение становится общим для всего вы ражения ?. Рассмотрим следующий пример, в котором переменной absval присваи вается значение переменной val. absval = val < 0 ? -val : val; // получить абсолютное значение переменной val
В данном примере переменной absval присваивается значение переменной val, если оно больше или равно нулю. Если же значение переменной val отрицательно, то переменной absval присваивается результат отрицания этого значения, что в итоге дает положительное значение.
Ниже приведен еще один пример применения оператора ?. В данной программе одно число делится на другое, но при этом исключается деление на нуль. // Исключить деление на нуль, используя оператор?. using System; class NoZeroDiv { static void Main() { int result; for(int i = -5; i < 6; i++) { result = i != 0 ? 100 / i : 0; if (i ! = 0) Console.WriteLine("100 / " + i + " равно " + result); } } }
Выполнение этой программы дает следующий результат. 100 / -5 равно -20 100 / -4 равно -25 100 / -3 равно -33 100 / -2 равно -50 100 / -1 равно -100 100 / 1 равно 100 100 / 2 равно 50 100 / 3 равно 33 100 / 4 равно 25 100 / 5 равно 20
Обратите особое внимание на следующую строку из приведенной выше программы. result = i != 0 ? 100 / i : 0;
В этой строке переменной result присваивается результат деления числа 100 на значение переменной i. Но это деление осуществляется лишь в том случае, если зна чение переменной i не равно нулю. Когда же оно равно нулю, переменной result присваивается значение, обнуляющее результат.
Присваивать переменной результат выполнения оператора ? совсем не обязатель но. Например, значение, которое дает оператор ?, можно использовать в качестве аргу мента при вызове метода. А если все выражения в операторе ? относятся к типу bool, то такой оператор может заменить собой условное выражение в цикле или операторе if. В приведенном ниже примере программы выводятся результаты деления числа 100 только на четные, ненулевые значения. // Разделить только на четные, ненулевые значения. using System; class NoZeroDiv2 { static void Main() { for(int i = -5; i < 6; i++) if(i != 0 ? (i%2 == 0) : false) Console.WriteLine("100 / " + i + " равно " + 100 / i); } }
Обратите внимание на оператор if в приведенной выше программе. Если значение переменной i равно нулю, то оператор if дает ложный результат. А если значение переменной i не равно нулю, то оператор if дает истинный результат, когда значение переменной i оказывается четным, и ложный результат, если оно нечетное. Благодаря этому допускается деление только на четные и ненулевые значения. Несмотря на то что данный пример служит лишь для целей демонстрации, подобные конструкции иногда оказываются весьма полезными. Использование пробелов и круглых скобок
В выражении на C# допускается наличие символов табуляции и пробелов, благо даря которым оно становится более удобным для чтения. Например, оба приведенных ниже выражения, по существу, одинаковы, но второе читается легче. х=10/у*(127+х); х = 10 / у * (127 + х);
Скобки могут служить для группирования подвыражений, по существу, повышая порядок предшествования заключенных в них операций, как в алгебре. Применение лишних или дополнительных скобок не приводит к ошибкам и не замедляет вычис ление выражения. Поэтому скобки рекомендуется использовать, чтобы сделать более ясным и понятным порядок вычисления как для самого автора программы, так и для тех, кто будет разбираться в ней впоследствии. Например, какое из двух приведенных ниже выражение легче читается? х = у/3-34*temp+127; х = (у/3) – (34*temp) + 127; Предшествование операторов
В табл. 4.2 приведен порядок предшествования всех операторов в С#: от самого вы сокого до самого низкого. В таблицу включен ряд операторов, рассматриваемых далее в этой книге. Наивысший порядок () [] . ++ (постфиксный) – (постфиксный) checked new sizeof typeof unchecked ! ~ (приведение типов) + (унарный) – (унарный) ++ (префиксный) – (префиксный) * / % << >> < > <= >= is == != & ^ | && || ?? ?: = op= => Наинизший порядок
ГЛАВА 5. Управляющие операторы
В этой главе речь пойдет об операторах, управляющих ходом выполнения программы на С#. Управляющие операторы разделяются на три категории: операторы выбора, к числу которых относятся операторы if и switch, итерационные операторы, в том числе операторы цикла for, while, do-while и foreach, а также операторы пере хода: break, continue, goto, return и throw. За исклю чением оператора throw, который является неотъемлемой частью встроенного в C# механизма обработки исключи тельных ситуаций, рассматриваемого в главе 13, все осталь ные управляющие операторы представлены в этой главе. Оператор if
Оператор if уже был представлен в главе 2, а здесь он рассматривается более подробно. Ниже приведена полная форма этого оператора: if(условие) оператор; else оператор;
где условие – это некоторое условное выражение, a опe– ратор – адресат операторов if и else. Оператор else не является обязательным. Адресатом обоих операторов, if и else, могут также служить блоки операторов. Ниже приведена общая форма оператора if, в котором исполь зуются блоки операторов. if(условие) { последовательность операторов } else { последовательность операторов }
Если условное выражение оказывается истинным, то выполняется адресат операто ра if. В противном случае выполняется адресат оператора else, если таковой суще ствует. Но одновременно не может выполняться и то и другое. Условное выражение, управляющее оператором if, должно давать результат типа bool.
Ниже приведен пример простой программы, в которой операторы if и else используются для того, чтобы сообщить, является ли число положительным или отрицательным. // Определить, является ли числовое значение положительным или отрицательным. using System; class PosNeg { static void Main() { int i; for(i=-5; i <= 5; i++) { Console.Write("Проверка " + i + "); if(i < 0) Console.WriteLine("отрицательное число”); else Console.WriteLine("положительное число"); } } }
Результат выполнения этой программы выглядит следующим образом. Проверка -5: отрицательное число Проверка -4: отрицательное число Проверка -3: отрицательное число Проверка -2: отрицательное число Проверка -1: отрицательное число Проверка 0: положительное число Проверка 1: положительное число Проверка 2: положительное число Проверка 3: положительное число Проверка 4: положительное число Проверка 5: положительное число
Если в данном примере значение переменной i оказывается меньше нуля, то вы полнятся адресат оператора if. В противном случае выполняется адресат оператора else, одновременно они не выполняются. Вложенные операторы if
Вложенным называется такой оператор if, который является адресатом другого оператора if или же оператора else. Вложенные операторы if очень часто приме няются в программировании. Что же касается их применения в С#, то не следует забы вать, что любой оператор else всегда связан с ближайшим оператором if, т.е. с тем оператором if, который находится в том же самом блоке, где и оператор else, но не с другим оператором else. Рассмотрим следующий пример. if (i == 10) { if(j < 20) a = b; if(k > 100) с = d; else a = с; // этот оператор else связан с оператором if(k > 100) } else a = d; // этот оператор else связан с оператором if(i == 10)
Как следует из комментариев к приведенному выше фрагменту кода, последний оператор else не связан с оператором if(j < 20), поскольку они не находятся в одном и том же блоке, несмотря на то, что этот оператор является для него ближай шим оператором if без вспомогательного оператора else. Напротив, последний опе ратор else связан с оператором if(i == 10). А внутренний оператор else связан с оператором if(k > 100), поскольку этот последний является для него ближайшим оператором if в том же самом блоке.
В приведенном ниже примере программы демонстрируется применение вложен ного оператора if. В представленной ранее программе определения положительных и отрицательных чисел о нуле сообщалось как о положительном числе. Но, как прави ло, нуль считается числом, не имеющим знака. Поэтому в следующей версии данной программы о нуле сообщается как о числе, которое не является ни положительным, ни отрицательным. // Определить, является ли числовое значение // положительным, отрицательным или нулевым. using System; class PosNegZero { static void Main() { int i; for(i=-5; i <= 5; i++) { Console.Write("Проверка " + i + ": "); if(i < 0) Console.WriteLine("отрицательное число"); else if(i == 0) Console.WriteLine("число без знака"); else Console.WriteLine ("положительное число"); } } }
Ниже приведен результат выполнения этой программы. Проверка -5: отрицательное число Проверка -4: отрицательное число Проверка -3: отрицательное число Проверка -2: отрицательное число Проверка -1: отрицательное число Проверка 0: число без знака Проверка 1: положительное число Проверка 2: положительное число Проверка 3: положительное число Проверка 4: положительное число Проверка 5: положительное число Конструкция if-else-if
В программировании часто применяется многоступенчатая конструкция if-elseif, состоящая из вложенных операторов if. Ниже приведена ее общая форма. if(условие) оператор; else if (условие) оператор; else if (условие) оператор; else оператор;
Условные выражения в такой конструкции вычисляются сверху вниз. Как только обнаружится истинное условие, выполняется связанный с ним оператор, а все осталь ные операторы в многоступенчатой конструкции опускаются.
Если ни одно из условий не является истинным, то выполняется последний опера тор else, который зачастую служит в качестве условия, устанавливаемого по умол чанию. Когда же последний оператор else отсутствует, а все остальные проверки по условию дают ложный результат, то никаких действий вообще не выполняется.
В приведенном ниже примере программы демонстрируется применение многосту пенчатой конструкции if-else-if. В этой программе обнаруживается наименьший множитель заданного целого значения, состоящий из одной цифры. // Определить наименьший множитель заданного // целого значения, состоящий из одной цифры. using System; class Ladder { static void Main() { int num; for(num = 2; num < 12; num++) { if((num % 2) == 0) Console.WriteLine("Наименьший множитель числа " + num + " равен 2."); else if((num % 3) == 0) Console.WriteLine("Наименьший множитель числа " + num + " равен 3."); else if((num % 5) == 0) Console.WriteLine("Наименьший множитель числа " + num + " равен 5."); else if((num % 7) == 0) Console.WriteLine("Наименьший множитель числа " + num + " равен 7."); else Console.WriteLine(num + " не делится на 2, 3, 5 или 7."); } } }
Вот к какому результату приводит выполнение этой программы. Наименьший множитель числа 2 равен 2 Наименьший множитель числа 3 равен 3 . . . Наименьший множитель числа 4 равен 2 Наименьший множитель числа 5 равен 5 Наименьший множитель числа 6 равен 2 Наименьший множитель числа 7 равен 7 Наименьший множитель числа 8 равен 2 Наименьший множитель числа 9 равен 3 Наименьший множитель числа 10 равен 2 11 не делится на 2, 3, 5 или 7.
Как видите, последний оператор else выполняется лишь в том случае, если не удается выполнить ни один из предыдущих операторов. Оператор switch
Вторым оператором выбора в C# является оператор switch, который обеспечивает многонаправленное ветвление программы. Следовательно, этот оператор позволяет сделать выбор среди нескольких альтернативных вариантов дальнейшего выполнения программы. Несмотря на то что многонаправленная проверка может быть организо вана с помощью последовательного ряда вложенных операторов if, во многих слу чаях более эффективным оказывается применение оператора switch. Этот оператор действует следующим образом. Значение выражения последовательно сравнивается с константами выбора из заданного списка. Как только будет обнаружено совпадение с одним из условий выбора, выполняется последовательность операторов, связанных с этим условием. Ниже приведена общая форма оператора switch. switch(выражение) { case константа1: последовательность операторов break; case константа2: последовательность операторов break; case константа3: последовательность операторов break; default: последовательность операторов break; }
Заданное выражение в операторе switch должно быть целочисленного типа (char, byte, short или int), перечислимого или же строкового. (О перечислениях и сим вольных строках типа string речь пойдет далее в этой книге.) А выражения других типов, например с плавающей точкой, в операторе switch не допускаются. Зачастую выражение, управляющее оператором switch, просто сводится к одной переменной. Кроме того, константы выбора должны иметь тип, совместимый с типом выражения. В одном операторе switch не допускается наличие двух одинаковых по значению констант выбора.
Последовательность операторов из ветви default выполняется в том случае, если ни одна из констант выбора не совпадает с заданным выражением. Ветвь default не является обязательной. Если же она отсутствует и выражение не совпадает ни с одним из условий выбора, то никаких действий вообще не выполняется. Если же происходит совпадение с одним из условий выбора, то выполняются операторы, связанные с этим условием, вплоть до оператора break.
Ниже приведен пример программы, в котором демонстрируется применение опе ратора switch. // Продемонстрировать применение оператора switch. using System; class SwitchDemo { static void Main() { int i; for(i=0; i<10; i++) switch(i) { case 0: Console.WriteLine("i равно нулю"); break; case 1: Console.WriteLine("i равно единице"); break; case 2: Console.WriteLine("i равно двум"); break; case 3: Console.WriteLine("i равно трем"); break; case 4: Console.WriteLine("i равно четырем"); break; default: Console.WriteLine("i равно или больше пяти"); break; } } }
Результат выполнения этой программы выглядит следующим образом. i равно нулю. i равно единице. i равно двум. i равно трем. i равно четырем. i равно или больше пяти. i равно или больше пяти. i равно или больше пяти. i равно или больше пяти. i равно или больше пяти.
Как видите, на каждом шаге цикла выполняются операторы, связанные с совпа дающей константой выбора, в обход всех остальных операторов. Когда же значение переменной i становится равным или больше пяти, то оно не совпадает ни с одной из констант выбора, а следовательно, выполняются операторы из ветви default.
В приведенном выше примере оператором switch управляла переменная i типа int. Как пояснялось ранее, для управления оператором switch может быть использо вано выражение любого целочисленного типа, включая и char. Ниже приведен при мер применения выражения и констант выбора типа char в операторе switch. // Использовать элементы типа char для управления оператором switch. using System; class SwitchDemo2 { static void Main() { char ch; for(ch='A'; ch<= 'E'; ch++) switch(ch) { case 'A': Console.WriteLine("ch содержит A"); break; case 'В': Console.WriteLine("ch содержит В"); break; case 'С': Console.WriteLine("ch содержит С"); break; case 'D': Console.WriteLine("ch содержит D"); break; case 'E': Console.WriteLine("ch содержит E"); break; } } }
Вот какой результат дает выполнение этой программы. ch содержит А ch содержит В ch содержит С ch содержит D ch содержит Е
Обратите в данном примере внимание на отсутствие ветви default в операторе switch. Напомним, что ветвь default не является обязательной. Когда она не нужна, ее можно просто опустить.
Переход последовательности операторов, связанных с одной ветвью case, в сле дующую ветвь case считается ошибкой, поскольку в С# должно непременно соблю даться правило недопущения "провалов" в передаче управления ходом выполнения программы. Именно поэтому последовательность операторов в каждой ветви case оператора switch оканчивается оператором break. (Избежать подобных "провалов", можно также с помощью оператора безусловного перехода goto, рассматриваемого далее в этой главе, но для данной цели чаще применяется оператор break.) Когда в последовательности операторов отдельной ветви case встречается оператор break, происходит выход не только из этой ветви, но из всего оператора switch, а выполне ние программы возобновляется со следующего оператора, находящегося за предела ми оператора switch. Последовательность операторов в ветви default также должна быть лишена "провалов", поэтому она завершается, как правило, оператором break.
Правило недопущения "провалов" относится к тем особенностям языка С#, кото рыми он отличается от С, C++ и Java. В этих языках программирования одна ветвь case может переходить (т.е. "проваливаться") в другую. Данное правило установлено в C# для ветвей case по двум причинам. Во-первых, оно дает компилятору возмож ность свободно изменять порядок следования последовательностей операторов из вет вей case для целей оптимизации. Такая реорганизация была бы невозможной, если бы одна ветвь case могла переходить в другую. И во-вторых, требование завершать каждую ветвь case явным образом исключает непроизвольные ошибки программи рования, допускающие переход одной ветви case в другую.
Несмотря на то что правило недопущения "провалов" не допускает переход одной ветви case в другую, в двух или более ветвях case все же разрешается ссылаться с по мощью меток на одну и ту же кодовую последовательность, как показано в следующем примере программы. // Пример "проваливания" пустых ветвей case. using System; class EmptyCasesCanFall { static void Main() { int i; for(i=1; i < 5; i++) switch(i) { case 1: case 2: case 3: Console.WriteLine("i равно 1, 2 или 3"); break; case 4: Console.WriteLine("i равно 4"); break; } } }
Ниже приведен результат выполнения этой программы. i равно 1, 2 или 3 i равно 1, 2 или 3 i равно 1, 2 или 3 i равно 4
Если значение переменной i в данном примере равно 1, 2 иди 3, то выполняется пер вый оператор, содержащий вызов метода WriteLine(). Такое расположение несколь ких меток ветвей case подряд не нарушает правило недопущения "провалов"; посколь ку во всех этих ветвях используется одна и та же последовательность операторов.
Расположение нескольких меток ветвей case подряд зачастую применяется в том случае, если у нескольких ветвей имеется общий код. Благодаря этому исключается излишнее дублирование кодовых последовательностей. Вложенные операторы switch
Один оператор switch может быть частью последовательности операторов дру гого, внешнего оператора switch. И такой оператор switch называется вложенным. Константы выбора внутреннего и внешнего операторов switch могут содержать об щие значения, не вызывая никаких конфликтов. Например, следующий фрагмент кода является вполне допустимым. switch(ch1) { case 'A': Console.WriteLine("Эта ветвь А – Часть " + "внешнего оператора switch."); switch(ch2) { case 'A': Console.WriteLine("Эта ветвь A – часть " + "внутреннего оператора switch"); break; case 'В': // ... } // конец внутреннего оператора switch break; case 'В': // ... Оператор цикла for
Оператор for уже был представлен в главе 2, а здесь он рассматривается более под робно. Вас должны приятно удивить эффективность и гибкость этого оператора. Пре жде всего, обратимся к самым основным и традиционным формам оператора for. Ниже приведена общая форма оператора for для повторного выполнения един ственного оператора. for(инициализация; условие; итерация) оператор;
А вот как выглядит его форма для повторного выполнения кодового блока: for(инициализация; условие; итерация) { последовательность операторов; }
где инициализация, как правило, представлена оператором присваивания, задающим первоначальное значение переменной, которая выполняет роль счетчика и управляет циклом; условие – это логическое выражение, определяющее необходимость повто рения цикла; а итерация – выражение, определяющее величину, на которую должно изменяться значение переменной, управляющей циклом, при каждом повторе цикла. Обратите внимание на то, что эти три основные части оператора цикла for должны быть разделены точкой с запятой. Выполнение цикла for будет продолжаться до тех пор, пока проверка условия дает истинный результат. Как только эта проверка даст ложный результат, цикл завершится, а выполнение программы будет продолжено с оператора, следующего после цикла for.
Цикл for может продолжаться как в положительном, так и в отрицательном на правлении, изменяя значение переменной управления циклом на любую величину. В приведенном ниже примере программы выводятся числа постепенно уменьшаю щиеся от 100 до -100 на величину 5. // Выполнение цикла for в отрицательном направлении. using System; class DecrFor { static void Main() { int x; for(x = 100; x > -100; x -= 5) Console.WriteLine(x); } }
В отношении циклов for следует особо подчеркнуть, что условное выражение всег да проверяется в самом начале цикла. Это означает, что код в цикле может вообще не выполняться, если проверяемое условие с самого начала оказывается ложным. Рассмо трим следующий пример. for(count=10; count < 5; count++) x += count; // этот оператор не будет выполняться
Данный цикл вообще не будет выполняться, поскольку первоначальное значение переменной count, которая им управляет, сразу же оказывается больше 5. Это означа ет, что условное выражение count < 5 оказывается ложным с самого начала, т.е. еще до выполнения первого шага цикла.
Оператор цикла for – наиболее полезный для повторного выполнения операций известное число раз. В следующем примере программы используются два цикла for для выявления простых чисел в пределах от 2 до 20. Если число оказывается непро стым, то выводится наибольший его множитель. // Выяснить, является ли число простым. Если оно // непростое, вывести наибольший его множитель. using System; class FindPrimes { static void Main() { int num; int i; int factor; bool isprime; for(num = 2; num < 20; num++) { isprime = true; factor = 0; // Выяснить, делится ли значение переменной num нацело. for(i=2; i <= num/2; i++) { if((num % i) == 0) { // Значение переменной num делится нацело. // Следовательно, это непростое число. isprime = false; factor = i; } } if(isprime) Console.WriteLine(num + " – простое число."); else Console.WriteLine("Наибольший множитель числа " + num + " равен " + factor); } } }
Ниже приведен результат выполнения этой программы. 2 – простое число 3 – простое число Наибольший множитель числа 4 равен 2 5 – простое число Наибольший множитель числа 6 равен 3 7 – простое число Наибольший множитель числа 8 равен 4 Наибольший множитель числа 9 равен 3 Наибольший множитель числа 10 равен 5 11 – простое число Наибольший множитель числа 12 равен 6 13 – простое число Наибольший множитель числа 14 равен 7 Наибольший множитель числа 15 равен 5 Наибольший множитель числа 16 равен 8 17 – простое число Наибольший множитель числа 18 равен 9 19 – простое число Некоторые разновидности оператора цикла for
