Массивы

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

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

ИнициализацияКопированием ::= СпецификацияСоставляющей
СпецификацияСоставляющей ::= ИмяМассива СписокИндексныхВыражений
СписокИндексныхВыражений ::= [СписокИндексныхВыражений] [Индексное Выражение]
ИндексноеВыражение ::= Выражение

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

int [] q = {0,1,2,3,4,5,6,7,8,9};
int [][] d1 = {
new int[3],
new int[5]
	 };
int [][][] d2 = new int[2][][];
d2[0] = new int[50][]; d2[0][0] = d1[0];
// d2[0][0] ссылается на составляющую массива d1.
d2[0][1] = new int[125]; 
d2[1] = new int[50][]; 
d2[1][1] = new int[10]{1,2,3,4,5,6,7,8,9,10}; 
d2[1][0] = q;
// d2[1][0] ссылается на ранее объявленный и определенный массив q.

В следующем примере одномерный массив myArray строится из элементов типа int.

int[] myArray = new int [5];

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

Простой строковый массив можно объявить и проинициализировать аналогичным образом:

string[] myStringArray = new string[6];

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

int[] myArray = new int[] {1, 3, 5, 7, 9};

Строковый массив может быть проинициализирован аналогичным образом:

string[] weekDays = new string[] {"Sun","Sat","Mon","Tue","Wed","Thu","Fri"};

И это не единственный способ объявления и инициализации.

Если объявление совмещается с инициализацией, операция new может быть опущена. Предполагается, что транслятор знает, ЧТО при этом нужно делать:

string[] weekDays = {"Sun","Sat","Mon","Tue","Wed","Thu","Fri"};

Объявление и инициализация вообще могут быть размещены в разных операторах. Но в этом случае без операции new ничего не получится:

int[] myArray;
myArray = new int[] {1, 3, 5, 7, 9}; // Так можно.
myArray = {1, 3, 5, 7, 9}; // Так нельзя.

А вот объявление одномерного массива, состоящего из трех элементов, каждый из которых является одномерным массивом целых:

int[][] myJaggedArray = new int[3][];

Дальнейшее использование этого массива требует инициализации его элементов. Например, так:

myJaggedArray[0] = new int[5];
myJaggedArray[1] = new int[4];
myJaggedArray[2] = new int[2];

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

Ниже показан пример использования заполняющей инициализации, при которой одновременно с определением (созданием) массивов производится присвоение элементам новорожденных массивов конкретных значений:

myJaggedArray[0] = new int[] {1,3,5,7,9};
myJaggedArray[1] = new int[] {0,2,4,6};
myJaggedArray[2] = new int[] {11,22};

Вышеупомянутый массив может быть объявлен и проинициализирован и таким образом:

int[][] myJaggedArray = new int [][]
 {
new int[] {1,3,5,7,9},
new int[] {0,2,4,6},
new int[] {11,22}
 };

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

int[][] myJaggedArray = {
new int[] {1,3,5,7,9},
new int[] {0,2,4,6},
new int[] {11,22}
 };

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

// Assign 33 to the second element of the first array:
myJaggedArray[0][1] = 33;
// Assign 44 to the second element of the third array:
myJaggedArray[2][1] = 44;

C# позволяет собирать разнообразные конструкции на основе jagged многомерных массивов. Ниже приводится пример объявления и инициализации одномерного jagged-массива, содержащего в качестве элементов двумерные массивы различных размеров:

int[][,] myJaggedArray = new int [3][,]
 {
new int[,] { {1,3}, {5,7} },
new int[,] { {0,2}, {4,6}, {8,10} },
new int[,] { {11,22}, {99,88}, {0,9} } 
 };

Доступ к отдельным элементам jagged-массива обеспечивается различными комбинациями выражений индексации. В приводимом ниже примере выводится значение элемента массива [1,0], расположенного по нулевому индексу myJaggedArray (это 5 ):

Console.Write("{0}", myJaggedArray[0][1,0]);

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

using System;
public class ArrayTest 
{
public static void Main() 
 {
int[][] myArray = new int[2][];
myArray[0] = new int[5] {1,3,5,7,9};
myArray[1] = new int[4] {2,4,6,8};

for (int i=0; i < myArray.Length; i++) 
 {
Console.Write("Element({0}):", i);
for (int j = 0 ; j < myArray[i].Length ; j++)
Console.Write("{0}{1}",myArray[i][j], j == (myArray[i].Length–1) 
? "" : " ");
Console.WriteLine();
 }
 }
}

Результат:

Element(0): 1 3 5 7 9
Element(1): 2 4 6 8