Другие элементы меню 3 страница

a= double. Parse(Console.ReadLine());

Console.WriteLine("Введите параметр b (double)");

b= double. Parse(Console.ReadLine());

Console.WriteLine("Введите начальное время t0(double)");

t0= double. Parse(Console.ReadLine());

const int points = 10;

dt = 0.2;

for (int i = 1; i<=points; i++)

{

t = t0 + (i-1)* dt;

switch (NameFunction)

{

case ("sin"):

y = a*Math.Sin(b*t);

break;

case ("cos"):

y = a*Math.Cos(b*t);

break;

case ("tan"):

y = a*Math.Tan(b*t);

break;

case ("cotan"):

y = a/Math.Tan(b*t);

break;

case ("ln"):

y = a*Math.Log(b*t);

break;

case ("tanh"):

y = a*Math.Tanh(b*t);

break;

default:

y=1;

break;

}// switch

Console.WriteLine ("t = " + t + "; " +

a +"*" + NameFunction +"(" + b + "*t)= " + y + ";");

}// for

double u = 2.5, v = 1.5, p,w;

p= Math.Pow(u,v);

w = Math.IEEERemainder(u,v);

Console.WriteLine ("u = " + u + "; v= " + v +

"; power(u,v)= " + p + "; reminder(u,v)= " + w);

}// MathFunctions

Заметьте, в примерах программного кода я постепенно расширяю диапазон используемых средств. Часть из этих средств уже описана, а часть, например, оператор цикла for и оператор выбора switch будут описаны позже. Те, для кого чтение примеров вызывает затруднение, сможет вернуться к ним при повторном чтении книги.

Коротко прокомментирую этот код. В этом примере пользователь определяет, какую функцию он хочет вычислить и при каких значениях ее параметров. Некоторые параметры задаются константами и инициализированными переменными, но для большинства параметров значения вводятся пользователем. Одна из целей этого фрагмента состоит в демонстрации консольного ввода данных разного типа, при котором используется описанный ранее метод Parse.

Функция, заданная пользователем, вычисляется в операторе switch. Здесь реализован выбор из 6 стандартных функций, входящих в джентльменский набор класса Math.

Вызов еще двух функций из класса Math содержится в двух последних строчках этой процедуры. На 6.1 можно видеть результаты ее работы:

Рис. 7.1. Результаты работы процедуры MathFunctions

Класс Random и его функции

Умение генерировать случайные числа требуется во многих приложениях. Класс Random содержит все необходимые для этого средства. Класс Random имеет конструктор класса. Для того чтобы вызывать методы класса, нужно вначале создавать экземпляр класса. Этим Random отличается от класса Math, у которого все поля и методы статические, что позволяет обойтись без создания экземпляров класса Math.

Как и всякий «настоящий» класс, класс Random является наследником класса Object, а, следовательно, имеет в своем составе и методы родителя. Рассмотрим только оригинальные методы класса Random со статусом public, необходимые для генерирования последовательностей случайных чисел. Класс имеет защищенные методы, знание которых полезно при необходимости создания собственных потомков класса Random, но этим заниматься не будем.

Начнем рассмотрение с конструктора класса. Он перегружен и имеет две реализации. Одна из них позволяет генерировать неповторяющиеся при каждом запуске серии случайных чисел. Начальный элемент такой серии строится на основе текущей даты и времени, что гарантирует уникальность серии. Этот конструктор вызывается без параметров. Он описан как public Random(). Другой конструктор с параметром – public Random (int) обеспечивает важную возможность генерирования повторяющейся серии случайных чисел. Параметр конструктора используется для построения начального элемента серии, поэтому при задании одного и того же значения параметра серия будет повторяться.

Перегруженный метод public int Next() при каждом вызове возвращает положительное целое, равномерно распределенное в некотором диапазоне. Диапазон задается параметрами метода. Три реализации метода отличаются набором параметров:

public int Next() – метод без параметров выдает целые положительные числа во всем положительном диапазоне типа int;

public int Next (int max) – выдает целые положительные числа в диапазоне [0,max];

public int Next (int min, int max) – выдает целые положительные числа в диапазоне [min,max].

Метод public double NextDouble() имеет одну реализацию. При каждом вызове этого метода выдается новое случайное число, равномерно распределенное в интервале [0-1).

