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

Теория

Типы данных. Описание переменных. Константы именованные и неименованные

Данные хранятся в памяти компьютера, но для указания на конкретную информацию очень неудобно все время записывать физические адреса ячеек. Эта проблема в языках программирования высокого уровня решена введением понятия переменной. Переменная - именованный участок памяти для хранения данных определенного типа. Значение переменной (информация в соответствующих ячейках памяти) в ходе выполнения программы может быть изменено. Константами называются величины, значение которых в ходе выполнения программы изменено быть не может. Конкретные переменные и константы представляют собой объекты уникальные и отличаются друг от друга именем.

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

Базовые типы

К базовым типам относятся:

• тип целых чисел

int -2147483648 до 2147483647Int16 -32768..32768Int32 -2млрд..2млрдInt64 -9223372036854775808 до 9223372036854775807 Byte 0..255

• тип действительных (вещественных) чисел (то есть - с дробной частью). Примеры обозначения действительного числа:

-25.0004520.244.854E-12

при вводе констант в программе требуют использования специальных суффиксов в конце.

double от ±5,0 × 10⁻³²⁴ до ±1,7 × 10³⁰⁸ double x = 3.7D; double m = 8.2;float от ±1,5 × 10⁻⁴⁵ до ±3,4 × 10³⁸ float x = 3.5F;

• символьный тип - Char

Ключевое слово char используется для объявления символа Юникода в диапазоне, указанном в следующей таблице. Символы Юникода — это 10-разрядные символы, которые используются для представления большинства известных письменных языков мира. содержит внутри себя всего один символ например 'w' или '#'

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

char c1 = 'Z'; // Буквенный символchar c2 = '\x0058'; // Шестнадцатеричный код символа

• строковый тип - string по умолчанию до 2Гбайт например " iit "

Тип данных string — это последовательность, содержащая ни одного или любое число знаков Юникода. В платформе.NET Framework string является псевдонимом для String.

string a = "hello";string b = "h";

• логический тип - bool (Может принимать два значения Истинно-true Ложно-false)

bool f = true;

Физически типы данных отличаются друг от друга количеством ячеек памяти (байтов), отводимых для хранения соответствующей переменной. Логическое же отличие проявляется в интерпретации хранящейся информации. Например, переменные типа Char и типа Byte занимают в памяти по одному байту. Однако в первом случае содержимое ячейки памяти интерпретируется как целое беззнаковое число, а во втором - как код (ASCII) символа.

Константы

Константа - это объект, значение которого известно еще до начала работы программы. Константы необходимы для оформления наглядных программ, незаменимы при использовании в тексте программы многократно повторяемых значений, удобны в случае необходимости изменения этих значений сразу во всей программе.

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

• неименованные константы (цифры и числа, символы и строки, множества);
• именованные константы;

Неименованные константы

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

• любая последовательность цифр (возможно, предваряемая знаком "-" или "+" или разбиваемая одной точкой) воспринимается компилятором как неименованная константа - число (целое или вещественное);
• любая последовательность символов, заключенная в апострофы, воспринимается как неименованная константа - строка;
• любая последовательность целых чисел, либо символов через запятую, обрамленная квадратными скобками, воспринимается как неименованная константа - множество.

Кроме того, существуют две специальные константы true и false, относящиеся к логическому типу данных. Примерами использования неименованных констант могут послужить следующие операторы:

a = -10;b = 12.075 + х;c = 'z';d = "abc" + string44;

Именованные константы

Именованные константы, как следует из их названия, должны иметь имя. Стало быть, эти имена необходимо сообщить компилятору, то есть описать в специальном разделе const.

Если не указывать тип константы, то по ее внешнему виду компилятор сам определит, к какому (базовому) типу ее отнести. Любую уже описанную константу можно использовать при объявлении других констант, переменных и типов данных. Вот несколько примеров описания нетипизированных именованных констант:

const int speedLimit = 55;const double pi = 3.14159265358979323846264338327950;

Переменные

В C# переменные объявляются с определенным типом данных и надписью. Если ранее вам приходилось работать со слабо типизированными языками, например JScript, вы привыкли использовать один тип "var" для всех переменных, то в C# необходимо указать тип переменной: int, float, byte, short или другой из более чем 20 различных типов данных. Тип указывает, помимо всего прочего, точный объем памяти, который следует выделить для хранения значения при выполнении приложения. Пример:

