Ветвящиеся алгоритмы

Ветвящимся алгоритмом называется алгоритм, в котором из блока может выходить два потока данных. Таким блоком является блок условия, внутри блока записывается логическое выражение. Принято следующее, если логическое выражение имеет значение ИСТИНА, то поток данных идет вправо вниз, если выражение имеет значение ЛОЖЬ - влево вниз.

Пример 1.

Даны два значения целого типа x, y. Переменной z присвоить максимальное из двух значений.

Пример 2

Даны два значения целого типа x, y. Если значения x, y положительны, то заменить их нулем, в противном случае оставить их без изменений.

Пример 3

Заданы три стороны треугольника. Определить существует ли такой треугольник, в соответствии с этим существует, не существует.

Ветвление программ

Для того чтобы программы на С# были более гибкими, используются операторы перехода (операторы ветвления). В С# есть два типа ветвления программы: безусловный переход и условный. Кроме ветвлений, в С# также предусмотрены возможности циклической обработки данных, которые определяются ключевыми словами: for, while, do, in и foreach. Эти операторы обсудим в последующих уроках. Пока рассмотрим несколько способов условного и безусловного перехода.

Безусловные переходы

Безусловный переход осуществляется двумя способами. Первый способ — это вызов функций. Когда компилятор находит в основном тексте программы имя функции, то происходит приостановка выполнения текущего кода программы и осуществляется переход к найденной функции. Когда функция выполнится и завершит свою работу, то произойдет возврат в основной код программы, на ту инструкцию, которая следует за именем функции. Следующий пример иллюстрирует безусловный переход с использованием функции:

using System; class Functions {     static void Main()     {         Console.WriteLine("Метод Main. Вызываем метод Jump...");         Jump();         Console.WriteLine("Возврат в метод Main.");     }     static void Jump()     {         Console.WriteLine("Работает метод Jump!");     } }

Откомпилируйте и запустите программу. Вы увидите результат ее работы: Метод Main. Вызываем метод Jump... Работает метод Jump! Возврат в метод Main. Программа начинает выполняться с метода Main() и осуществляется последовательно, пока компилятор не вызовет функцию Jump(). Таким образом, происходит ответвление от основного потока выполняемых инструкций. Когда функция Jump() заканчивает свою работу, то продолжается выполнение программы со следующей строки после вызова функции. Второй способ реализации безусловного перехода можно осуществить при помощи ключевых слов: goto, break, continue, return или throw. Дополнительная информация об инструкциях goto, break, continue и return будет рассмотрена чуть позже. Об инструкции throw будет отдельный урок.

Условные переходы

Условный переход можно реализовать в программе с помощью ключевых слов языка: if, else или switch. Такой переход возможен только при условии, если он является истинным. if...else оператор if...else — это оператор ветвления, работа которого определяется условием. Условие оператора анализируется инструкцией if. Если условие верно (true), то выполняется блок инструкций программы, описанных после условия. if ( expression ) statement 1 [else statement2 ] Такой вид этого оператора вы можете найти в документации по С#. Он показывает, что работа условного оператора определяется булевым выражением (выражение, которое имеет значение true или false) в круглых скобках. Если значение этого выражения истинно, то выполняется блок инструкций statement1. Если же выражение ложно, произойдет выполнение блока инструкций statement2. Необходимо заметить, что вторая часть оператора (else statement2) может не указываться. Если инструкций в блоках statement1 или statement2 больше одной, то блок обязательно нужно брать в фигурные скобки.

