6.3. Условный оператор (ветвлений)

К

операторам

выбора

,

называемым

операторами

ветвлений

"оператор:оператор ветвлений" , относят: условный оператор "оператор:условный

оператор" (if...else) и переключатель (switch). Каждый из них служит для выбора

"пути" выполнения программы. (О переключателе §6.6)

Синтаксис условного оператора:

If (логическое выражение) оператор_1

else оператор_2

Логическое выражение иногда называют проверяемым условием. Если

логическое выражение равно true, выполняется оператор_1. В противном случае,

когда выражение равно false, выполняется оператор_2. В качестве операторов,

входящих в условный оператор, нельзя использовать объявления. Однако, здесь

могут быть блоки и в них допустимы объявления. Примеры:

if (x > 0) { double x=-4; f(x * 2); }

else { int i = 2; double x = i*i; f(x); }

При использовании блоков нельзя забывать о локализации определяемых в

блоке объектов. Например, ошибочна будет такая конструкция:

if (j > 0) { int i; i = 2 * j; } else i = -j;

Здесь предполагается, что переменная j определена и имеет конкретное

значение. Ошибка в том, что переменная i локализована в блоке и не существует вне

блока

.

Допустима сокращенная форма условного оператора, в которой отсутствует

else и оператор_2. В этом случае при ложности проверяемого условия никакие

действия не выполняются. Пример:

if (a < 0) a = -a;

Оператор_1

и

оператор_2

могут

быть

условными,

что

позволяет

организовать цепочку проверок условий любой глубины вложенности. В этих

цепочках каждый из условных операторов (после проверяемого условия и после

else) может быть как полным условным, так и иметь сокращенную форму записи.

При этом могут возникать ошибки неоднозначного сопоставления if и else.

Синтаксис языка предполагает, что при вложениях условных операторов каждое

else соответствует ближайшему к нему предшествующему if.

В качестве примера вложения условных операторов приведём фрагмент

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

трёх значений переменных x, y, z. (Объявление и инициализация переменных

опущены).

if (x<y)

if (y<z) result = z;

else result = y;

else

if (x<z) result = z;

else result = x;

В тексте соответствие if и else показано с помощью отступов.

6.4. Операторы цикла

Операторы цикла

"оператор:операторы цикла"

задают многократное

исполнение операторов тела цикла. В языке C# определены четыре разных

оператора цикла.

Цикл с предусловием "цикл:цикл с предусловием" :

while (выражение-условие)

тело_цикла

Цикл с постусловием "цикл:цикл с постусловием" :

do

тело_цикла

while (выражение-условие);

Параметрический цикл

"цикл:параметрический цикл"

(цикл общего

вида):

for (инициализатор_цикла;

выражение-условие; завершающее_выражение

)

тело_цикла

Цикл перебора элементов "цикл:цикл перебора элементов" массива или

коллекции:

foreach (тип идентификатор in выражение )

тело цикла

while, do, for, foreach, in – служебные слова, применяемые только для

создания циклов. Оператор foreach будет рассмотрен при изучении массивов (глава

7). А теперь рассмотрим остальные циклы и их элементы.

Тело_цикла

"цикл:тело_цикла"

не может быть объявлением. Это либо

отдельный (в том числе пустой) оператор, который всегда завершается точкой с

запятой, либо блок. Выражение-условие, используемое в первых трех операторах –

это логическое выражение, определяющее условие продолжения выполнения

итераций (если его значение true). Прекращение выполнения цикла возможно в

следующих случаях:

ложное (false) значение проверяемого выражения-условия;

выполнение в теле цикла оператора передачи управления (break, goto, return).

Последнюю из указанных возможностей проиллюстрируем чуть позже,

рассматривая особенности операторов передачи управления.

Оператор while (оператор "повторять, пока истинно условие") называется

оператором цикла с предусловием "цикл:цикл с предусловием" . При входе в цикл

вычисляется выражение-условие. Если его значение истинно, то выполняется

тело_цикла. Затем вычисление выражения-условия и выполнение операторов

тела_цикла повторяются последовательно, пока значение выражения-условия

остаётся истинным и нет явной передачи управления за пределы тела цикла.

Оператором while удобно пользоваться для просмотра последовательностей,

если в конце каждой из них находится заранее известный признак.

В качестве проверяемого выражения-условия в циклах часто используются

отношения. Например, следующая последовательность операторов вычисляет сумму

квадратов первых К натуральных чисел (членов натурального ряда):

int i = 0; // Cчётчик

int s = 0; // Будущая сумма