Еще один полезный метод класса Random позволяет при одном обращении получать целую серию случайных чисел. Метод имеет параметр – массив, который и будет заполнен случайными числами. Метод описан как public void NextBytes (byte [] buffer). Так как параметр buffer представляет массив байтов, то, естественно, генерированные случайные числа находятся в диапазоне [0, 255].

Приведу теперь пример работы со случайными числами. Как обычно, для проведения экспериментов по генерации случайных чисел я создал метод Rand в классе Testing. Вот программный код этого метода:

/// <summary>

/// Эксперименты с классом Random

/// </summary>

public void Rand()

{

const int initRnd = 77;

Random realRnd = new Random();

Random repeatRnd = new Random(initRnd);

// случайные числа в диапазоне [0,1)

Console.WriteLine("случайные числа в диапазоне[0,1)");

for (int i =1; i <= 5; i++)

{

Console.WriteLine("Число " + i + "= "

+ realRnd.NextDouble());

}

// случайные числа в диапазоне[min,max]

int min = -100, max=-10;

Console.WriteLine("случайные числа в диапазоне [" + min +

"," + max + "]");

for (int i =1; i <= 5; i++)

{

Console.WriteLine("Число " + i + "= "

+ realRnd.Next(min,max));

}

// случайный массив байтов

byte [] bar = new byte [10];

repeatRnd.NextBytes(bar);

Console.WriteLine("Массив случайных чисел в диапазоне [0, 255]");

for (int i =0; i < 10; i++)

{

Console.WriteLine("Число " + i + "= " +bar[i]);

}

}// Rand

Приведу краткий комментарий к тексту программы. Вначале создаются два объекта класса Random. У этих объектов разные конструкторы. Объект с именем realRnd позволяет генерировать неповторяющиеся серии случайных чисел. Объект repeatRnd дает возможность повторить при необходимости серию. Метод NextDoubl e создает серию случайных чисел в диапазоне [0, 1). Вызываемый в цикле метод Next с двумя параметрами создает серию случайных положительных целых, равномерно распределенных в диапазоне [-100, -10]. Метод NextBytes объекта repeatRnd позволяет получить при одном вызове массив случайных чисел из диапазона [0, 255]. Результаты вывода можно увидеть на рис. 7.2:

Рис. 7.2. Генерирование последовательностей случайных чисел в процедуре Rand

На этом заканчивается рассмотрение темы выражений языка C#.

Вариант 1

16. Операциями присваивания языка C# являются:

q +=;

q ++=;

q &=;

q &&=;

q >>=.

17. Отметьте истинные высказывания:

q все методы класса Math являются статическими;

q для вызова методов класса Random нужно предварительно создать экземпляр этого класса;

q класс Random позволяет получить только повторяющиеся серии случайных чисел.

q класс Random позволяет получить только неповторяющиеся серии случайных чисел;

q все переменные, входящие в выражение присваивания, должны быть явно инициализированы.

18. В каких фрагментах возникнет ошибка:

q sbyte sb1=1, sb2= 2, sb3 = sb1+ sb2;

q ulong ul1 =1, ul2= 2, ul3 = ul1 + ul2;

q int x; if (5 >4) x= 4;

q int x=5, y; if (x>4) y=x;

Вариант 2

19. В классе Random определен:

q перегруженный конструктор Random;

q перегруженный метод Rnd;

q перегруженный метод Next;

q перегруженный метод Bytes;

q метод NextInt;

q метод NextBytes.

20. Отметьте истинные высказывания:

q методы класса Random позволяют получать только положительные случайные числа;

q метод NextDouble позволяет получать числа типа Double в диапазоне [0,1);

q возможность получения повторяющихся серий случайных чисел определяется при вызове методов класса Random;

q при одном вызове методов класса Random можно получить целый массив случайных чисел.

21. В каких фрагментах возникнет ошибка:

q int x; x = Math.Sin(1);

q Math M1 = new Math(); int x; x = M1.Sin(1);

q int x; x = Random.Next();

q int x; Random R1 = Random(); x = R1.NexT();

Вариант 3

19. В классе Math определены методы (функции):

q Sin;

q Tg;

q Ln;

q MaxValue;

q Min.

20. Отметьте истинные высказывания:

q все методы класса Random являются статическими;

q для вызова методов класса Math нужно предварительно создать экземпляр этого класса;

q возможность получения повторяющихся серий случайных чисел определяется при вызове конструктора класса Random;

q при одном вызове методов класса Random можно получить только одно случайное число.

21. В каких фрагментах возникнет ошибка:

