Алгоритмы и структуры данных. Класс. Объект. Свойства и методы презентация

Синтаксис ООЯП С#
Лекция 1 (часть 2)

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

Для создания проекта следует после запуска Visual Studio.NET в главном меню выбрать команду File? New Project….

Главное меню
Панель инструментов
Окно управления проектом
Окно редактора

Заготовка консольной программы
using System;
namespace ConsoleApplication1
{
class Class1
{
static void Main(string[] args)
{
// // TODO: Add code to start application here
//
}
}
}
Программа на C# состоит из классов, внутри которого описывают методы и данные. описывают методы и данные. Переменные, описанные непосредственно внутри класса, называются полями класса.
Им автоматически присваивается так называемое «значение по умолчанию» —как правило, это 0 соответствующего типа.
Переменные, описанные внутри метода класса, называются локальными переменными.
Их инициализация возлагается на программиста.

Пространство имен
Классы логически сгруппированы в так называемые пространства имен, которые служат для упорядочивания имен классов и предотвращения их конфликтов: в разных пространствах имена могут совпадать. Пространства имен могут быть вложенными.
Полное имя класса состоит из имени самого класса и имени пространства имен в котором данный класс находится, при написании соединяясь точкой.
System. ConsoleApplication1. Class1

Состав языка
Символы:
буквы: A-Z, a-z, _, буквы нац. алфавитов
цифры: 0-9, A-F
спец. символы: +, *, {, …
пробельные символы
Лексемы:
константы 2 0.11 “Вася”
имена Vasia a _11
ключевые слова double do if
знаки операций + - =
разделители ; [ ] ,
Выражения
выражение - правило вычисления значения: a + b
Операторы
исполняемые: c = a + b;
описания: double a, b;

Имена (идентификаторы)
имя должно начинаться с буквы или _;
имя должно содержать только буквы, знак подчеркивания и цифры;
прописные и строчные буквы различаются;
длина имени практически не ограничена.
имена не должны совпадать с ключевыми словами, однако допускается: @if, @float…
в именах можно использовать управляющие последовательности Unicode
Примеры правильных имен:
Vasia, Вася, _13, \u00F2\u01DD, @while.
Примеры неправильных имен:
2late, Big gig, Б#г

Нотации
Понятные и согласованные между собой имена — основа хорошего стиля. Существует несколько нотаций — соглашений о правилах создания имен.
В C# для именования различных видов программных объектов чаще всего используются две нотации:
Нотация Паскаля - каждое слово начинается с прописной буквы:
MaxLength, MyFuzzyShooshpanchik
Camel notation - с прописной буквы начинается каждое слово, составляющее идентификатор, кроме первого:
maxLength, myFuzzyShooshpanchik

Ключевые слова, знаки операций, разделители
Ключевые слова — идентификаторы, имеющие специальное значение для компилятора. Их можно использовать только в том смысле, в котором они определены.
Например, для оператора перехода определено слово goto.
Знак операции — один или более символов, определяющих действие над операндами. Внутри знака операции пробелы не допускаются.
Например, сложение +, деление /, сложное присваивание %=.
Операции делятся на унарные (с одним операндом), бинарные (с двумя) и тернарную (с тремя).
Разделители используются для разделения или, наоборот, группирования элементов. Примеры разделителей: скобки, точка, запятая.

Типы данных
Тип данных определяет:
внутреннее представление данных => множество их возможных значений
допустимые действия над данными => операции и функции

Хранение в памяти величин значимого и ссылочного типа
Хранятся в стеке.
Стек-это область памяти, которая активно используется процессором.
Хранятся в управляемой куче (области оперативной памяти).

Значимые типы

Переменные
Переменная — это величина, которая во время работы программы может изменять свое значение.
Все переменные, используемые в программе, должны быть описаны.
Для каждой переменной задается ее имя и тип:
int number;
float x, y;
char option;
Тип переменной выбирается исходя из диапазона и требуемой точности представления данных.

ОБЛАСТЬ ДЕЙСТВИЯ И ВРЕМЯ ЖИЗНИ ПЕРЕМЕННЫХ
Переменные описываются внутри какого-л. блока (класса, метода или блока внутри метода)
Блок — это код, заключенный в фигурные скобки. Основное назначение блока — группировка операторов.
Переменные, описанные непосредственно внутри класса, называются полями класса.
Переменные, описанные внутри метода класса, называются локальными переменными.
Область действия переменной - область программы, где можно использовать переменную.
Область действия переменной начинается в точке ее описания и длится до конца блока, внутри которого она описана.
Время жизни: переменные создаются при входе в их область действия (блок) и уничтожаются при выходе.

Инициализация переменных
При объявлении можно присвоить переменной начальное значение (инициализировать).
int number = 100; float x = 0.02;
char option = ’ю’;
При инициализации можно использовать не только константы, но и выражения — главное, чтобы на момент описания они были вычислимыми, например:
int b = 1, a = 100;
int x = b * a + 25;
Инициализация локальных переменных возлагается на программиста. Рекомендуется всегда инициализировать переменные при описании.

Вместо значений констант можно (и нужно!) использовать в программе их имена.
Это облегчает читабельность программы и внесение в нее изменений:
const float weight = 61.5;
const int n = 10;
const float g = 9.8;
Именованные константы

Выражения
Выражение — правило вычисления значения.
В выражении участвуют операнды, объединенные знаками операций.
Операндами выражения могут быть константы, переменные и вызовы функций.
Операции выполняются в соответствии с приоритетами.
Для изменения порядка выполнения операций используются круглые скобки.
Результатом выражения всегда является значение определенного типа, который определяется типами операндов.
Величины, участвующие в выражении, должны быть совместимых типов.
t + Math.Sin(x)/2 * x
результат имеет вещественный тип
a <= b + 2
результат имеет логический тип
x > 0 && y < 0
результат имеет логический тип

Приоритеты операций C#
Первичные (), [], ++, --, new, …
Унарные ~, !, ++, --, -, …
Типа умножения (мультипликативные) *, /, %
Типа сложения (аддитивные) +, -
Сдвига <<, >>
Отношения и проверки типа <, >, is, …
Проверки на равенство ==, !=
Поразрядные логические &, ^, |
Условные логические &&, ||
Условная ?:
Присваивания =, *=, /=,…

Тип результата выражения
Если операнды, входящие в выражение, одного типа, и операция для этого типа определена, то результат выражения будет иметь тот же тип.
Если операнды разного типа и (или) операция для этого типа не определена, перед вычислениями автоматически выполняется преобразование типа по правилам, обеспечивающим приведение более коротких типов к более длинным для сохранения значимости и точности.
Автоматическое (неявное) преобразование возможно не всегда, а только если при этом не может случиться потеря значимости.
Если неявного преобразования из одного типа в другой не существует, программист может задать явное преобразование типа с помощью операции:
(тип) x.
Convert.ToInt16(x)
Int16.Parse(строковая_переменная);

Неявные арифметические преобразования типов в C#

Вывод сообщения на экран
Console.Write(“текст сообщения") – вывод сообщения на экран.
Console.WriteLine(“текст сообщения") – вывод сообщения на экран и перенос каретки на следующую строку.
Console.WriteLine(“текст сообщения”+ x ) – вывод на экран сообщения, заключенного в кавычки и значения переменной x и перенос каретки на следующую строку.
Console.WriteLine(“текст сообщения {0} {1}”, x,y ) – вывод на экран сообщения, заключенного в кавычки и значения переменной x и y перенос курсора на следующую строку.
using System;
namespace ConsoleApplication1
{
class Program
{
static void Main(string[] args)
{
int x = 6;
double y=0.5;
Console.WriteLine("... идет работа консоли");
Console.WriteLine("значение переменой х= " + x + ", значение переменной у=" + y);
Console.WriteLine("значение переменой х= {0}, значение переменной у={1}", x,y);
Console.ReadKey();
}
}
}

Существуют две формы рассматриваемых операций: префиксная и постфиксная.
Если операторы записаны после переменной (х++ или х--) - это постфиксная форма.
При этом последовательно происходят следующие действия:
старое значение переменной сохраняется для использования в дальнейшем выражении, в котором встретилась эта переменная;
и только после этого ее значение сразу же изменяется на 1.
Если операторы записаны перед переменной (++х или –х) -это префиксная форма.
При этом последовательность действий такая:
вначале переменная изменяется на 1;
и только после этого используется в выражении.
Инкремент (++) и декремент (--)

Инкремент и декремент
using System;
namespace ConsoleApplication1
{ class Program
{ static void Main(string[] args) {
int x=1,y=1;
Console.WriteLine("x={0}, y= {1}", x, x * y + (x++)+x*y);
x = 1; y = 1;
Console.WriteLine("x={0}, y= {1}", x, x * y + (++x) + x * y);
Console.ReadLine();
}
}
}
using System;
namespace CA1
{ class C1
{ static void Main()
{ int x = 3, y = 3;
Console.Write( "Значение префиксного выражения: " );
Console.WriteLine( ++x );
Console.Write( "Значение х после приращения: " );
Console.WriteLine( x );
Console.Write( "Значение постфиксного выражения: " );
Console.WriteLine( y++ );
Console.Write( "Значение у после приращения: " );
Console.WriteLine( y );
}}}
Результат работы программы:
Значение префиксного выражения: 4
Значение х после приращения: 4
Значение постфиксного выражения: 3
Значение у после приращения: 4

Операция присваивания
Сложное присваивание:
x += 0.5; соответствует x = x + 0.5;
x *= 0.5; соответствует x = x * 0.5;
a %= 3; соответствует a = a % 3;
a <<= 2; соответствует a = a << 2;
Присваивание – это замена старого значения переменной на новое. Старое значение стирается бесследно.
Операция может использоваться в программе как законченный оператор.
переменная = выражение
a = b + c;
x = 1;
x = x + 0.5;

Операция умножения и деления
using System;
namespace ConsoleApplication1
{ class Class1
{ static void Main()
{ int x = 11, y = 4;
float z = 4;
Console.WriteLine( z * y ); // Результат 16
Console.WriteLine( x / y ); // Результат 2 (целочисленное деление)
Console.WriteLine( x / z ); // Результат 2,75
Console.WriteLine( x % y ); // Результат 3 (остаток)
}}}

Операции сдвига (<< и >>) применяются к целочисленным операндам. Они сдвигают двоичное представление первого операнда влево или вправо на количество двоичных разрядов, заданное вторым операндом.
При сдвиге влево (<<) освободившиеся разряды обнуляются. При сдвиге вправо (>>) освободившиеся биты заполняются нулями, если первый операнд беззнакового типа, и знаковым разрядом в противном случае.
Стандартные операции сдвига определены для типов int, uint, long и ulong.
©Павловская Т.А. (СПбГУ ИТМО)
ОПЕРАЦИИ СДВИГА

using System;
namespace ConsoleApplication1
{ class Class1
{ static void Main()
{
byte a = 3, b = 9;
sbyte c = 9, d = -9;
Console.WriteLine( a << 1 ); // Результат 6
Console.WriteLine( a << 2 ); // Результат 12
Console.WriteLine( b >> 1 ); // Результат 4
Console.WriteLine( c >> 1 ); // Результат 4
Console.WriteLine( d >> 1 ); // Результат -5
}
}
}
ПРИМЕР ОПЕРАЦИИ СДВИГА

Операции отношения и проверки на равенство
Операции отношения (<, <=, >, >=, ==, !=) сравнивают первый операнд со вторым.
Операнды должны быть арифметического типа.
Результат операции — логического типа, равен true или false.
x == y -- true, если x равно y, иначе false
x != y -- true, если x не равно y, иначе false
x < y -- true, если x меньше y, иначе false
x > y -- true, если x больше y, иначе false
x <= y -- true, если x меньше или равно y, иначе false
x >= y -- true, если x больше или равно y, иначе false

Условные логические операции
using System;
namespace ConsoleApplication1
{ class Class1
{ static void Main()
{ Console.WriteLine( true && true ); // Результат true
Console.WriteLine( true && false ); // Результат false
Console.WriteLine( true || true ); // Результат true
Console.WriteLine( true || false ); // Результат true
}
}
}

Условная операция
операнд_1 ? операнд_2 : операнд_3
Первый операнд — выражение, для которого существует неявное преобразование к логическому типу.
Если результат вычисления первого операнда равен true, то результатом будет значение второго операнда, иначе — третьего операнда.
using System;
namespace ConsoleApplication1
{ class Class1
{ static void Main()
{
int a = 11, b = 4;
int max = b > a ? b : a;
Console.WriteLine( max ); // Результат 11
}}}

Ввод данных с консоли
using System;
namespace A
{ class Class1
{ static void Main()
{ string s = Console.ReadLine(); // ввод строки
char c = (char)Console.Read(); // ввод символа
Console.ReadLine();
string buf; // буфер для ввода чисел
buf = Console.ReadLine();
int i = Convert.ToInt32( buf ); // преобразование в целое
buf = Console.ReadLine();
double x = Convert.ToDouble( buf ); // преобразование в вещ.
buf = Console.ReadLine();
double y = double.Parse( buf ); // преобразование в вещ.
}
}
}

Математические функции: класс Math

УПРАВЛЯЮЩИЕ ОПЕРАТОРЫ ЯЗЫКА ВЫСОКОГО УРОВНЯ
Реализуют логику выполнения программы:
следование
ветвление
цикл
передача управления

Блок (составной оператор)
Блок — это последовательность операторов, заключенная в операторные скобки:
begin end
{ }
Блок воспринимается компилятором как один оператор и может использоваться всюду, где синтаксис требует одного оператора, а алгоритм — нескольких.
Блок может содержать один оператор или быть пустым.

Оператор «выражение»
Любое выражение, завершающееся точкой с запятой, рассматривается как оператор, выполнение которого заключается в вычислении выражения.
i++; // выполняется операция инкремента
a *= b + c; // выполняется умножение с присваиванием
fun( i, k ); // выполняется вызов функции
; называют пустым оператором.

Операторы ветвления:
развилка (if)
переключатель (switch)

Условный оператор if
if ( a < 0 ) b = 1;
if ( a < b && (a > d || a = = 0)) ++b;
else { b *= a; a = 0; }
if ( a < b ) if ( a < c ) m = a;
else m = c;
else if ( b < c ) m = b; else m = c;
if ( выражение ) оператор_1; [else оператор_2;]

Пример
if ( x < -2 ) y = 0;
if ( x >= -2 && x < -1 ) y = -x - 2;
if ( x >= -1 && x < 1 ) y = x;
if ( x >= 1 && x < 2 ) y = -x + 2;
if ( x >= 2 ) y = 0;
if ( x <= -2 ) y = 0;
else if ( x < -1 ) y = -x - 2;
else if ( x < 1 ) y = x;
else if ( x < 2 ) y = -x + 2;
else y = 0;
y = 0;
if ( x > -2 ) y = -x - 2;
if ( x > -1 ) y = x;
if ( x > 1 ) y = -x + 2;
if ( x > 2 ) y = 0;

Оператор выбора switch
switch ( выражение )
{
case константное_выражение_1: [ список_операторов_1 ]
case константное_выражение_2: [ список_операторов_2 ]
..
case константное_выражение_n: [ список_операторов_n ]
[ default: операторы ]
}

Пример: Калькулятор на четыре действия
using System; namespace ConsoleApplication1
{ class Class1 { static void Main() {
string buf; double a, b, res;
Console.WriteLine( "Введите 1й операнд:" );
buf = Console.ReadLine(); a = double.Parse( buf);
Console.WriteLine( "Введите знак операции" );
char op = (char)Console.Read(); Console.ReadLine();
Console.WriteLine( "Введите 2й операнд:" );
buf = Console.ReadLine(); b = double.Parse( buf);
bool ok = true;
switch (op)
{
case '+' : res = a + b; break;
case '-' : res = a - b; break;
case '*' : res = a * b; break;
case '/' : res = a / b; break;
default : res = double.NaN; ok = false; break;
}
if (ok) Console.WriteLine( "Результат: " + res );
else Console.WriteLine( "Недопустимая операция" );
}}}

Структура оператора цикла
Усл-е
Начальные
значения
Тело
цикла
Модиф-я параметра

Цикл с предусловием
while ( выражение ) оператор
using System;
namespace ConsoleApplication1
{ class Class1
{ static void Main()
{
double Xn = -2, Xk = 12, dX = 2, t = 2, y;
Console.WriteLine( "| x | y |" );
double x = Xn;
while ( x <= Xk )
{
y = t * x;
Console.WriteLine( "| {0,9} | {1,9} |", x, y );
x += dX;
}
}
}
}
y = t⋅x

Цикл с постусловием
do оператор while выражение;
using System;
namespace ConsoleApplication1
{ class Class1
{ static void Main()
{
char answer;
do
{
Console.WriteLine( "Купи слоника, а?" );
answer = (char) Console.Read();
Console.ReadLine();
} while ( answer != 'y' );
}
}
}

Цикл с параметром
for ( инициализация; выражение; модификации ) оператор;
int s = 0;
for ( int i = 1; i <= 100; i++ ) s += i;

Пример цикла с параметром
using System;
namespace ConsoleApplication1
{ class Class1
{ static void Main()
{ double Xn = -2, Xk = 12, dX = 2, t = 2, y;
Console.WriteLine( "| x | y |";
for ( double x = Xn; x <= Xk; x += dX )
{
y = t * x;
Console.WriteLine( "| {0,9} | {1,9} |", x, y );
}
}
}
}

Рекомендации по написанию циклов
не забывать о том, что если в теле циклов while и for требуется выполнить более одного оператора, нужно заключать их в блок;
убедиться, что всем переменным, встречающимся в правой части операторов присваивания в теле цикла, до этого присвоены значения, а также возможно ли выполнение других операторов;
проверить, изменяется ли в теле цикла хотя бы одна переменная, входящая в условие продолжения цикла;
предусматривать аварийный выход из итеративного цикла по достижению некоторого предельно допустимого количества итераций.

Передача управления
оператор break — завершает выполнение цикла, внутри которого записан;
оператор continue — выполняет переход к следующей итерации цикла;
оператор return — выполняет выход из функции, внутри которой он записан;
оператор throw — генерирует исключительную ситуацию;
оператор goto — выполняет безусловную передачу управления.

using System;
namespace ConsoleApplication43
{ class Program
{
static void Main(string[] args)
{
int me = 8;
for (int i = 0; i < 9; i++)
{
if (me % 2 == 0)
{
Console.WriteLine(me);
me += 1;
}
else
{
me += 1;
break;
} }
Console.ReadLine();
} } }
using System;
namespace ConsoleApplication43
{ class Program
{
static void Main(string[] args)
{
int me = 8;
for (int i = 0; i < 9; i++)
{
if (me % 2 == 0)
{
Console.WriteLine(me);
me += 1;
}
else
{
me += 1;
continue;
} }
Console.ReadLine();
} } }
Оператор break
ОПЕРАТОР CONTINUE

Оператор goto
завершает выполнение функции и передает управление в точку ее вызова:
return [ выражение ];
Оператор goto
goto метка;
В теле той же функции должна присутствовать ровно одна конструкция вида:
метка: оператор;
goto case константное_выражение;
goto default;

using System;
namespace ConsoleApplication43
{ class Program {
static void Main(string[] args)
{
do
{
Console.WriteLine("введите слово или символ 'x' для завершения работы приложения");
str = Console.ReadLine();
Console.WriteLine("вы ввели следующую последовательность символов: {0}", str);
if (str == "x") goto Finish;
}
while (true);
Finish:
Console.WriteLine("Нажмите клавишу ENTER, чтобы завершить работу приложения");
Console.ReadLine();
}
}
}
using System;
namespace ConsoleApplication43
{ class Program {
static void Main(string[] args)
{ Console.WriteLine("Coffee sizes: 1=Small 2=Medium 3=Large");
Console.Write("Please enter your selection: ");
string s = Console.ReadLine();
int n = int.Parse(s); int cost = 0;
switch (n)
{ case 1:
cost += 25;
break;
case 2:
cost += 25;
goto case 1;
case 3:
cost += 50;
goto case 1;
default:
Console.WriteLine("Invalid selection.");
break;
}
if (cost != 0) Console.WriteLine("Please insert {0} cents.", cost);
Console.WriteLine("Thank you for your business.");
Console.WriteLine("Press any key to exit.");
Console.ReadKey(); } } }
Оператор goto: 2 варианта использования

ОБРАБОТКА ИСКЛЮЧЕНИЙ
Исключительная ситуация, или исключение — это возникновение непредвиденного или аварийного события, которое может порождаться некорректным использованием аппаратуры.
Например, это деление на ноль или обращение по несуществующему адресу памяти.
Исключения позволяют логически разделить вычислительный процесс на две части — обнаружение аварийной ситуации и ее обработка.

Возможные действия при ошибке
прервать выполнение программы;
возвратить значение, означающее «ошибка»;
вывести сообщение об ошибке и вернуть вызывающей программе некоторое приемлемое значение, которое позволит ей продолжать работу;
выбросить исключение
Исключения генерирует либо система выполнения, либо программист с помощью оператора throw.

Некоторые стандартные исключения

Оператор try
Синтаксис оператора try:
try блок [ catch-блоки ] [ finally-блок ]
Служит для обнаружения и обработки исключений.
Оператор содержит три части:
контролируемый блок — составной оператор, предваряемый ключевым словом try. В контролируемый блок включаются потенциально опасные операторы программы. Все функции, прямо или косвенно вызываемые из блока, также считаются ему принадлежащими;
один или несколько обработчиков исключений — блоков catch, в которых описывается, как обрабатываются ошибки различных типов;
блок завершения finally, выполняемый независимо от того, возникла ли ошибка в контролируемом блоке.

Механизм обработки исключений
Обработка исключения начинается с появления ошибки. Функция или операция, в которой возникла ошибка, генерируют исключение;
Выполнение текущего блока прекращается, отыскивается соответствующий обработчик исключения, и ему передается управление.
В любом случае (была ошибка или нет) выполняется блок finally, если он присутствует.
Если обработчик не найден, вызывается стандартный обработчик исключения.

using System;
namespace ConsoleApplication43
{
class Program
{
static void Main(string[] args)
{
try
{ Console.WriteLine("Введите напряжение:");
double u = double.Parse(Console.ReadLine());
Console.WriteLine("Введите сопротивление:");
double r = double.Parse(Console.ReadLine());
double i = u / r;
Console.WriteLine("Сила тока = " + i);
}
catch (FormatException)
Console.WriteLine("Неверный формат ввода!");
catch // общий случай
Console.WriteLine("Неопознанное исключение");
finally
Console.WriteLine("Нажмите любую клавишу для завершения работы программы");
Console.ReadKey();
} } }
Пример работы оператора обработки исключений

Массивы
Массив — ограниченная совокупность однотипных величин
Элементы массива имеют одно и то же имя, а различаются по порядковому номеру (индексу)

Создание массива
Массив относится к ссылочным типам данных (располагается в управляемой куче), поэтому создание массива начинается с выделения памяти под его элементы.
Элементами массива могут быть величины как значимых, так и ссылочных типов (в том числе массивы), например:
int[] w = new int[10]; // массив из 10 целых чисел
string[] z = new string[100]; // массив из 100 строк
Массив значимых типов хранит значения, массив ссылочных типов — ссылки на элементы.
Всем элементам при создании массива присваиваются значения по умолчанию: нули для значимых типов и null для ссылочных.

Размещение массивов в памяти

Размерность массива
Количество элементов в массиве (размерность) задается при выделении памяти и не может быть изменена впоследствии. Она может задаваться выражением:
short n = ...;
string[] z = new string[2*n + 1];
Размерность не является частью типа массива.
Элементы массива нумеруются с нуля.
Для обращения к элементу массива после имени массива указывается номер элемента в квадратных скобках, например:
w[4] z[i]
С элементом массива можно делать все, что допустимо для переменных того же типа.
При работе с массивом автоматически выполняется контроль выхода за его границы: если значение индекса выходит за границы массива, генерируется исключение IndexOutOfRangeException.

Действия с массивами
Массивы одного типа можно присваивать друг другу. При этом происходит присваивание ссылок, а не элементов:
int[] a = new int[10];
int[] b = a; // b и a указывают на один и тот же массив
Все массивы в C# имеют общий базовый класс Array, определенный в пространстве имен System. Некоторые элементы класса Array:
Length (Свойство) - Количество элементов массива (по всем размерностям)
BinarySearch (Статический метод) - Двоичный поиск в отсортированном массиве
IndexOf – (Статический метод) - Поиск первого вхождения элемента в одномерный массив
Sort (Статический метод) - Упорядочивание элементов одномерного массива

Одномерные массивы
Варианты описания массива:
тип[] имя;
тип[] имя = new тип [ размерность ];
тип[] имя = { список_инициализаторов };
тип[] имя = new тип [] { список_инициализаторов };
тип[] имя = new тип [ размерность ] { список_инициализаторов };
Примеры описаний (один пример на каждый вариант описания, соответственно):
int[] a; // элементов нет
int[] b = new int[4]; // элементы равны 0
int[] c = { 61, 2, 5, -9 }; // new подразумевается
int[] d = new int[] { 61, 2, 5, -9 }; // размерность вычисляется
int[] e = new int[4] { 61, 2, 5, -9 }; // избыточное описание

Программа
const int n = 6;
int[] a = new int[n] { 3, 12, 5, -9, 8, -4 };
Console.WriteLine( "Исходный массив:" );
for ( int i = 0; i < n; ++i ) Console.Write( "\t" + a[i] );
Console.WriteLine();
long sum = 0; // cумма отрицательных элементов
int num = 0; // количество отрицательных элементов
for ( int i = 0; i < n; ++i )
if ( a[i] < 0 ) {
sum += a[i]; ++num;
}
Console.WriteLine( "Сумма отрицательных = " + sum );
Console.WriteLine( "Кол-во отрицательных = " + num );
int max = a[0]; // максимальный элемент
for ( int i = 0; i < n; ++i )
if ( a[i] > max ) max = a[i];
Console.WriteLine( "Максимальный элемент = " + max );
Для массива, состоящего из 6 целочисленных элементов, программа определяет:
сумму и количество отрицательных элементов;
максимальный элемент.

Оператор foreach
Применяется для перебора элементов массива.
Синтаксис:
foreach ( тип имя in имя_массива ) тело_цикла
Имя задает локальную по отношению к циклу переменную, которая будет по очереди принимать все значения из массива, например:
int[] massiv = { 24, 50, 18, 3, 16, -7, 9, -1 };
foreach ( int x in massiv ) Console.WriteLine( x );

Использование методов класса Array
static void Main()
{
int[] a = { 24, 50, 18, 3, 16, -7, 9, -1 };
Console.WriteLine( "Исходный массив:", a );
for ( int i = 0; i < a.Length; ++i )
Console.Write( "\t" + a[i] );
Console.WriteLine();
Console.WriteLine( Array.IndexOf( a, 18 ) );
Array.Sort(a); // Array.Sort(a, 1, 5);
Console.WriteLine ( "Упорядоченный массив:", a );
for ( int i = 0; i < a.Length; ++i )
Console.Write( "\t" + a[i] );
Console.WriteLine();
Console.WriteLine( Array.BinarySearch( a, 18) );
Array.Reverse(a); // Array.Reverse(a, 2, 4);
}

Прямоугольные массивы
Прямоугольный массив имеет более одного измерения. Чаще всего в программах используются двумерные массивы.
Варианты описания двумерного массива:
тип[,] имя;
тип[,] имя = new тип [ разм_1, разм_2 ];
тип[,] имя = { список_инициализаторов };
тип[,] имя = new тип [,] { список_инициализаторов };
тип[,] имя = new тип [ разм_1, разм_2 ] { список_инициализаторов };
Примеры описаний (один пример на каждый вариант описания):
int[,] a; // элементов нет
int[,] b = new int[2, 3]; // элементы равны 0
int[,] c = {{1, 2, 3}, {4, 5, 6}}; // new подразумевается
int[,] c = new int[,] {{1, 2, 3}, {4, 5, 6}}; // разм-сть вычисляется
int[,] d = new int[2,3] {{1, 2, 3}, {4, 5, 6}}; // избыточное описание

К элементу двумерного массива обращаются, указывая номера строки и столбца, на пересечении которых он расположен:
a[1, 4] b[i, j] b[j, i]
Компилятор воспринимает как номер строки первый индекс, как бы он ни был обозначен в программе.

const int m = 3, n = 4;
int[,] a = new int[m, n] {
{ 2,-2, 8, 9 },
{-4,-5, 6,-2 },
{ 7, 0, 1, 1 }
};
Console.WriteLine( "Исходный массив:" );
for ( int i = 0; i < m; ++i )
{ for ( int j = 0; j < n; ++j )
Console.Write( "\t" + a[i, j] );
Console.WriteLine();
}

double sum = 0;
int nPosEl;
for ( int i = 0; i < m; ++i )
{
nPosEl = 0;
for ( int j = 0; j < n; ++j )
{
sum += a[i, j];
if ( a[i, j] > 0 ) ++nPosEl;
}
Console.WriteLine( "В строке {0} {1} положит-х эл-в", i, nPosEl);
}
Console.WriteLine( "Среднее арифметическое всех элементов: "
+ sum / m / n );
double sum = 0;
foreach ( int x in a ) sum += x; // все элементы двумерного массива!
Console.WriteLine( "Среднее арифметическое всех элементов: "
+ sum / m / n );

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

Описание ступенчатого массива
тип[][] имя;
Под каждый из массивов, составляющих ступенчатый массив, память требуется выделять явным образом:
int[][] a = new int[3][]; // память под ссылки на 3 строки
a[0] = new int[5]; // память под 0-ю строку (5 эл-в)
a[1] = new int[3]; // память под 1-ю строку (3 эл-та)
a[2] = new int[4]; // память под 2-ю строку (4 эл-та)
Или:
int[][] a = { new int[5], new int[3], new int[4] };
Обращение к элементу ступенчатого массива:
a[1][2] a[i][j] a[j][i]

Пример
int[][] a = new int[3][];
a[0] = new int [5] { 24, 50, 18, 3, 16 };
a[1] = new int [3] { 7, 9, -1 };
a[2] = new int [4] { 6, 15, 3, 1 };
Console.WriteLine( "Исходный массив:" );
for ( int i = 0; i < a.Length; ++i )
{
for ( int j=0; j < a[i].Length; ++j)
Console.Write( "\t" + a[i][j] );
Console.WriteLine();
}
// поиск числа 18 в нулевой строке:
Console.WriteLine( Array.IndexOf( a[0], 18 ) );
foreach ( int [] mas1 in a )
{
foreach ( int x in mas1 )
Console.Write( "\t" + x );
Console.WriteLine();
}

СТРОКИ В C#
string
StringBuilder
символы (тип char)

Строки типа string
Тип string предназначен для работы со строками символов в кодировке Unicode. Ему соответствует базовый класс System.String библиотеки .NET.
Создание строки:
string s; // инициализация отложена
string t = "qqq"; // инициализация строковым литералом
string u = new string(' ', 20); // с пом. конструктора
string v = new string( a ); // создание из массива символов
// создание массива символов: char[] a = { '0', '0', '0' };

Операции для строк
присваивание (=);
проверка на равенство (==);
проверка на неравенство (!=);
обращение по индексу ([]);
сцепление (конкатенация) строк (+).
Строки равны, если имеют одинаковое количество символов и совпадают посимвольно.
Обращаться к отдельному элементу строки по индексу можно только для получения значения, но не для его изменения. Это связано с тем, что строки типа string относятся к неизменяемым типам данных.
Методы, изменяющие содержимое строки, на самом деле создают новую копию строки. Неиспользуемые «старые» копии автоматически удаляются сборщиком мусора.

Некоторые элементы класса System.String

Некоторые элементы класса System.String

Пример
string s = "прекрасная королева Изольда";
Console.WriteLine( s );
string sub = s.Substring( 3 ).Remove( 12, 2 ); // 1
Console.WriteLine( sub );
string[] mas = s.Split(' '); // 2
string joined = string.Join( "! ", mas );
Console.WriteLine( joined );

Строки типа StringBuilder
Класс StringBuilder определен в пространстве имен System.Text. Позволяет изменять значение своих экземпляров.
При создании экземпляра обязательно использовать операцию new и конструктор, например:
StringBuilder a = new StringBuilder(); // 1
StringBuilder b = new StringBuilder( "qwerty" ); // 2
StringBuilder c = new StringBuilder( 100 ); // 3
StringBuilder d = new StringBuilder( "qwerty", 100 ); // 4
StringBuilder e = new StringBuilder( "qwerty", 1, 3, 100 );// 5

Основные элементы класса System.Text.StringBuilder

Console.Write( "Введите зарплату: " );
double salary = double.Parse( Console.ReadLine());
StringBuilder a = new StringBuilder();
a.Append( "зарплата " );
a.AppendFormat( "{0, 6:C} - в год {1, 6:C}", salary, salary * 12 );
Console.WriteLine( a );
a.Replace( "р.", "тыс.$" );
Console.WriteLine( "А лучше было бы: " + a );
Пример

Символьный тип char предназначен для хранения символов в кодировке Unicode. Символьный тип относится к встроенным типам данных C# и соответствует стандартному классу Char библиотеки .NET из пространства имен System.
Символьный тип данных char

Основные методы

namespace ConsoleApplication1
{ class Class1
{ static void Main()
{
try
{
char b = 'B', c = '\x63', d = '\u0032'; // 1
Console.WriteLine( "{0} {1} {2}", b, c, d );
Console.WriteLine( "{0} {1} {2}",
char.ToLower(b), char.ToUpper(c), char.GetNumericValue(d) );
char a;
do // 2
{
Console.Write( "Введите символ: " );
a = char.Parse( Console.ReadLine() );
Console.WriteLine( "Введен символ {0}, его код – {1}",
a, (int)a );
if (char.IsLetter(a)) Console.WriteLine("Буква");
if (char.IsUpper(a)) Console.WriteLine("Верхний рег.");
if (char.IsLower(a)) Console.WriteLine("Нижний рег.");
if (char.IsControl(a)) Console.WriteLine("Управляющий");
if (char.IsNumber(a)) Console.WriteLine("Число");
if (char.IsPunctuation(a)) Console.WriteLine("Разделитель");
} while (a != 'q');
}
catch
{
Console.WriteLine( "Возникло исключение" );
return;
} } } }
Пример