int i;int answer = 42;string greeting = "Hello, World!";double bigNumber = 1e100;Console.WriteLine("{0} {1} {2}", answer, greeting, bigNumber);

Идентификаторы

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

• идентификатор должен быть уникальным, то есть одним и тем же именем разные объекты не могут быть названы;
• идентификатор имеет ограничение по длине (зависит от конкретной реализации языка на компьютере);
• идентификатор может состоять только из символов латинского алфавита, цифр и знака подчеркивания ("_"), регистр букв имеет значение;
• идентификатор не может начинаться с цифры.

//допустимые именаx , s5 , Ax6 , D_f , _Fm5 , xM_5 , _128

Имена - это идентификаторы. Любая случайным образом составленная последовательность букв, цифр и знаков подчёркивания с точки зрения грамматики языка идеально подходит на роль имени любого объекта, если только она начинающаяся с буквы. Фрагмент программы, содержащий подобную переменную, будет синтаксически безупречен.

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

Желательно создавать составные осмысленные имена. При создании подобных имён в одно слово можно "втиснуть" предложение, которое в доступной форме представит информацию о типе объекта, его назначении и особенностях использования.

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

Приведем список наиболее часто встречающихся зарезервированных слов:

Abstract event new struct as explicit null switch base extern object this bool false operator throw break finally out true byte fixed override try case float params typeof catch for private uint char foreach protected ulong checked goto public unchecked class if readonly unsafe const implicit ref ushort continue in return using decimal int sbyte virtual default interface sealed volatile delegate internal short void do is sizeof while double lock stackalloc else long static enum namespace string

Class Program

{

static void Main(string[] args)

{

//здесь писать текст программы

}

}

}

Имя программы выбирается программистом самостоятельно в соответствии с правилами построения идентификаторов и совпадает с именем файла на диске.

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

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

Самым простым действием над переменной является занесение в нее величины соответствующего типа. Иногда говорят об этом, как о присвоении переменной конкретного значения. Такая команда (оператор) в общем виде выглядит следующим образом:

<Имя переменной> = <Выражение>;

Тип переменной и тип выражения должны быть совместимы. Выражение, указанное справа от знака "=", должно приводить к значению того же типа, какого и сама переменная, или типа, совместимого с переменной относительно команды присваивания. Например, переменной типа double можно присвоить значение типа Int или byte (впрочем, наоборот делать нельзя). Выражение будет сначала вычислено, затем, его результат будет положен в ячейки памяти, отведенные для переменной.

Выражение - это конструкция, возвращающая значение. Например

A = X; // переменная

B =15; // целая константа

D = Math.Sin(X); // вызов функции

E = X * Y; // произведение X на Y

F = Z / (1 - Z); // отношение Z к (1 - Z)

G =(X == 1.5); // логическое выражение

H = ! J; // отрицание логической переменной

Также можно делать множественное присваивание (во все переменные заносится самое правое значение):

a = b = c = d = 18;

Операторы ввода-вывода

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

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

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

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

<строковая переменная>=Console.ReadLine()

Для того чтобы преобразовать к нужному типу данных используем объект Convert

<переменная целого типа> = Convert.ToInt32(<строковая переменная>);<переменная действ типа> = Convert.ToDouble(<строковая переменная>); <переменная логического типа> = Convert.ToBoolean(<строковая переменная>);<переменная целого типа> = Convert.ToByte(<строковая переменная>); <переменная символьного типа> = Convert.ToChar(<строковая переменная>);<переменная целого типа> = Convert.ToInt64(<строковая переменная>);Пример

Int32 x; Double y; string s;

s = Console.ReadLine();

x = Convert.ToInt32(s);

//без промежуточной строковой переменной

y = Convert.ToDouble(Console.ReadLine());

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

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

Console.ReadKey();

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

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

Примером неплохого приглашения служит, скажем, такая строчка: Введите два вещественных числа (0.1<1000000) - длины катетов.

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

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

Для того чтобы вывести на экран какое-либо сообщение, воспользуйтесь процедурой Console.Write или Console.WriteLine

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

Пример простейшей программы

string s1;

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

s1 = Console.ReadLine();

Console.WriteLine("Мы рады вас приветствовать, {0:g}, в нашей программе", s1);

Console.ReadKey();

