Инициализация массивов

Массив мало объявить, его нужно ещё проинициализировать. Только тогда ранее специфицированное множество однотипных объектов будет размещено в памяти.

Определение предполагает спецификацию КОЛИЧЕСТВА объектов по каждому измерению.

ИнициализацияМассива ::= = newИнициализация

::= = ИнициализацияСписком

::= = ЗаполняющаяИнициализация

::= = ИнициализацияКопированием

newИнициализация ::= new ИмяТипа СписокОписателейРазмерности

ЗаполняющаяИнициализация ::= newИнициализация ИнициализацияСписком

СписокОписателейРазмерности ::= [СписокОписателейРазмерности] ОписательРазмерности

ОписательРазмерности ::= [СписокОписателей] | ПустойОписатель

СписокОписателей ::= [СписокОписателей ,] Описатель

Описатель ::= Выражение

ПустойОписатель ::= [ПУСТО]

Выражение-описатель должно быть:

• целочисленным,

• с определённым значением.

Такой фокус при определении и инициализации массивов не проходит:

int x; // К моменту определения массива значение x должно быть определено!

int[] arr0 = new int[x];

Так нормально! В момент определения массива CLR знает ВСЕ НЕОБХОДИМЫЕ характеристики определяемого массива.

int x = 10;

int[][] arr1 = new int[125][x];

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

ВСЕ НЕОБХОДИМЫЕ характеристики – это не всегда ВСЕ!

При определении массивов произвольной размерности инициализирующая запись должна содержать ПОЛНУЮ информацию о характеристиках первой составляющей массива. Все остальные описатели могут оставаться пустыми.

int val1 = 100;

// На этом этапе определения массива массивов

// элементов типа int принципиально знание характеристик первой составляющей!

// Все остальные могут быть заданы после!

int [][] x0 = new int[15][];

int [][][] x1 = new int[val1][][];

int [,][] x2 = new int[val1,7][];

int [,,][,][] x3 = new int[2,val1,7][,][];

// Следующие способы объявления корректными не являются.

// int [][][] y0 = new int[val1][2][];

// int [][][] y1 = new int[][2][7];

// int [,][] y2 = new int[ ,2][7];

// int [,,] y3 = new int[val1,2, ];

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

ИнициализацияСписком ::= {СписокВыражений}

::= {СписокИнициализаторовСоставляющихМассива}

СписокИнициализаторовСоставляющихМассива ::=

[СписокИнициализаторовСоставляющихМассива , ] ИнициализаторМассива

ИнициализаторМассива ::= newИнициализация {СписокВыражений} | {СписокВыражений}

СписокВыражений ::= [СписокВыражений ,] Выражение

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

int[] r = {val1, 1, 4, 1*val1};

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

int[] r = new int[] {val1, 1, 4, 1*val1};

int[] t = new int[4] {val1, 1, 4, 1*val1};

В первом случае избыточная инициализация – рецидив многословия. Тип значений элементов массива определяется спецификатором массива, количество элементов массива определяется количеством элементов списка выражений.

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

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

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

ИнициализацияКопированием ::= СпецификацияСоставляющей

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

СписокИндексныхВыражений ::= [СписокИндексныхВыражений] [ИндексноеВыражение]

ИндексноеВыражение ::= Выражение

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

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[1][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.