|
Ветвление программ
Для того чтобы программы на С# были более гибкими, используются операторы перехода (операторы ветвления). В С# есть два типа ветвления программы: безусловный переход и условный.
Кроме ветвлений, в С# также предусмотрены возможности циклической обработки данных, которые определяются ключевыми словами: 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++, так как разрешается проблема неявных преобразований типов данных, в частности целых чисел и булева типа.
Использование составных инструкций сравнения
Оператор if в инструкции сравнения может применять несколько инструкций, объединенных арифметическими операторами. В качестве последних используются операторы (&& — И), (|| —ИЛИ) и (! — НЕ).
Рассмотрим пример использования составных инструкций в блоке if.
using System;
class Conditions
{
static void Main(string[] args)
{
int n1 = 5;
int n2 = 0;
if ((n1 == 5) && (n2 == 5))
Console.WriteLine("Инструкция 'И' верна");
else
Console.WriteLine("Инструкция 'И' не верна");
if ((n1 == 5) || (n2 == 5))
Console.WriteLine("Инструкция 'ИЛИ' верна");
else
Console.WriteLine("Инструкция 'ИЛИ' не верна");
Console.Read();
}
}
|
В данном примере каждая инструкция if проверяет сразу два условия. Первое if условие использует оператор (&&) для проверки условия. Необходимо, чтобы сразу два условия в блоке if были истинны. Только тогда выражение будет считаться верным:
if ((n1==5) &&(n2==5))
При этом не всегда выполняются все выражения в блоке if. Если первое выражение однозначно определяет результат операции, то второе уже не проверяется. Так, если бы условие n1 == 5 было ложным, то условие n2==5 уже не проверялось бы, поскольку его результат перестал бы играть роль.
Второе выражение использует оператор (||) для проверки сложного условия:
if ((n1==5)||(n2==5))
В данном случае для верности всего выражения достаточно истинности лишь одного из условий. И тогда действует правило проверки условий до выяснения однозначности результата. То есть, если условие n1 == 5 верно, то n2 == 5 уже проверяться не будет. Это свойство может сыграть очень важную роль при разработке кода программ. Рассмотрим пример.
using System;
class Conditions
{
static void Main(string[] args)
{
const int MAX_VALUE = 3;
int n1 = 1;
int n2 = 1;
if((++n1 < MAX_VALUE) && (++n2 < MAX_VALUE))
Console.WriteLine("Операция && nl:={0} n2:={1}", n1, n2);
if((++n1 < MAX_VALUE + 1) || (++n2 < MAX_VALUE + 1))
Console.WriteLine("Операция || nl:={0} n2:={1};", n1, n2);
}
}
|
Результат работы программы будет следующий:
Операция && n1:=2 n2:=2
Операция || n1:=3 n2:=2
Заметьте, что первый оператор if нарастил значения обеих переменных, потому как осуществлялась проверка обоих условий. Второй оператор if выполнил инкремент только переменной nl. Причина в том, что условие (++n1Оператор switch как альтернатива оператору условия Достаточно часто встречаются ситуации, когда вложенные условные операторы выполняют множество проверок на совпадение значения переменной, но среди этих условных операторов только один является истинным.
if (myValue == 10) Console.WriteLine("myValue равно 10");
else
if (myValue == 20) Console.WriteLine("myValue равно 20 " );
else
if (myValue == 30} Console.WriteLine("myValue равно 30 " );
else ....
Когда вы имеете такой сложный набор условий, лучше всего воспользоваться оператором switch, который является более удобной альтернативой оператору if.
Логика оператора switch следующая: «найти значение, соответствующее переменной для сравнения, и выполнить соответствующее действие». Иными словами, он работает как оператор выбора нужного действия.
switch (выражение)
{
case константное выражение: инструкция
выражение перехода
[default:: инструкция]
|
Вы видите, что, подобно оператору условия if...else, выражение условия помещено в круглые скобки в начале оператора switch.
Внутри оператора switch есть секция выбора —case и секция действия по умолчанию —default. Секция выбора нужна для определения действия, которое будет выполняться при совпадении соответствующего константного выражения выражению в switch. В этой секции обязательно нужно указать одно или несколько действий. Секция default может в операторе switch не указываться. Она выполняется в том случае, если не совпала ни одна константная инструкция из секции выбора.
Оператор case требует обязательного указания значения для сравнения (constant-expression) — константного выражение (литеральная или символическая константа, или перечисление), а также блока инструкций (statement) и оператора прерывания действия (jump-statement).
Если результат условия совпадет с константным значением оператора case, то будет выполняться соответствующий ему блок инструкций. Как правило, в качестве оператор перехода используют оператор break, который прерывает выполнение оператора switch. Альтернативой ему может быть и другой оператор — goto, который обычно применяют для перехода в другое место программы.
Чтобы вы могли увидеть, как оператор switch заменяет сложный набор условий, приведем пример той же программы, но с использованием оператора switch:
switch ( myValue )
{
case 100:
Console.WriteLine("Переменная myValue равна 100");
break;
case 200:
Console.WriteLine("Переменная myValue равна 200");
break;
case 300: Console.WriteLine("Переменная myValue равна 300");
break;
}
|
В этом примере мы проверяем значение переменной myValue на равенство ее одному из следующих значений: 100, 200, 300. Если, например, myValue будет равно 100, то на экран выведется строка:
myValue равно 100
В языке С и C++ вы можете автоматически перейти к секции следующего case, если в конце предыдущего не стоит инструкция перехода break или goto. Таким образом, на C++ вы можете написать:
case 1: statment1;
case 2: statment2;
break;
В этом примере на C++ после выполнения statement1 будет автоматически выполняться секция statment2.
В С# это работать не будет. Автоматический переход от case 1 к следующей секции case 2 будет выполняться только в том случае, если секция case 1 окажется пустой (не будет содержать ни одной инструкции). В противном же случае перехода к выполнению case 2 не произойдет, так как в С# каждая непустая секция инструкций оператора case должна содержать в себе оператор break.
case 1: Console.WriteLine("Выражение секции 1»);
case 2:
Здесь case 1 содержит инструкцию, поэтому вы не сможете автоматически перейти к выполнению case 2. Такой код вообще не будет компилироваться. Если вы хотите перейти после выполнения case 1 к выполнению case 2, то должны явно указать это при помощи оператора goto:
case 1: Console.WriteLine("Выражение секции 1");
goto case 2
case 2:
Однако другая форма использования оператора switch позволит обойтись без инструкции goto:
case 1:
case 2:
Console.WriteLine("Выражение секций 1 и 2»);
Такой принцип работы оператора switch используется в случае, когда необходимо выполнить одно и то же действие (или часть действия) для разных значений условного оператора.
using System;
namespace SwitchStatement
{
class MyClass
{
static void Main(string[] args)
{
int user = 1;
user = Convert.ToInt32(Console.ReadLine());
switch (user)
{
case 1:
Console.WriteLine("Здравствуйте Userl");
break;
case 2:
Console.WriteLine("Здравствуйте User2");
break;
case 3:
Console.WriteLine("Здравствуйте User3");
break;
default:
Console.WriteLine("Здравствуйте новый пользователь");
break;
}
}
}
}
|
Этот пример выводит на экран сообщение с приветствием пользователя в зависимости от введенного на экране значения. Так, если вы введете число 1, то на экране появится сообщение «Здравствуйте User2».
В данном примере для выбора выражения, выводящего сообщение на экран, использовалось числовое значение {0, 1 или 2}. Если же вы введете иное значение, нежели представленное в массиве, то на экране появится сообщение «Здравствуйте новый пользователь».
Объявление переменных внутри case инструкций Рассмотрим случай, когда вам необходимо создать в программе сложную case инструкцию. Для придания программе большей читабельности создание переменных, необходимых для использования, лучше всего объявлять непосредственно перед их применением. Так, если каждый блок case использует свой набор переменных, то и объявление переменных следует делать внутри блоков case. Посмотрите на следующий код:
using System;
class Part
{
public static void Main()
{
Console.WriteLine("Выбрать:");
Console.WriteLine("1: для ввода наименования товара\n2: для ввода количества товара");
int Choice = Convert.ToInt32(Console.ReadLine());
switch (Choice)
{
case 1:
string Name;
Console.Write("Введите наименование товара ");
Name = Console.ReadLine();
break;
case 2:
int Count;
Console.Write("Введите количество товара ");
Name = Console.ReadLine();
Count = Convert.ToInt32(Console.ReadLine());
break;
default:
break;
}
}
}
|
Знатоки C++ могут без труда увидеть, что на C++ такая switch инструкция компилироваться не будет. Причина этому — объявление переменных внутри блоков case. Однако разработчики С# постарались и предусмотрели возможность создания переменных внутри case блоков. Поэтому на С# такой код является рабочим.
Switch и работа со строками
В приведенном ранее примере переменная user была целочисленного типа. Если вам необходимо использовать в качестве условия оператора switch переменную строкового типа, то вы можете сделать это следующим образом:
саsе "Светлана":
Если строк для сравнения много, то по аналогии с целочисленной переменной user используйте несколько инструкций case.
Вот пример использования строковой переменной в качестве условия оператора switch.
using System;
class MyClass
{
static void Main(string[] args)
{
string user;
Console.WriteLine("Возможные варианты:");
Console.WriteLine("User1");
Console.WriteLine("User2");
Console.WriteLine("User3");
user = Console.ReadLine();
switch (user)
{
case "User1":
Console.WriteLine("Здравствуйте пользователь один");
break;
case "User2":
Console.WriteLine("Здравствуйте пользователь два");
break;
case "User3":
Console.WriteLine("Здравствуйте пользователь три");
break;
default:
Console.WriteLine("Здравствуйте новый пользователь");
break;
}
}
}
|
В данном случае для идентификации пользователя вам необходимо применить не числовое значение, а строку. Если вы введете строку «User1», то на экране появится сообщение «Здравствуйте пользователь один».
Предыдущая стр.
Оглавление
Следующая стр.
Средняя оценка:   (4,29 - 7 голосов)
Для оценки необходимо зарегистрироваться
Только зарегистрировавшиеся пользователи могут оставлять комментарии
Комментирует Strade 01.06.2010 18:04:39
Очень похоже на С++, прям почти одинаковое всё!
Вообще курс очень хороший, учу C# с нуля, всё понятно.
Спасибо авторам сайта!
Комментирует daneel1985 21.09.2010 12:37:04
Тоже учу "с нуля", пока понятно и даже интересно - посмотрим, что там дальше :)
Комментирует vicisleo 02.11.2010 22:32:42
Ранее как и многие изучал только паскаль, но тем не менее всё очень грамотно и понятно изложено. Да и сам сайт очень приятный, понятный, а главное очень полезный.
Комментирует smokimoo 19.02.2011 17:59:21
Там где идет ветвление switch (User)
исправьте комментарий который ошибочно указывает на user 2
Комментирует zam_arcan 09.06.2011 17:02:49
Комментирует Gordon 22.01.2012 0:05:20
Во первом примере раздела "Условные переходы" в восьмой строке написано " //устанавливаем второе значение больше первого " а должно быть наоборот вот так " //устанавливаем первое значение больше второго "
|
|