Во время работы этой программы на экране появится примерно следующее:

Введите ваше имя ДжонМы рады вас приветствовать, Джон, в нашей программе

Арифметические операторы

Для каждого типа данных определены действия, применимые к его значениям. Итак, поговорим теперь об операциях - стандартных действиях, разрешенных для переменных того или иного базового типа данных.

Бинарные

Оператор Операция Тип операндов Тип рез. Пример+ сложение целый, вещ. целый, вещ. A =X + Y;- вычитание целый, вещ. целый, вещ. A =Result-1;* произведение целый, вещ. целый, вещ. A =P * I;

Оператор деления (/) делит первый операнд на второй. Все числовые типы имеют предопределенные операторы деления.

При делении двух целых чисел результат всегда является целочисленным. Например, результат деления 5 на 2 — 2. Чтобы получить частное в виде рационального числа или дроби, присвойте делителю или делимому тип float или double. Чтобы явно присвоить тип, можно поместить десятичный разделитель после числа, как показано в следующем примере.

Пример 1:

Console.WriteLine(5 / 2);

Console.WriteLine(5D / 2);

Console.WriteLine(5 / 2.1);

Console.WriteLine(5.1 / 2);

Console.WriteLine(-5 / 2);

/* напечатается

2.5

2.38095238095238

2.55

-2 */

Оператор % - остаток от целочисленного деления, например A=Y % 6;
Пример 2:

Console.WriteLine(24 % 6);

Console.WriteLine(24 % 7);

Console.WriteLine(7 % 7);

Console.WriteLine(8 % 12);

/*напечатается

8 */

Унарные

Оператор Операция Тип операндов Тип рез. Пример+ (унарный) знак плюс целый, вещ. целый, вещ. A =+7;- (унарный) знак минус целый, вещ. целый, вещ. A =-X;

Оператор увеличения (++) увеличивает свой операнд на 1. Оператор увеличения может находиться как до, так и после операнда:

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

double x;

x = 1.5;

Console.WriteLine(++x); //напечатается 2.5

x = 1.5;

Console.WriteLine(x++);//напечатается 1.5

Логические операторы

Логические операции (&&, ||, !, ^) применимы только к значениям типа bool. Их результатом также служат величины типа bool.

Оператор Операция Пример! лог. отрицание F=! C;&& лог. умножение F=D && T;|| лог. сложение F=A || B;^ исключающее или F=A ^ B; Таблица истинности О п е р а ц и иОперанды || & & ^true,true true true falsetrue,false true false truefalse,true true false truefalse,false false false false !true falsefalse true

Наряду с && и ||можно использовать & и | соответственно. Отличие &от && состоит в том, что & может выполнять побитовую операцию И для целых чисел, но также работает и с логическим типом, например 5 & 3 = 1 .

Отличие | от || состоит в том, что | может выполнять побитовую операцию ИЛИ для целых чисел, но также работает и с логическим типом.

Операторы отношения

Операции отношения (==, !=, >, <, <=, >=) применимы ко всем базовым типам. Их результатами также являются значения типа bool.

Оператор Операция Тип операндов Тип рез. Пример== равно простой bool F= C == 7;!= не равно простой bool F= X != Y;< меньше простой bool F= X < Y;> больше простой bool F= L > 0;<= меньше или равно простой bool F= C <= I;>= больше или равно простой bool F= I >= 1;

Пример: Попадает ли Х в интервал от 0 до 1 или в интервал от 3 до 5

z = x > 0 && x < 1 || x > 3 && x < 5;

Стандартные функции

• Math.Abs(x) Модуль числа
• Math.Exp(x) Вычисляется е в степени х
• Math.Floor(x) Возвращает наибольшее целое число, которое меньше или равно указанному числу.
• Math.Log(x) Натуральный логарифм числа х
• Math.Log10(x) Десятичный логарифм числа х.
• Math.Pow(B,E) Возводит B в любую степень
• Math.Round(x) Округляет значение до ближайшего целого или указанного количества десятичных знаков
• Math.Truncate(x) Вычисляет целую часть числа
• Math.Ceiling(x) Возвращает наименьшее целое число, которое больше или равно заданному числу.
• Math.PI Число 3,1415...
• Math.E Число 2,7128...
• Math.Sin(x) Math.Cos(x) Синус, косинус в радианах
• Math.Atan(x) Арктангенс в радианах
• Math.Sqrt(x) Квадратный корень числа Х.

