Еще раз о семантике присваивания

Подводя итоги рассмотрения присваивания x=e, следует отметить, что семантика присваивания далеко не столь проста, как может показаться с первого взгляда. Напомню, что деление типов на значимые и ссылочные приводит к двум семантикам присваивания. Будет ли семантика значимой или ссылочной - определяется типом левой части присваивания. Переменные значимых типов являются единоличными владельцами памяти, в которой хранятся их значения. При значимом присваивании память для хранения значений остается той же - меняются лишь сами значения, хранимые в ней. Переменные ссылочных типов (объекты) являются ссылками на реальные объекты динамической памяти. Ссылки могут разделять одну и ту же область памяти - ссылаться на один и тот же объект. Ссылочное присваивание - это операция над ссылками. В результате ссылочного присваивания ссылка начинает указывать на другой объект.

Рассмотрим объявления:

int x=3, y=5;object obj1, obj2;

Здесь объявлены четыре сущности: две переменные значимого типа и две - объектного. Значимые переменные x и y проинициализированы и имеют значения, объектные переменные obj1 и obj2 являются пустыми ссылками со значением void. Рассмотрим присваивания:

obj1 = x; obj2 = y;

Эти присваивания ссылочные (из-за типа левой части), поэтому правая часть приводится к ссылочному типу. В результате неявного преобразования - операции boxing - в динамической памяти создаются два объекта, обертывающие соответственно значения переменных x и y. Сущности obj1 и obj2 получают значения ссылок на эти объекты.

7. Лекция: Присваивание и встроенные функции

7.2

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

Кроме переменных и констант, первичным материалом для построения выражений являются функции. Большинство их в проекте будут созданы самим программистом, но не обойтись и без встроенных функций. Умение работать в среде Visual Studio .Net предполагает знание встроенных возможностей этой среды, знание возможностей каркаса Framework .Net, пространств имен, доступных при программировании на языке C#, а также соответствующих встроенных классов и функций этих классов. Продолжим знакомство с возможностями, предоставляемыми пространством имен System. Мы уже познакомились с классом Convert этого пространства и частично с классом Console. Давайте рассмотрим еще один класс - класс Math, содержащий стандартные математические функции, без которых трудно обойтись при построении многих выражений. Этот класс содержит два статических поля, задающих константы E и PI, а также 23 статических метода. Методы задают:

• тригонометрические функции - Sin, Cos, Tan;
• обратные тригонометрические функции - ASin, ACos, ATan, ATan2 (sinx, cosx);
• гиперболические функции - Tanh, Sinh, Cosh;
• экспоненту и логарифмические функции - Exp, Log, Log10;
• модуль, корень, знак - Abs, Sqrt, Sign;
• функции округления - Ceiling, Floor, Round;
• минимум, максимум, степень, остаток - Min, Max, Pow, IEEEReminder.

В особых пояснениях эти функции не нуждаются. Приведу пример:

/// <summary>/// работа с функциями класса Math/// </summary>public void MathFunctions(){ double a, b,t,t0,dt,y; string NameFunction; Console.WriteLine("Введите имя F(t)исследуемой функции a*F(b*t)" + " (sin, cos, tan, cotan)"); NameFunction = Console.ReadLine(); Console.WriteLine("Введите параметр a (double)"); 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 содержится в двух последних строчках этой процедуры. На рис. 7.1 можно видеть результаты ее работы.

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

7. Лекция: Присваивание и встроенные функции

7.3

Класс 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 дает возможность повторить при необходимости серию. Метод NextDouble создает серию случайных чисел в диапазоне [0, 1). Вызываемый в цикле метод Next с двумя параметрами создает серию случайных отрицательных целых, равномерно распределенных в диапазоне [-100, -10]. Метод NextBytes объекта repeatRnd позволяет получить при одном вызове массив случайных чисел из диапазона [0, 255]. Результаты вывода можно увидеть на рис. 7.2.

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

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

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

8.1

Операторы языка C#. Оператор присваивания. Составной оператор. Пустой оператор. Операторы выбора. If-оператор. Switch-оператор. Операторы перехода. Оператор goto. Операторы break, continue. Операторы цикла. 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;} else {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++) {;;;};

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

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