while (i ++< K) //Цикл вычисления суммы

s += i * i;

Только при изменении операндов выражения-условия можно избежать

зацикливания. Поэтому, используя оператор цикла, необходимо следить за тем,

чтобы операторы тела_цикла воздействовали на выражение-условие, либо оно ещ

е

каким-то образом должно изменяться во время вычислений. Например, могут

изменяться операнды выражения-условия. Часто для этих целей используют

унарные операции ++ и --. В качестве примера использования оператора while

рассмотрим программу, которая предлагает пользователю ввести текстовую

информацию (непустую строку). Если пользователь нажимает ENTER, не введя

никаких данных, то предложение "Ввести данные" повторяется.

// 06_01.cs - цикл с предусловием

using System;

class Program

{

static void Main()

{

string name = "";

while (name == "")

{

Console.Write("Введите имя: ");

name = Console.ReadLine();

}

}

}

Результат выполнения программы:

Введите имя:<ENTER>

Введите имя:<ENTER>

Введите имя: Rem<ENTER>

В данной программе предлагается ввести имя и введённая строка,

представляемая переменной name, сравнивается с пустой строкой. Проверка

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

сложной. Но общая схема применения оператора цикла будет пригодна и в этих

более сложных случаях. Цикл не прекращается, пока не будут введены правильные

(по смыслу задачи) данные.

Оператор do (оператор "повторять") называется оператором цикла с

постусловием "цикл:цикл с постусловием" . Он имеет следующий вид:

do

тело_цикла

while (выражение-условие);

При входе в цикл do с постусловием тело_цикла хотя бы один раз

обязательно выполняется. Затем вычисляется выражение-условие и, если его

значение равно true, вновь выполняется тело_цикла. При обработке некоторых

последовательностей применение цикла с постусловием оказывается удобнее, чем

цикла с предусловием. Это бывает в тех случаях, когда обработку нужно

заканчивать не перед, а после появления концевого признака.

К выражению-условию в цикле do требования те же, что и для цикла while –

оно должно изменяться при итерациях либо за счет операторов тела цикла, либо при

вычислениях значения выражения-условия.

В предыдущей программе цикл с предусловием можно заменить таким циклом

с постусловием:

do

{ Console.Write ("Введите имя:");

name = Console.ReadLine();}

while (name=="");

Оператор параметрического цикла for или цикл общего вида имеет формат:

for ( инициализатор_цикла;

выражение_условие;

завершающее_выражение)

тело_цикла

Инициализатор_цикла

"цикл:инициализатор_цикла" – выражение или

определение

объектов

одного

типа .

Обычно

здесь

определяются

и

инициализируются некие параметры цикла. Обратим внимание, что эти параметры

должны быть только одного типа. Если в качестве инициализатора_цикла

используется не определение, а выражение, то чаще всего его операнды разделены

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

один раз при входе в цикл. Инициализатор_цикла в цикле for всегда завершается

точкой с запятой, т.е. отделяется этим разделителем от последующего выражения-

условия, которое также завершается точкой с запятой. Даже при отсутствии for в

цикле инициализатора_цикла, выражения-условия и завершающего_выражения

разделяющие их символы "точка с запятой" всегда присутствуют. То есть в

заголовке цикла for всегда имеются два символа ';'.

Выражение-условие такое же, как и в циклах while и do. Если оно равно false,

то выполнение цикла прекращается. В случае отсутствия выражения-условия

следующий за ним разделитель "точка с запятой" сохраняется, и предполагается, что

значение выражения_условия всегда истинно.

Завершающее_выражение (в цикле for) – достаточно часто представляет

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

выражения вычисляются на каждой итерации после выполнения операторов тела

цикла, то есть перед следующей проверкой выражения-условия.

Тело_цикла

"цикл:тело_цикла" , как уже сказано, может быть блоком,

отдельным оператором и пустым оператором. Определенные в инициализаторе

цикла объекты существуют только в заголовке и в теле цикла. Если результат

ы

выполнения цикла нужны после его окончания, то их нужно сохранять во внешних

относительно цикла объектах.

В следующей программе использованы три формы оператора for. В каждом из

циклов решается одна и та же задача суммирования квадратов первых k членов

натурального ряда:

// 06_02.cs - параметрический цикл (цикл общего вида).

using System;

class Program

{

static void Main()

{

int k = 3, s = 0, i = 1;

for (; i <= k; i++)

s += i * i;

Console.WriteLine("Сумма = " + s);

s = 0; k = 4; // Начальные значения s, k.

for (int j = 0; j < k; )

s += ++j * j;

Console.WriteLine("Сумма = " + s);

for (i = 0, s = 0, k = 5; i <= k; s += i * i, i++);

Console.WriteLine("Сумма = " + s);

}

}