using System; class Conditional {     static void Main()     {         int valueOne = 50;         //устанавливаем второе значение больше первого         int valueTwo = 5;         if ( valueOne > valueTwo )             Console.WriteLine ("valueOne: {0} больше чем valueTwo: {1}", valueOne, valueTwo);         else             Console.WriteLine("valueTwo: {0} больше или равно valueOne: {1}", valueTwo, valueOne);         //устанавливаем первое значение больше второго         valueTwo = 50;         if ( valueOne > valueTwo )         {             Console.WriteLine("valueOne: {0} больше чем valueTwo: {1}", valueOne, valueTwo);         }         //делаем значения одинаковыми         valueOne = valueTwo;         if (valueOne == valueTwo)         {             Console.WriteLine ( "valueOne и valueTwo равны: {0}=={1}", valueOne, valueTwo);         }     } }

Операторы сравнения: больше чем (>), меньше чем (<) или равно (==) достаточно понятны и просты в использовании. В этом примере первый оператор if проверяет значение переменной valueOne относительно значения переменной valueTwo. Если значение valueOne больше значения переменной valueTwo (valueOne будет равным 50, a valueTwo будет равным 5), то условие оператора (valueOne > valueTwo) является истинным и на экране появится строка: valueOne: 50 больше чем valueTwo: 5 Во втором операторе if условие осталось прежним, но значение valueTwo уже изменилось на 50. Поэтому условие оператора (valueOne > valueTwo) является ложным и результат не будет отображен на экране. Последний оператор условия проверяет равенство двух значений (valueOne == valueTwo). А поскольку перед этим мы приравняли две переменные, то результат проверки будет истинным. И на экране появится информация: valueOne и valueTwo равны: 50==50 Результатом работы программы будет следующая информация: valueTwo: 50 больше или равно valueOne: 5 valueOne и valueTwo равны: 50==50

Вложенные операторы условия

Для обработки сложных условий возможно вложение условных операторов в блоки инструкций других условных операторов. Например, вам необходимо оценить рабочую температуру воздуха в офисе и выдать сообщение пользователю. Если значение температуры больше 21° и меньше 26°, то температура находится в пределах нормы. Если же температура равна 24°, то выдается сообщение о том, что рабочий климат оптимален. Есть много способов написать такую программу. Приведем пример, иллюстрирующий один из способов, в котором используется вложенность оператора if...else:

using System; class Values {     static void Main( )     {         int temp = 25;         if (temp > 21)         {             if (temp < 26)             {                 Console.WriteLine ("Температура {0} находится в пределах нормы", temp);                 if (temp == 24)                 {                     Console.WriteLine("Рабочий климат оптимален");                 }                 else                 {                     Console .WriteLine ("Рабочий климат не оптимален\n" + "Оптимальная температура 24");                 }             }         }         Console.ReadLine();     } }

В теле программы встречается два условных оператора if...else. В первом операторе происходит проверка на попадание значения температуры в нижний предел (21°). Значение temp больше, чем 21, значит условие (temp > 21) истинное и выполнится следующая проверка. Во втором операторе происходит проверка на попадание значения температуры в верхний предел (26°). Значение temp равно 24, значит, условие (temp < 26) истинное и будет выполняться блок инструкций в фигурных скобках. Таким образом, уже выяснилось, что температура в пределах нормы, и остается узнать, является ли она оптимальной — это и реализует последний оператор if. Значение temp равно 25°, значит, условие (temp == 24) последнего оператора ложно и на экране появится сообщение: Температура 25 находится в пределах нормы Рабочий климат не оптимален. Оптимальная температура 24 Заметьте, что в условном операторе в круглых скобках стоит два знака равно: if(tempValue == 24) Если бы тут стоял один знак, то такую ошибку было бы трудно заметить. И результатом такого выражения стало бы присвоение переменной temp значения 24. В С и С ++ любое значение, отличное от нуля, определяется как булева истина (true), следовательно, условный оператор вернул бы истину, и на экране вывелась бы строка «Рабочий климат не оптимален». Таким образом, действие выполнилось бы неправильно, а побочным эффектом стало бы нежелательное изменение значения temp. С# требует, чтобы условные операторы принимали в качестве условий только булевы значения. Поэтому, если бы такая ошибка возникла, то компилятор не смог бы преобразовать выражение temp = 24 к булеву типу и выдал бы сообщение об ошибке в процессе компиляции программы. Это является достоинством по сравнению с C++, так как разрешается проблема неявных преобразований типов данных, в частности целых чисел и булева типа.