q float f1=1.0, f2= 2.0, f3 = f1+ f2;

q double d1 =1.0, d2= 2.0, d3 = d1 + d2;

q int u =5, v, w; if (u >0) v= 4; w=v;

q int x=5, y, z; if (x>4) y=x; else y=4; z=y;

Лекция 8. Операторы языка C#

Операторы языка C#. Оператор присваивания. Составной оператор. Пустой оператор. Операторы выбора. If-оператор. Switch-оператор. Операторы перехода. Оператор goto. Операторы break, continue. Операторы цикла. For-оператор. Циклы while. Цикл foreach.

Ключевые слова:присваивание; оператор присваивания;блок; составной оператор; пустой оператор; операторы выбора; оператор if; оператор switch; операторы перехода; оператор goto; операторы цикла; оператор for; циклы While; цикл foreach.

Операторы языка C#

Состав операторов языка C#, их синтаксис и семантика наследованы от языка С++. Как и положено, потомок частично дополнил состав, переопределил синтаксис и семантику отдельных операторов, постарался улучшить характеристики языка во благо программиста. Посмотрим, насколько это удалось языку C#.

Оператор присваивания

Как в языке С++, так и в C# присваивание формально считается операцией. Вместе с тем запись:

X= expr;

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

X1 = X2 = … = Xk = expr;

В отличие от языка C++ появление присваивания в выражениях C# хотя и допустимо, но практически не встречается. Например, запись:

if(x = expr)...

часто используемая в С++, в языке C# в большинстве случаев будет воспринята как ошибка еще на этапе компиляции.

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

Блок или составной оператор

С помощью фигурных скобок несколько операторов языка, возможно перемежаемых объявлениями, можно объединить в единую синтаксическую конструкцию, называемую блоком или составным оператором:

{

оператор_1

…

оператор_N

}