8.2

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

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

Оператор if

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

if(выражение_1) оператор_1else if(выражение_2) оператор_2...else if(выражение_K) оператор_Kelse оператор_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

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

8.3

Этот пример демонстрирует корректный стиль использования оператора 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, ни для организации безусловных переходов.

Операторы break и continue

В структурном программировании признаются полезными "переходы вперед" (но не назад), позволяющие при выполнении некоторого условия выйти из цикла, из оператора выбора, из блока. Для этой цели можно использовать оператор goto, но лучше применять специально предназначенные для этих целей операторы break и continue.

Оператор break может стоять в теле цикла или завершать case-ветвь в операторе switch. Пример его использования в операторе switch уже демонстрировался. При выполнении оператора break в теле цикла завершается выполнение самого внутреннего цикла. В теле цикла, чаще всего, оператор break помещается в одну из ветвей оператора if, проверяющего условие преждевременного завершения цикла:

public void Jumps(){ int i = 1, j=1; for(i =1; i<100; i++) { for(j = 1; j<10;j++) { if (j>=3) break; } Console.WriteLine("Выход из цикла j при j = {0}", j); if (i>=3) break; } Console.WriteLine("Выход из цикла i при i= {0}", i);}//Jumps

Оператор continue используется только в теле цикла. В отличие от оператора break, завершающего внутренний цикл, continue осуществляет переход к следующей итерации этого цикла.

Оператор return

Еще одним оператором, относящимся к группе операторов перехода, является оператор return, позволяющий завершить выполнение процедуры или функции. Его синтаксис:

return [выражение];

Для функций его присутствие и аргумент обязательны, поскольку выражение в операторе return задает значение, возвращаемое функцией.

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

Без циклов жить нельзя в программах, нет.

Оператор for

Наследованный от С++ весьма удобный оператор цикла for обобщает известную конструкцию цикла типа арифметической прогрессии. Его синтаксис:

for(инициализаторы; условие; список_выражений) оператор

Оператор, стоящий после закрывающей скобки, задает тело цикла. В большинстве случаев телом цикла является блок. Сколько раз будет выполняться тело цикла, зависит от трех управляющих элементов, заданных в скобках. Инициализаторы задают начальное значение одной или нескольких переменных, часто называемых счетчиками или просто переменными цикла. В большинстве случаев цикл for имеет один счетчик, но часто полезно иметь несколько счетчиков, что и будет продемонстрировано в следующем примере. Условие задает условие окончания цикла, соответствующее выражение при вычислении должно получать значение true или false. Список выражений, записанный через запятую, показывает, как меняются счетчики цикла на каждом шаге выполнения. Если условие цикла истинно, то выполняется тело цикла, затем изменяются значения счетчиков и снова проверяется условие. Как только условие становится ложным, цикл завершает свою работу. В цикле for тело цикла может ни разу не выполняться, если условие цикла ложно после инициализации, а может происходить зацикливание, если условие всегда остается истинным. В нормальной ситуации тело цикла выполняется конечное число раз.

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

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

В качестве примера рассмотрим классическую задачу: является ли строка текста палиндромом. Напомню, палиндромом называется симметричная строка текста, читающаяся одинаково слева направо и справа налево. Для ее решения цикл for подходит наилучшим образом: здесь используются два счетчика - один возрастающий, другой убывающий. Вот текст соответствующей процедуры:

/// <summary>/// Определение палиндромов.Демонстрация цикла for/// </summary>/// <param name="str">текст</param>/// <returns>true - если текст является палиндромом</returns>public bool Palindrom(string str){ for (int i =0,j =str.Length-1; i<j; i++,j--) if(str[i]!=str[j]) return(false); return(true);}//Palindrom

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

8.4

Циклы While

Цикл while (выражение) является универсальным видом цикла, включаемым во все языки программирования. Тело цикла выполняется до тех пор, пока остается истинным выражение while. В языке C# у этого вида цикла две модификации - с проверкой условия в начале и в конце цикла. Первая модификация имеет следующий синтаксис:

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

