Массивы языка C#

Как обычно задаются элементы массива, если они не заданы при инициализации? Они либо вычисляются, либо вводятся пользователем. Давайте рассмотрим первый пример работы с массивами из проекта с именем Arrays, поддерживающего эту лекцию:

public void TestDeclaration()
{
	//объявляются три одномерных массива A,B,C
	int[] A = new int[5], B= new int[5], C= new int[5];
	Arrs.CreateOneDimAr(A);
	Arrs.CreateOneDimAr(B);
	for(int i = 0; i<5; i++)
		C[i] = A[i] + B[i];
	//объявление массива с явной инициализацией
	int[] x ={5,5,6,6,7,7};
	//объявление массивов с отложенной инициализацией
	int[] u,v;
	u = new int[3];
	for(int i=0; i<3; i++) u[i] =i+1;
	//v= {1,2,3}; //присваивание константного массива 
	//недопустимо
	v = new int[4];	
	v=u; //допустимое присваивание
	int [,] w = new int[3,5];
	//v=w; //недопустимое присваивание: объекты разных классов
	Arrs.PrintAr1("A", A); Arrs.PrintAr1("B", B);
	Arrs.PrintAr1("C", C); Arrs.PrintAr1("X", x);
	Arrs.PrintAr1("U", u); Arrs.PrintAr1("V", v);
}

На что следует обратить внимание, анализируя этот текст:

public static void CreateOneDimAr(int[] A)
{
	for(int i = 0; i<A.GetLength(0);i++)
		A[i] = rnd.Next(1,100);
}//CreateOneDimAr

Здесь rnd - это статическое поле класса Arrs, объявленное следующим образом:

private  static Random rnd = new Random();

Процедура печати массива с именем name выглядит так:

public static void PrintAr1(string name,int[] A)
{
	Console.WriteLine(name);
	for(int i = 0; i<A.GetLength(0);i++)
		Console.Write("\t" + name + "[{0}]={1}", i, A[i]);
	Console.WriteLine();
}//PrintAr1

На рис. 11.1 показан консольный вывод результатов работы процедуры TestDeclarations.

Особое внимание обратите на вывод, связанный с массивами u и v.

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

Во всех вышеприведенных примерах объявлялись статические массивы, поскольку нижняя граница равна нулю по определению, а верхняя всегда задавалась в этих примерах константой. Напомню, что в C# все массивы, независимо от того, каким выражением описывается граница, рассматриваются как динамические, и память для них распределяется в "куче". Полагаю, что это отражение разумной точки зрения: ведь статические массивы, скорее исключение, а правилом является использование динамических массивов. В действительности реальные потребности в размере массива, скорее всего, выясняются в процессе работы в диалоге с пользователем.

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

Приведу пример, в котором описана работа с динамическим массивом:

public void TestDynAr()
{
	//объявление динамического массива A1
	Console.WriteLine("Введите число элементов массива A1");
	int size = int.Parse(Console.ReadLine());
	int[] A1 = new int[size];
	Arrs.CreateOneDimAr(A1);
	Arrs.PrintAr1("A1",A1);
}//TestDynAr

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

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

Уже объяснялось, что разделение массивов на одномерные и многомерные носит исторический характер. Никакой принципиальной разницы между ними нет. Одномерные массивы -это частный случай многомерных. Можно говорить и по-другому: многомерные массивы являются естественным обобщением одномерных. Одномерные массивы позволяют задавать такие математические структуры как векторы, двумерные - матрицы, трехмерные - кубы данных, массивы большей размерности - многомерные кубы данных. Замечу, что при работе с базами данных многомерные кубы, так называемые кубы OLAP, встречаются сплошь и рядом.

В чем особенность объявления многомерного массива? Как в типе указать размерность массива? Это делается достаточно просто, за счет использования запятых. Вот как выглядит объявление многомерного массива в общем случае:

<тип>[, ... ,] <объявители>;

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

public void TestMultiArr()
{
	int[,]matrix = {{1,2},{3,4}};
	Arrs.PrintAr2("matrix", matrix);
}//TestMultiArr

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

public void TestMultiMatr()
{
	int n1, m1, n2, m2,n3, m3;
	Arrs.GetSizes("MatrA",out n1,out m1);
	Arrs.GetSizes("MatrB",out n2,out m2);
	Arrs.GetSizes("MatrC",out n3,out m3);
	int[,]MatrA = new int[n1,m1], MatrB = new int[n2,m2];
	int[,]MatrC = new int[n3,m3];
	Arrs.CreateTwoDimAr(MatrA);Arrs.CreateTwoDimAr(MatrB);
	Arrs.MultMatr(MatrA, MatrB, MatrC);
	Arrs.PrintAr2("MatrA",MatrA); Arrs.PrintAr2("MatrB",MatrB);
	Arrs.PrintAr2("MatrC",MatrC);
}//TestMultiMatr

