lec

МАССИВЫ И СТРОКИ

1. Одномерные массивы

Одномерный массив - набор элементов одного типа, тип элементов стандартный или определен в разрабатываемой программе.

double[] a;	0	1	2
a=new double[3];	0	0	0

Тип может быть любой, например строковый:

string[] w;

w=new string[]{“МОСКВА”, “МАРСЕЛЬ”, “РИМ”};

0		1	2
w =>	МОСКВА	МАРСЕЛЬ	РИМ
0 1 2 3 4 5		0 1 2 3 4 5 6	0 1 2

string s=“”; // пустая строка s=s+w[0][0]+w[2][1]+w[1][2]; // s => МИР

Тип массива определен как класс Array (т.е. ссылочный тип) в пространстве имен System.

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

Дополнительные возможности определяются полями и методами. Для массива определено поле объекта – Length, определяющее ко-

личество элементов в массиве. Статические методы:

	массив-оригинал
	позиция в массиве-ориг.	Copy	void
	массив-копия
	позиция в массиве-коп.
	кол-во элементов

массив

номер позиции Метод void кол-во элементов

-Sort

-Reverse

91

Метод Copy выполняет копирование элементов из массива оригинала в массив копию. Метод Sort сортирует заданную часть массива по возрастанию значения элементов. Метод Reverse выполняет переворот заданной части массива.

int[] a,b; //массивы a и b a=new int[]{10,20,30,40};

b=new int[a.Length]; // 2-ой массив той же длины Array.Copy (a, 1, b, 0, 2); // копирование

Array.Sort (b, 0, b.Length); // отсортировали все элементы из b

Array.Reverse (b, 1, 2);
//Массив a:	10	20	30	40
//Массив b после копирования:	20	30	0	0
//Массив b после сортировки:	0	0	20	30
//Массив b после переворота:	0	20	0	30

2. Динамические массивы

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

Альтернативой массиву в этом случае является динамический массив. Динамический массив определен как класс ArrayList в пространст-

ве имен System.Collections.

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

Поле объекта: Count – количество элементов в массиве Методы объекта для добавления элементов в массив: Add (значение) // добавление элемента в конец массива

AddRange (массив) // добавление массива в конец массива

Insert (номер позиции, значение) //добавление элемента в заданную позицию

InsertRange (номер позиции, массив) // добавление массива с заданной позиции

Методы объекта для удаления элементов из массива:

Remove (значение) RemoveAt (номер позиции)

RemoveRange (номер позиции, количествово элементов) Clear () // удаление всех элементов

Пример:
ArrayList_a;
int[] b,c;
b=new int[]{10, 20};
c=new int[100];
a=new ArrayList();	a	Count

92

								пусто						0
a.Add(5);	5													1
a.Insert(0,77); // в позицию 0 значение 77							77 5							2
a.AddRange(b);				77 5					10		20			4
a.CopyTo(1,c,0,3);	4
a.InsertRange(0,b);	10	20		77			5		10		20			6
a.Remove(20);		10		77 5					10		20			5
a.RemoveAt(3);		10		77 5					20					4
a.RemoveRange(1,2);			10		20									2
a.Clear();								пусто						0

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

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

У динамического массива можно без проблем удалять/добавлять элементы, легко изменять размер.

На практике используется сочетание динамического и обычного массивов. Это порождает проблему создания динамического массива на основе обычного и наоборот.

динамический массив(a) → обычный массив(b)

a.CopyTo (позиция в дин.мас-ве ,обычный массив, позиция в об.мас-ве, кол-во элементов)

обычный массив(b) → динамический массив(a)

a.AddRange (b) //добавление обычного массива в пустой динамический

3. Строки

Понятие строки и операции со строками были рассмотрены ранее.

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

Поле объекта: Length Методы объекта:

сравнение строк на предмет больше-меньше

ИмяСтроки.CompareTo (строка, с которой сравниваем)

Сравнение выполняется лексикографичекси (по алфавиту), метод возвращает целое число:

93

-1, если строка < той, с которой сравниваем 0, если строка = той, с которой сравниваем +1, если строка > той, с которой сравниваем

поиск подстроки

	строка key		int
	номер позиции	поиск подстро-
		ки

позиция key в вызываемой строке, начиная с заданной позиции

IndexOf – первое вхождение key LastIndexOf – последнее вхождение key

Возвращает -1, если key отсутствует

Замена в вызывающей строке всех подстрок s1 на новую подстроку s2.

	строка s1		string
	строка s2	Replace

Вставка в вызывающую строку строки s1 с заданной позиции.

	номер позиции int		string
	строка s1	Insert

Удаление в строке заданного количества символов, начиная с заданной позиции.

	номер позиции		string
	кол-во символов	Remove

Разбиение вызывающей строки на слова. Возможные разделители между словами указываются в массиве символов.

Символьный массив	Split	string[]
		массив строк

94

Если несколько разделителей идут подряд, первый из них считается разделителем, а на месте остальных формируется пустая строка.

Формирование строки путем соединения строк, указанных в массиве. Слова в объединенной строке разделяются строкой-разделителем.

	строка-разделитель		string
	массив строк	Join

Метод Join - статический
string s1=”око , за”;
string[] word;
char[] sep; // массив разделителей
		око_ , _ за
	s1
sep = new char[]{‘ ’, ‘,’};
s1=s1.Insert(8, “_око”);	s1	око_ , _ за_ око
s1=s1.Replace(“око”, “зуб”);
	s1	зуб_ , _ за_ зуб
word=s1.Split(sep);	word	“зуб”	“”	“” “за”	“зуб”
s1=string.Join (“>”, word);
	s1	зуб>>> за> зуб

4. Динамические строки