Эта модификация соответствует стратегии: "сначала проверь, а потом делай". В результате проверки может оказаться, что и делать ничего не нужно. Тело такого цикла может ни разу не выполняться. Конечно же, возможно и зацикливание. В нормальной ситуации каждое выполнение тела цикла - это очередной шаг к завершению цикла.

Цикл, проверяющий условие завершения в конце, соответствует стратегии: "сначала делай, а потом проверь". Тело такого цикла выполняется, по меньшей мере, один раз. Вот синтаксис этой модификации:

do операторwhile(выражение);

Приведу пример, в котором участвуют обе модификации цикла while. Во внешнем цикле проверка выполняется в конце, во внутреннем - в начале. Внешний цикл представляет собой типичный образец организации учебных программ, когда в диалоге с пользователем многократно решается некоторая задача. На каждом шаге пользователь вводит новые данные, решает задачу и анализирует полученные данные. В его власти, продолжить вычисления или нет, но хотя бы один раз решить задачу ему приходится. Внутренний цикл do while используется для решения уже известной задачи с палиндромами. Вот текст соответствующей процедуры:

/// <summary>/// Два цикла: с проверкой в конце и в начале./// Внешний цикл - образец многократно решаемой задачи./// Завершение цикла определяется в диалоге/// с пользователем./// </summary>public void Loop(){ string answer, text; do { Console.WriteLine("Введите слово"); text = Console.ReadLine(); int i =0, j = text.Length-1; while ((i<j) && (text[i] == text[j])) {i++; j--;} if (text[i] == text[j]) Console.WriteLine(text +" - это палиндром!"); else Console.WriteLine(text +" - это не палиндром!"); Console.WriteLine("Продолжим? (yes/no)"); answer = Console.ReadLine(); } while(answer =="yes");}//Loop

Цикл foreach

Новым видом цикла, не унаследованным от С++, является цикл foreach, удобный при работе с массивами, коллекциями и другими подобными контейнерами данных. Его синтаксис:

foreach(тип идентификатор in контейнер) оператор

Цикл работает в полном соответствии со своим названием - тело цикла выполняется для каждого элемента в контейнере. Тип идентификатора должен быть согласован с типом элементов, хранящихся в контейнере данных. Предполагается также, что элементы контейнера (массива, коллекции) упорядочены. На каждом шаге цикла идентификатор, задающий текущий элемент контейнера, получает значение очередного элемента в соответствии с порядком, установленным на элементах контейнера. С этим текущим элементом и выполняется тело цикла - выполняется столько раз, сколько элементов находится в контейнере. Цикл заканчивается, когда полностью перебраны все элементы контейнера.

Серьезным недостатком циклов foreach в языке C# является то, что цикл работает только на чтение, но не на запись элементов. Так что наполнять контейнер элементами приходится с помощью других операторов цикла.

В приведенном ниже примере показана работа с трехмерным массивом. Массив создается с использованием циклов типа for, а при нахождении суммы его элементов, минимального и максимального значения используется цикл foreach:

/// <summary>/// Демонстрация цикла foreach. Вычисление суммы,/// максимального и минимального элементов/// трехмерного массива, заполненного случайными числами./// </summary>public void SumMinMax(){ int [,,] arr3d = new int[10,10,10]; Random rnd = new Random(); for (int i =0; i<10; i++) for (int j =0; j<10; j++) for (int k =0; k<10; k++) arr3d[i,j,k]= rnd.Next(100); long sum =0; int min=arr3d[0,0,0], max=arr3d[0,0,0]; foreach(int item in arr3d) { sum +=item; if (item > max) max = item; else if (item < min) min = item; } Console.WriteLine("sum = {0}, min = {1}, max = {2}", sum, min, max);}//SumMinMax

9. Лекция: Процедуры и функции - методы класса

9.1

Процедуры и функции - две формы функционального модуля. Чем отличаются эти формы? Процедуры и функции - это методы класса. Описание методов (процедур и функций). Синтаксис. Атрибуты доступа. Статические и динамические методы. Формальные аргументы. Статус аргументов. Тело методов. Вызов процедур и функций. Фактические аргументы. Семантика вызова. Поля класса или аргументы метода? Поля класса или функции без аргументов? Проектирование класса Account. Функции с побочным эффектом. Перегрузка методов.