Три матрицы - MatrA, MatrB и MatrC - имеют произвольные размеры, выясняемые в диалоге с пользователем, и использование для их описания динамических массивов представляется совершенно естественным. Метод CreateTwoDimAr заполняет случайными числами элементы матрицы, переданной ему в качестве аргумента, метод PrintAr2 выводит матрицу на печать. Я не буду приводить их код, похожий на код их одномерных аналогов.

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

public void MultMatr(int[,]A, int[,]B, int[,]C)
{
	if (A.GetLength(1) != B.GetLength(0))
		Console.WriteLine("MultMatr: ошибка размерности!");
	else
		for(int i = 0; i < A.GetLength(0); i++)
			for(int j = 0; j < B.GetLength(1); j++)
			{
				int s=0;
				for(int k = 0; k < A.GetLength(1); k++)
					s+= A[i,k]*B[k,j];
				C[i,j] = s;
			}
}//MultMatr

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

Обратите внимание, как выглядят результаты консольного вывода на данном этапе работы (рис. 11.2).

Массивы массивов

Еще одним видом массивов C# являются массивы массивов, называемые также изрезанными массивами (jagged arrays). Такой массив массивов можно рассматривать как одномерный массив, элементы которого являются массивами, элементы которых, в свою очередь, снова могут быть массивами, и так может продолжаться до некоторого уровня вложенности.

В каких ситуациях может возникать необходимость в таких структурах данных? Эти массивы могут применяться для представления деревьев, у которых узлы могут иметь произвольное число потомков. Таковым может быть, например, генеалогическое дерево. Вершины первого уровня - Fathers, представляющие отцов, могут задаваться одномерным массивом, так что Fathers[i] - это i -й отец. Вершины второго уровня представляются массивом массивов - Children, так что Children[i] - это массив детей i -го отца, а Children[i][j] - это j -й ребенок i -го отца. Для представления внуков понадобится третий уровень, так что GrandChildren [i][j][k] будет представлять к -го внука j -го ребенка i -го отца.

Есть некоторые особенности в объявлении и инициализации таких массивов. Если при объявлении типа многомерных массивов для указания размерности использовались запятые, то для изрезанных массивов применяется более ясная символика - совокупности пар квадратных скобок; например, int[][] задает массив, элементы которого - одномерные массивы элементов типа int.

Сложнее с созданием самих массивов и их инициализацией. Здесь нельзя вызвать конструктор new int[3][5], поскольку он не задает изрезанный массив. Фактически нужно вызывать конструктор для каждого массива на самом нижнем уровне. В этом и состоит сложность объявления таких массивов. Начну с формального примера:

//массив массивов - формальный пример
//объявление и инициализация
int[][] jagger = new int[3][]
{
	new int[] {5,7,9,11},
	new int[] {2,8},
	new int[] {6,12,4}
};

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

int[][] jagger1 = new int[3][]
{
	new int[4],
	new int[2],
	new int[3]
};

В этом случае элементы массива получат при инициализации нулевые значения. Реальную инициализацию нужно будет выполнять программным путем. Стоит заметить, что в конструкторе верхнего уровня константу 3 можно опустить и писать просто new int[][]. Самое забавное, что вызов этого конструктора можно вообще опустить - он будет подразумеваться:

int[][] jagger2 =
{
	new int[4],
	new int[2],
	new int[3]
};

А вот конструкторы нижнего уровня необходимы. Еще одно важное замечание - динамические массивы возможны и здесь. В общем случае, границы на любом уровне могут быть выражениями, зависящими от переменных. Более того, допустимо, чтобы массивы на нижнем уровне были многомерными. Но это уже "от лукавого" - вряд ли стоит пользоваться такими сложными структурами данных, ведь с ними предстоит еще и работать.

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

//массив массивов -"Отцы и дети"
int Fcount =3;
string[] Fathers = new string[Fcount];
Fathers[0] ="Николай"; Fathers[1] = "Сергей";
	Fathers[2] = "Петр";
string[][] Children = new string[Fcount][];
Children[0] = new string[] {"Ольга", "Федор"};
Children[1] = new string[]
	{"Сергей","Валентина","Ира","Дмитрий"};
Children[2] = new string[]{"Мария","Ирина","Надежда"};
myar.PrintAr3(Fathers,Children);

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

Я не буду демонстрировать работу с генеалогическим деревом, ограничусь лишь печатью этого массива. Здесь есть несколько поучительных моментов. В классе Arrs для печати массива создан специальный метод PrintAr3, которому в качестве аргументов передаются массивы Fathers и Children. Вот текст данной процедуры:

public void PrintAr3(string [] Fathers, string[][] Children)
{
	for(int i = 0; i < Fathers.Length; i++)
	{
		Console.WriteLine("Отец : {0}; Его дети:", Fathers[i]);
		for(int j = 0; j < Children[i].Length; j++)
			Console.Write( Children[i][j] + " ");
		Console.WriteLine();
	}
}//PrintAr3

Приведу некоторые комментарии к этой процедуре:

Приведу вывод, полученный в результате работы процедуры PrintAr3.

Процедуры и массивы

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

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