Тип динамической строки определен как класс – StringBuilder, пространство имен System.Text.

Создание динамической строки

StringBuilder ИмяСтроки; ИмяСтроки=new StringBuilder();

Отличия от обычной строки:

1.Элементы динамической строки можно изменять напрямую, путем присваивания.

2.В операциях ==, !=, = участвуют не элементы строки, а адреса (аналогично массиву).

Поле объекта: Length Методы:

ИмяСтроки.Append (символ) //добавление символа в конец строки ИмяСтроки.Append (символ, кол-во) //добавление заданного коли-

чества символов в конец строки

ИмяСтроки.Remove (номер позиции, кол-во символов) //удаление заданного кол-ва символов с заданной позиции

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

95

Схема выполнения преобразований: string s => char[] a

s.ToCharArray;

char[] a => string s s=new_string(a);

string s => StringBuilder b b=new_ StringBuilder(s);

StringBuilder b => string s s=b.ToString();

5.Двумерные массивы

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

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

		0	1	номера столбцов
	0			(второе измерение)
		10	15
	1
		12	13
	2	14	8

номера строк (первое измерение)

Объявление двумерного массива:

Тип элементов [,] ИмяМассива;

ИмяМассива=new Тип элементов [кол-во строк, кол-во столбцов];

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

int[,] a, b;	a
		0	0
a=new int[3,2];
		0	0
		0	0
b=new int[,] {{1,2}, {3,4}, {5,6}};

b 1 2

3 4

5 6

Свойство Length применительно к двумерному массиву соответствует общему количеству элементов: b.Length => 6

Пример:

96

Сформировать и выдать на экран целочисленную единичную матрицу размером m×n.

int [,] a;

int i,j; //номера строк и столбцов

string s; //строка, формирующая символьное значение строки матрицы int n=5;

a=new int [n,n]; for (i=0; i<n; i++)

a [i,i]=1;

for (i=0; i<n; i++) { s=””;

for (j=0; j<n; j++) s=s + a[i,j] + “_”;

Console.WriteLine (s);

6. Массив массивов

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

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

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

Массив

Строка

Элементы

Объявление массива массивов

Тип элементов [][] ИмяМассива; //память под ссылки

ИмяМассива=new_ Тип элементов [кол-во строк][]; //память под каждую строку ИмяМассива[№строки]=new_Тип[кол-во элементов в строке]

100

int[][] a;			100				0		0		0
a=new int[2][];
			200				0		0
a[0]=new int[3];
a[1]=new int[2];
								200
		100				1		2			3
//инициализация
		200				5		6
a[0]=new int[] {1, 2, 3};
	97

a[1]=new int[] {5,6};

Свойство Length определено как для всего массива, так и для каж-

дой строки отдельно:
a.Length => 2	(2 строки)

a[0].Length => 3 (3 элемента в строке)

Для каждой строки можно использовать методы обработки одномерных массивов. При поэлементной обработке массива для доступа к элементу необходимо указать номер строки и номер элемента внутри строки. Каждый номер указывается в своей паре скобок:

a[0][1]=88;

98

МЕТОДЫ

1. Определение метода

Метод определяет некоторую процедуру обработки данных. Выполнение объектно-ориентированной программы можно рассматривать как взаимодействие объектов путем передачи сообщений. Сообщение равносильно вызову метода. Т.е. выполнение программы можно рассматривать как взаимодействие методов с точки зрения двух аспектов:

-по управлению (вызов/возврат)

-по обмену данных

Определение метода может быть выполнено только в составе класса. Определение метода должно содержать:

1.Имя метода

2.Доступ к данному методу со стороны других

3.Принадлежность методу конкретному объекту или классу

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

5.Собственно процедуру обработки параметров

<модификаторы>_ТипВозвращаемогоОбъекта Имя (параметры)

{

<локальные переменные> + процедура

}

2. Взаимодействие методов по управлению

Методы имеют непосредственный доступ к полям своего класса. Статические методы имеют доступ только к статическим полям и могут вызывать только статические методы.

Класс1

Класс2

+Метод1() ИмяОбъекта.ИмяМетода + Метод1()

+Метод2() - Метод2()

+ Метод3()	ИмяКласса.ИмяМетода
	+ Метод3()
+ Метод4()	Имя Имя
	Класса. Метода

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

Пример

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

99

Yисх Yсм

a

b

a

b

Xсм

Xисх

В классе реализовать операции:

1.Сдвиг смещенной системы координат со всеми точками на единицу по обеим осям. Эту операцию назовем СдвигСистемы.

2.Сдвиг конкретной точки в смещенной системе координат (СдвигТочки). Сдвиг точки выполняется на единицу по обеим осям

3.Вывод координат точки в смещенной системе координат (Ко-

орСм)

4.Вывод координат точки в исходной системе координат (КоорИсх)

Точка

+x // поля, которые определяют координаты в смещенной +y //системе

+x0 // насколько сдвинута система

+y0 // поля статические, т.к. эта характеристика для всех точек (система сдвигается вместе со всеми точками)

+СдвигСистемы() // применяем для всего класса точек, а не для конкретной точки , поэтому метод статический

+СдвигТочки() +КоорСм() +КоорИсх()

class_Точка

{

public_int x,y; public_static_int x0,y0;

public_static_void_СдвигСистемы(){x0++; y0++}; public_void_СдвигТочки(){x++;y++} public_void_КоорСм()

{ Console.WriteLine (x+”,”+y);} public_void_КоорИсх() {Console.WriteLine ((x+x0)+”,”+(y+y0));}

}

class_Пример

{

public_static_void_Main() {Точка a,b; a=new_Точка(); b=new_ Точка();

a.x=3; a.y=4; b.x=4; b.y=3;

100