Результат выполнения программы:

Сумма = 14

Сумма = 30

Сумма = 55

Все переменные в первом цикле внешние, отсутствует инициализатор цикла, в

завершающем выражении заголовка изменяется параметр цикла i. После

выполнения цикла результат сохраняется в переменной s и выводится. Перед

вторым циклом s обнуляется, а переменной k присваивается значение 4.

Инициализатор второго цикла определяет локализованную в цикле переменную j. В

заголовке отсутствует завершающее выражение, а параметр цикла j изменяется в

его теле (вне заголовка). Инициализатор третьего цикла – выражение, операнды

которого разделены запятыми. В этом выражении подготавливается выполнение

цикла – обнуляются значения i и s, и присваивается значение 5 переменной k.

Остальное должно быть понятно.

Итак, еще раз проследим последовательность выполнения цикла for.

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

инициализатора_цикла. Вычисляется значение выражения-условия. Если оно равно

true, выполняются операторы тела_цикла. Затем вычисляется завершающее

выражение, вновь вычисляется выражение-условие, и проверяется его значение.

Далее цепочка действий повторяется. Оператору for может быть поставлен в

соответствие следующий блок:

{

инициализатор_цикла;

while (выражение-условие) {

операторы_тела_цикла

завершающее_выражение;

}

}

При выполнении цикла for выражение-условие может изменяться либо при

вычислении его значений, либо под действием операторов тела цикла, либо под

действием завершающего выражения. Если выражение-условие не изменяется либо

отсутствует, то цикл бесконечен. Следующий оператор обеспечивает бесконечное

выполнение пустого оператора:

for( ; ;); // Бесконечный цикл

Разрешено и широко используется вложение любых циклов в любые циклы.

Чтобы проиллюстрировать возможности циклов и показать ещё несколько

приёмов программирования на C# , рассмотрим задачу об оценке машинного нуля

относительно заданного числового значения.

В предыдущей главе, посвящённой связи типов языка с классами .NET

Framework, мы узнали, что для классов вещественных чисел введено константное

статическое поле Epsilon, значение которого – наименьшее отличное от нуля

значение, которое может принимать переменная заданного вещественного типа. При

решении вычислительных задач иногда требуется использовать не минимально

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

относительно другого числа, принятого за базовое. Иногда это малое число

называют машинным нулём, относительно базовой величины.

Иллюстрируя

применение

операторов

цикла ,

напишем

программу ,

позволяющую оценить машинный нуль "машинный нуль" относительно вводимого

пользователем значения.

/ 06_03.cs - циклы и машинный нуль.

using System;

class Program

{

static void Main()

{

double real, estimate, zero;

do

Console.Write("Введите положительное число: ");

while (!double.TryParse(Console.ReadLine(), out real)||real <= 0);

for (estimate = 0, zero = real; estimate != real; zero /= 2.0)

estimate = real + zero

;

Console.WriteLine("Машинный нуль: " + zero);

}

}

Результат выполнения программы:

Введите положительное число: -16<ENTER>

Введите положительное число: двадцать<ENTER>

Введите положительное число: 23<ENTER>

Машинный нуль: 6,38378239159465E-16

В программе два цикла. Цикл с постусловием служит для "наблюдения" за

правильностью ввода исходного числового значения. От пользователя требуется,

чтобы он ввел положительное число. Метод TryParse() класса double анализирует

вводимую пользователем строку символов. Если она корректно представляет

вещественное число, то метод TryParse() возвращает значение true и присваивает

значение введенного числа аргументу real. Выражение_условие цикла do

(размещённое в скобках после while), истинно, если метод TryParse() вернёт

значение false или значение переменной real не положительное. В этом случае цикл

повторяется и пользователь повторно видит приглашение «Введите положительное

число».

Как только пользователь введет положительное значение переменной real,

начинает выполняться второй цикл. В конце каждой итерации вдвое уменьшается

значение переменной zero. Цикл выполняется до тех пор, пока сумма значения real с

zero не равна значению real. Равенство достигается в том случае, когда значение zero

становится пренебрежимо малой величиной относительно real. Таким образом,

достигнутое значение zero можно считать машинным нулём относительно real.

Разрешено и широко используется вложение любых циклов в любые циклы,

то есть цикл может быть телом другого цикла. Примеры таких вложений будут

многократно рассмотрены при дальнейшем изложении материала.