Пример: Реализовать в виде оператора следующее выражение:

R=((a+b)*Math.Sin(Math.Pow(x,2))+a*b)/

Math.Sqrt(Math.Pow(Math.Cos(x+Math.PI/2),2)-b)

Составной оператор

Этот оператор, строго говоря, оператором не является. Дело в том, что также как арифметические действия иногда бывает необходимо заключать в скобки, последовательности команд (операторов) тоже иногда требуют объединения. Это позволяют сделать так называемые операторные скобки. Формат (общий вид) составного оператора таков:

{ <Оператор 1>; //Разделителем является точка с запятой <Оператор 2>; ...... <Оператор N>;}

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

ПРИМЕР

Составить программу для вычисления значения y(x) и для некоторых x произвести вычисления

Double x, y; string s; //Описываем переменные

Console.Write("Введите x="); //Выдаём приглашение для ввода х

s = Console.ReadLine(); //Вводим строку s

x = Convert.ToDouble(s); //Преобразовываем строку в х

y = (x / 2 * Math.Exp(x) + Math.Log(1 + Math.Exp(x))) / (Math.Pow(Math.Sin(x), 2) + Math.Sin(Math.Sqrt(x)));//Вычисляем y согласно формуле

Console.Write("y(x)={0}", y); //Печатаем полученный результат

Console.ReadKey(); //Ожидаем нажатия на любую клавишу в конце программы

РАЗДЕЛ: Условные операторы

Оператор условия (if)

Условные операторы позволяют осуществить ветвление алгоритма и делают возможность выбрать для выполнения один из операторов.

Синтаксис оператора if можно представить следующим образом:

if (выражение_лог_типа) оператор; //сокращенная форма if (выражение_лог_типа>) оператор1; else оператор2; // полная форма

В выражении должен получаться результат, имеющий логический тип. Если результатом выражения является истинное значение (True), то выполняется оператор, следующий за условием в скобках. Если результатом выражения является значение False и присутствует ключевое слово else, то выполнятся оператор, следующий за ключевым словом else. Если ключевое слово else отсутствует, то никакой оператор не выполняется. В предшествующем else операторе точка с запятой указывается. В общем случае ключевое слово else связывается с ближайшим ключевым словом if, которое еще не связано с ключевым словом else. Если вместо указанных операторов1,2 требуется выполнить несколько операторов используются операторные скобки {}.

Пример 1:

if (x < 1.5)

z = z + y;

else

z = 3.4;

Пример 2:

if (a > b)

if (b > c) b = b + 1;

else b = b - 1;

else b = b - 1;

Пример 3:

if (a > b)

if (b > c) b = b + 1;

else;

else b = b - 1;

Пример4:

if (a > b)

{

if (b > c) b = b + 1;

else b = b - 1;

c = c + b + 1;

}

else

{

c = 0;

a = 1;

b = 2;

}

Пример 5:

if (a > b) ; else

if (b > c) ; else b = b + 1;

Пример 6: Даны две переменные целого типа: A и B. Если их значения не равны, то присвоить каждой переменной большее из этих значений, а если равны, то присвоить переменным нулевые значения. Вывести новые значения переменных A и B.

int A, B; string s;

Console.Write("Введите A=");

s = Console.ReadLine();

A = Convert.ToInt32(s);

Console.Write("Введите В=");

s = Console.ReadLine();

B = Convert.ToInt32(s);

if (A != B)

if (A > B) B = A;

else A = B;

else { A = 0; B = 0; }

Console.WriteLine("A={0} B={1}", A, B);

Console.ReadKey();

Пример 7: Даны a,b,c - коэффициенты квадратного уравнения. Получить корни уравнения.

Else

if (D == 0) //если дискриминант равен нулю будет всего один корень

{

x1 = -b / 2 / a;

Console.WriteLine("Единственный действительный корень x={0}", x1);

}

Switch (A)

{

case 1: Console.WriteLine("Один"); break;

case 2: Console.WriteLine("Два"); break;

case 3: Console.WriteLine("Три"); break;

case 4: Console.WriteLine("Четыре"); break;

default: Console.WriteLine("Остальные числа"); break;

}

Управление передается оператору case, совпадающему со значением оператора switch. Оператор switch может включать любое количество экземпляров case, но два оператора case не могут иметь одинаковое значение. Выполнение текста оператора начинается с выбранного оператора и продолжается до тех пор, пока оператор break не передаст управление за пределы текста case. Оператор перехода, такой как break, требуется после каждого блока case, включая последний блок, вне зависимости от того, какой из двух операторов — case или default — там использован. Язык C# (в отличие от оператора switch в языке C++) не поддерживает неявное "проваливание" от одной подписи оператора case к другой, однако есть одно исключение. Исключением является случай, когда оператор case не имеет кода.

Пример 2: Случай с неявным проваливанием

int A; string s;

Console.Write("Введите A=");

s = Console.ReadLine();

A = Convert.ToInt32(s);

Switch (A)

{

case 1: Console.WriteLine("Один"); break;

case 2: Console.WriteLine("Два"); break;

case 3: Console.WriteLine("Три"); break;

case 4: Console.WriteLine("Четыре"); break;

case 5:

case 6:

case 7:

case 8:

case 9:

case 10: Console.WriteLine("Число от 5 до 10"); break;

default: Console.WriteLine("Остальные числа"); break;

}

Console.ReadKey();

Если ни одно выражение case не совпадает со значением оператора switch, управление передается операторам, следующим за необязательной подписью default. Если подписи default нет, то управление передается за пределы оператора switch.

Пример 3:

Console.WriteLine("Какой кофе желаете: 1=Малый 2=Средний 3=Большой");

Console.Write("Выберите вариант (1 , 2 или 3): ");

string s = Console.ReadLine();

int n = Convert.ToInt32(s);

int cost = 0;

Switch (n)

{

case 1: cost = cost + 25; break;

case 2: cost = cost + 25; goto case 1;

case 3: cost = cost + 50; goto case 1;

default:

Console.WriteLine("Неправильный выбор. Пожалуйста выбирайтеt 1, 2 или 3");

break;

}

if (cost != 0)

{

Console.WriteLine("Кофе будет стоить {0} ", cost);

}

Пример

Написать программу, которая считывает введённое пользователем с клавиатуры целое число (использовать переменную целого типа) и выдает на экран дисплея сумму цифр этого числа.

Решение

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

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

РАЗДЕЛ: Операторы цикла

3.8

3.5

3.2

2.9

2.6

2.3

*/

Оператор for повторно выполняет заключенный в цикл оператор (или несколько операторов) следующим образом.

• Сначала вычисляется начальное значение параметра цикла.
• Затем, пока условие получает значение true, оператор в теле цикла выполняется и затем происходит новое вычисление параметра цикла.
• Когда условие получает значение false управление передается вне цикла.

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

for (;;) { // ... }

Инструкция break прекращает выполнение цикла и управлени передаётся за цикл. Инструкция continue выполняет пропускание операторов в теле цикла идущих ниже , осуществляется вычисление следующего параметра цикла и его дальнейшее повторение.

Пример:

double i;

for (i = 3.8; i > 2.1; i = i - 0.3)

{

Console.WriteLine(i);

if (i == 3.5) break;

}

Console.WriteLine(i);

/* напечатается

3.8

3.5

3.5 */

for (i = 2; i < 7.2; i += 0.7)

{

if (i < 4.5) continue;

Console.WriteLine(i);

}

Console.WriteLine(i);

/* напечатается

4.8

5.5

6.2

6.9

7.6 */

3.8

3.9

3.6

3.3

2.7

РАЗДЕЛ: Массивы, строки

Массивы одномерные

Хранение группы связанных элементов данных является основным требованием большинства программных приложений. Для этого существуют два основных способа: массивы и коллекции.

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

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

Индексный массив — именованный набор однотипных переменных, расположенных в памяти непосредственно друг за другом, доступ к которым осуществляется по индексу.

Одномерный массив объектов объявляется следующим образом:

тип_элемента[] имя_массива;

int[] myArray1;

Часто элементы в массиве инициализируются в это же время, как показано ниже:

int[] massiv1 = new int[12];

Здесь между разделителями [ и ] находится константное выражение, значение которого определяет размерность массива.

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

int[] myArray2 = new int[] { 7, 13, 4, 2 };

int[] myArray3 = { 5, 9, 3, 17, 9 };

Можно создавать массивы из строк:

string[] days = { "Sun", "Mon", "Tue", "Wed", "Thr", "Fri", "Sat" };

Индексация массивов начинается с нуля, поэтому номер первого элемента массива равен 0. Обращение к элементу массива осуществляется через квадратные скобки [ и ].

myArray2[2] = 17;

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

int i,N; string s;double av;

//вводим число элементов

Console.Write("Введите число элементов массива N=");

s = Console.ReadLine();

N = Convert.ToInt32(s);

//создаём массив необходимой длины

int[] massiv1 = new int[N]; av = 0;

//запускаем цикл по всем элементам массива

for (i = 0; i < N; i++)

{

//вводим i-ый элемент

Console.Write("Введите {0}-й элемент массива ",i);

s = Console.ReadLine();

massiv1[i] = Convert.ToInt32(s);

//суммируем все элементы массива

av += massiv1[i];

}

//находим среднее арифметическое

av /=N;

//запускаем цикл по всем элементам массива

for (i = 0; i < N; i++)

//печатаем только элементы больше среднего

if (massiv1[i] > av) Console.Write("{0} ", massiv1[i]);

Console.ReadKey();

Массивы можно целиком переприсваивать:

int[] massiv1 = new int[50];

Обрабока элементов массива

//обьявляем массив massiv2 без инициализации

int[] massiv2;

massiv2 = massiv1;//переприсваиваем

Чтобы узнать число элементов в массиве используют свойство Length:

N = massiv1.Length;

Оператор foreach

Оператор foreach повторяет группу внедренных операторов для каждого элемента в коллекции массива или объекта. Оператор foreach используется для итерации коллекции с целью получения необходимой информации, однако его не следует использовать для изменения содержимого коллекции во избежание непредвиденных побочных эффектов.

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

В любой точке блока foreach можно разорвать цикл с помощью ключевого слова break или перейти к следующей итерации в цикле с помощью ключевого слова continue.

Цикл foreach также может быть разорван при помощи операторов goto, return или throw.

Пример: Распечатать содержимое массива в одну колонку

int[] myarray5 = new int[] { 0, 1, 2, 3, 5, 8, 13 };

// В операторе foreach требуется указать и тип, и идентификатор

foreach (int i in myarray5)

Console.WriteLine(i);

Пример: Во введённом массиве определить минимальный элемент

int i,N; string s;

Console.Write("Введите число элементов массива N=");

s = Console.ReadLine();

N = Convert.ToInt32(s);

int[] massiv1 = new int[N];

for (i = 0; i < N; i++)

{

Console.Write("Введите {0}-й элемент массива ",i);

s = Console.ReadLine();

massiv1[i] = Convert.ToInt32(s);

}

//Временно считаем, что самый первый

//элемент и есть минимальный

int min = massiv1[0];

//запускаем цикл по всем элементам массива

//при этом очередной элемент массива

//будет помещаться во временную переменную x

foreach (int x in massiv1)

//сравниваем текущий минимум

//с очередным элементом

//и если нужно обновляем

//текущий минимум

if (x < min) min = x;

Console.WriteLine("Минимальный элемент массива равен {0}", min);

Console.ReadKey();

Переприсваивание

Строки можно целиком переприсваивать:

string s1 = "Hello";

string s2 = s1; //переприсваиваем

Объединение строк

Можно объединять строки с помощью оператора +, как показано в следующем примере:

string s1 = "orange";

string s2 = "red";

s1 += s2;

Console.WriteLine(s1); // напечатается "orangered"

Escape-знаки

Строки могут содержать escape-знаки, такие как "\n" (новая строка) и "\t" (табуляция). Пример:

string hello = "Hello\nWorld!";

Console.WriteLine(hello);

/* Напечатается

Hello

World!

*/

string s = "чтобы вставить \"кавычки\" в строку используем обратный слэш";

Console.WriteLine(s);

Если требуется добавить в строку обратную косую черту, перед ней нужно поставить еще одну обратную косую черту. Следующая строка:

string filePath = "\\\\My Documents\\";

Console.WriteLine(filePath);

/* Напечатается:

\\My Documents\

*/

Точные строки: символ @

Символ @ служит для того, чтобы конструктор строк пропускал escape-знаки и переносы строки. Следующие две строки являются идентичными:

string p1 = "\\\\My Documents\\My Files\\";

string p2 = @"\\My Documents\My Files\";

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