В языках программирования нет общепринятой точки зрения на использование символа точки с запятой при записи последовательности операторов. Есть три различных подхода и их вариации. Категорические противники точек с запятой считают, что каждый оператор должен записываться на отдельной строке (для длинных операторов определяются правила переноса). В этом случае точки с запятой (или другие аналогичные разделители не нужны). Горячие поклонники точек с запятой (к ним относятся языки С++ и C#) считают, что точкой с запятой должен оканчиваться каждый оператор. В результате в операторе if перед else появляется точка с запятой. Третьи полагают, что точка с запятой играет роль разделителя операторов, поэтому перед else точки с запятой не должно быть. В выше приведенной записи блока, следуя синтаксису C#, каждый из операторов заканчивается символом точка с запятой. Но, заметьте, блок не заканчивается этим символом!

Синтаксически блок воспринимается как единичный оператор и может всюду использоваться в конструкциях, где синтаксис требует одного оператора. Тело цикла, ветви оператора if, как правило, представляются блоком. Приведу достаточно формальный и слегка запутанный пример, где тело процедуры представлено блоком, в котором есть встроенные блоки, задающие тело оператора цикла for и тела ветвей оператора if:

/// <summary>

/// демонстрация блоков (составных операторов)

/// </summary>

public void Block()

{

int limit = 100;

int x = 120, y = 50;

int sum1 =0, sum2=0;

for (int i = 0; i< 11; i++)

{

int step = Math.Abs(limit -x)/10;

if (x > limit)

{x -= step; y += step;}

{x += step; y -= step;}

sum1 += x;

sum2 +=y;

}

// limit = step; //переменная step перестала существовать

// limit = i; // переменная i перестала существовать

Console.WriteLine("x= {0}, y= {1}, sum1 ={2}, sum2 = {3}",

x,y,sum1,sum2);

}

Заметьте, здесь в тело основного блока вложен блок, задающий тело цикла, в котором объявлены две локальные переменные – i и step. В свою очередь, в тело цикла вложены блоки, связанные с ветвями then и else оператора if. Закомментированные операторы, стоящие сразу за окончанием цикла, напоминают, что соответствующие локальные переменные, определенные в блоке, перестают существовать по завершении блока.

Приведенная процедура Block является методом класса Testing, входящего в проект Statements, спроектированного для работы с примерами этой лекции. Вот описание полей и конструктора класса Testing:

/// <summary>

/// Класс Testing - тестирующий класс.

/// Представляет набор скалярных переменных

/// и методов, тестирующих работу с операторами,

/// процедурами и функциями C#.

/// </summary>

public class Testing

{

public Testing(string name, int age)

{

this. age = age;

this. name = name;

}

//поля класса

public string name;

public int age;

private int period;

private string status;

Пустой оператор

Пустой оператор – это пусто, завершаемое точкой с запятой. Иногда полезно рассматривать отсутствие операторов как существующий пустой оператор. Синтаксически допустимо ставить лишние точки с запятой, полагая, что вставляются пустые операторы. Например, синтаксически допустима следующая конструкция:

for (int j=1; j<5; j++)

{;;;};

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

Операторы выбора

Как в С++ и других языках программирования, в языке C# для выбора одной из нескольких возможностей используются две конструкции – if и switch. Первую из них обычно называют альтернативным выбором, вторую – разбором случаев.

Оператор if

Начнем с синтаксиса оператора if:

if (выражение_1)оператор_1

else if (выражение_2)оператор_2

…

else if (выражение_K)оператор_K

else оператор_N

Какие особенности синтаксиса следует отметить? Выражения if должны заключаться в круглые скобки и быть булевского типа. Точнее выражения должны давать значения true или false. Напомню, арифметический тип не имеет явных или неявных преобразований к булевскому типу. Следуя синтаксису языка С++, then-ветвь оператора следует сразу за круглой скобкой без ключевого слова then, типичного для большинства языков программирования. Каждый из операторов может быть блоком, в частности if-оператором. Поэтому возможна и такая конструкция:

if (выражение1) if (выражение2) if (выражение3) …

Ветви else if, позволяющие организовать выбор из многих возможностей, могут отсутствовать. Может быть опущена и заключительная else-ветвь. В этом случае краткая форма оператора if задает альтернативный выбор – делать или не делать – выполнять или не выполнять then-оператор.

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

Оператор switch

Частным, но важным случаем выбора из нескольких вариантов является ситуация, при которой выбор варианта определяется значениями некоторого выражения. Соответствующий оператор C#, наследованный от C++, но с небольшими изменениями в синтаксисе, называется оператором switch. Вот его синтаксис:

switch (выражение)

{

case константное_выражение_1: [операторы_1 оператор_перехода_1]

…

case константное_выражение_K: [операторы_K оператор_перехода_K]

[ default: операторы_N оператор_перехода_N]

}

Ветвь default может отсутствовать. Заметьте, по синтаксису допустимо, чтобы после двоеточия следовала пустая последовательность операторов, а не последовательность, заканчивающаяся оператором перехода. Константные выражения в case должны иметь тот же тип, что и switch-выражение.

Семантика оператора switch чуть запутана. Вначале вычисляется значение switch-выражения. Затем оно поочередно в порядке следования case сравнивается на совпадение с константными выражениями. Как только достигнуто совпадение, выполняется соответствующая последовательность операторов case-ветви. Поскольку последний оператор этой последовательности является оператором перехода (чаще всего это оператор break), то обычно он завершает выполнение оператора switch. Использование операторов перехода – это плохая идея. Таким оператором может быть оператор goto, передающий управление другой case-ветви, которая в свою очередь может передать управление еще куда-нибудь, получая блюдо «спагетти» вместо хорошо структурированной последовательности операторов. Семантика осложняется еще и тем, что case-ветвь может быть пустой последовательностью операторов. Тогда в случае совпадения константного выражения этой ветви со значением switch-выражения будет выполняться первая непустая последовательность очередной case-ветви. Если значение switch-выражения не совпадает ни с одним константным выражением, то выполняется последовательность операторов ветви default, если же таковой ветви нет, то оператор switch эквивалентен пустому оператору.

Полагаю, что оператор switch –это самый неудачный оператор языка C# как с точки зрения синтаксиса, так и семантики. Неудачный синтаксис порождает запутанную семантику, являющуюся источником плохого стиля программирования. Понять, почему авторов постигла неудача, можно, оправдать – нет. Дело в том, что оператор наследован от С++, где семантика и синтаксис этого оператора еще хуже. В языке C# синтаксически каждая case-ветвь должна заканчиваться оператором перехода (забудем на минуту о пустой последовательности), иначе возникнет ошибка периода компиляции. В языке С++ это правило не является синтаксически обязательным, хотя на практике применяется та же конструкция с конечным оператором break. При его отсутствии управление «проваливается» в следующую case-ветвь. Конечно, профессионал может с успехом использовать этот трюк, но в целом ни к чему хорошему это не приводит. Борясь с этим, в C# потребовали обязательного включения оператора перехода, завершающего ветвь. Гораздо лучше было бы, если бы последним оператором мог быть только оператор break, писать его было бы не нужно, и семантика стала бы прозрачной – при совпадении значений двух выражений выполняются операторы соответствующей case-ветви, при завершении которой завершается и оператор switch.

Еще одна неудача в синтаксической конструкции switch связана с существенным ограничением, накладываемым на case-выражения, которые могут быть только константным выражением. Уж если изменять оператор, то гораздо лучше было бы использовать синтаксис и семантику Visual Basic, где в case-выражениях допускается список, каждое из выражений которого может задавать диапазон значений.

Разбор случаев – это часто встречающаяся ситуация в самых разных задачах. Используя оператор switch, помните о недостатках его синтаксиса, используйте его в правильном стиле. Заканчивайте каждую case-ветвь оператором break, но не применяйте goto.

Когда разбор случаев предполагает проверку попадания в некоторый диапазон значений, приходится прибегать к оператору if для формирования специальной переменной. Этот прием демонстрируется в следующем примере, где идет работа над данными нашего класса Testing:

/// <summary>

/// Определяет период в зависимости от возраста - age

/// Использование ветвящегося оператора if

/// </summary>

public void SetPeriod()

{

if ((age > 0)&& (age <7))period=1;

else if ((age >= 7)&& (age <17))period=2;

else if ((age >= 17)&& (age <22))period=3;

else if ((age >= 22)&& (age <27))period=4;

else if ((age >= 27)&& (age <37))period=5;

else period =6;

}

Этот пример демонстрирует применение ветвящегося оператора if. С содержательной точки зрения он интересен тем, что в поля класса пришлось ввести специальную переменную period, позволяющую в дальнейшем использовать разбор случаев в зависимости от периода жизни:

/// <summary>

/// Определяет статус в зависимости от периода - period

/// Использование разбора случаев - оператора Switch

/// </summary>

public void SetStatus()

{

switch (period)

{

case 1:

status = "child";

break;

case 2:

status = "schoolboy";

break;

case 3:

status = "student";

break;

case 4:

status = "junior researcher";

break;

case 5:

status = "senior researcher";

break;

case 6:

status = "professor";

break;

default:

status = "не определен";

break;

}

Console.WriteLine("Имя = {0}, Возраст = {1}, Статус = {2}",

name, age, status);

}// SetStatus

Этот пример демонстрирует корректный стиль использования оператора switch. В следующем примере показана роль пустых последовательностей операторов case-ветвей для организации списка выражений одного варианта:

/// <summary>

/// Разбор случаев с использованием списков выражений

/// </summary>

/// <param name="operation"> операция над аргументами </param>

/// <param name="arg1"> первый аргумент бинарной операции </param>

/// <param name="arg2"> второй аргумент бинарной операции </param>

/// <param name="result"> результат бинарной операции </param>

public void ExprResult(string operation, int arg1, int arg2,

ref int result)

{

switch (operation)

{

case "+":

case "Plus":

case "Плюс":

result = arg1 + arg2;

break;

case "-":

case "Minus":

case "Минус":

result = arg1 - arg2;

break;

case "*":

case "Mult":

case "Умножить":

result = arg1 * arg2;

break;

case "/":

case "Divide":

case "Div":

case "разделить":

case "Делить":

result = arg1 / arg2;

break;

default:

result = 0;

Console.WriteLine("Операция не определена");

break;

}

Console.WriteLine ("{0} ({1}, {2}) = {3}",

operation, arg1, arg2, result);

}// ExprResult

Операторы перехода

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

Оператор goto

Оператор goto имеет простой синтаксис и семантику:

goto [метка| case константное_выражение| default ];

Все операторы языка C# могут иметь метку – уникальный идентификатор, предшествующий оператору и отделенный от него символом двоеточия. Передача управления помеченному оператору – это классическое использование оператора goto. Два других способа использования goto – это передача управления в case или default-ветвь – используются в операторе switch, о чем шла речь выше.

«О вреде оператора goto» и о том, как можно обойтись без него, писал еще Эдсгар Дейкстра при обосновании принципов структурного программирования.

Я уже многие годы не применяю этот оператор и считаю, что хороший стиль программирования не предполагает использования этого оператора в C# ни в каком из своих вариантов – ни в операторе switch, ни для организации безусловных переходов.

Дата добавления: 2014-12-25