Пример программы с двумерным массивом

В первой статье были описаны приёмы работы с простейшим видом массивов — одномерным (линейным) массивом. В этой, второй статье будут рассмотрены многомерные массивы. В основном, речь пойдёт о двумерных массивах. Но приведённые примеры легко экстраполируются на массивы любой размерности. Также как и в первой статье, будут рассматриваться только массивы в стиле C/C++, без использования возможностей STL.

Эта статья предполагает у читателя базовые знания об одномерных и многомерных массивах, указателях и адресной арифметике. Почерпнуть эти знания можно в любом учебнике по C/C++.

• Классика жанра

• Определение автоматических многомерных массивов
• Инициализация
• Заполнение массива значениями
• Вывод значений массива на консоль
• Расположение в памяти
• Хаки

• №1
• №2

• Создание и уничтожение динамических многомерных массивов
• Где собака порылась
• Ещё раз о предосторожности

• Передача в функцию многомерного C-массива
• Передача в функцию многомерного динамического массива

Классика жанра

Если мы откроем классический труд «Язык программирования C» Брайана Кернигана и Денниса Ритчи, то прочитаем, что «В языке C есть возможность работать с многомерными прямоугольными массивами, хотя на практике они используются гораздо реже, чем массивы указателей». C++ практически полностью унаследовал работу с многомерными массивами своего предтечи.

Двумерный массив что это. Многомерные массивы. Пример. Теория. Что такое массив. Array. C++ #30

Определение автоматических многомерных массивов

В этом разделе я буду иногда употреблять термин «матрица» как синоним термина «двумерный массив». В C/C++ прямоугольный двумерный массив чисел действительно реализует математическое понятие «матрица». Однако, в общем случае, двумерный массив — понятие гораздо более широкое, чем матрица, поскольку он может быть и не прямоугольным, и не числовым.

Определение автоматических многомерных массивов почти полностью совпадает с определением одномерных массивов (о чём было рассказано в первой статье), за исключением того, что вместо одного размера может быть указано несколько:

В этом примере определяется двумерный массив из 3 строк по 5 значений типа int в каждой строке. Итого 15 значений типа int .

Во втором примере определяется трёхмерный массив, содержащий 3 матрицы, каждая из которых состоит из 5 строк по 2 значения типа int в каждой строке.

Понятно, что тип данных, содержащихся в многомерном массиве, может быть любым.

При дальнейшем изложении для таких многомерных массивов будет употребляться термин «C-массив», что бы отличать их от массивов других видов.

Инициализация

При статической (определяемой на этапе компиляции) инициализации значения C-массива перечисляются в порядке указания размеров (индексов) в определении массива. Каждый уровень (индекс), кроме самого младшего, многомерного массива заключается в свою пару фигурных скобок. Значения самого младшего индекса указываются через запятую:

Двумерный динамический массив c++ пример. Создание, заполнение, удаление. Динамические массивы. #56

В примере показана статическая инициализация прямоугольного массива. Весь список инициализирующих значений заключён в фигурные скобки. Значения для каждой из 3 строк заключены в свою пару из фигурных скобок, значения для каждого из 5 столбцов для каждой строки перечислены через запятую.

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

Заполнение массива значениями

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

#include using namespace std; const unsigned int DIM1 = 3; const unsigned int DIM2 = 5; int ary[DIM1][DIM2]; int main() < for (int i = 0; i < DIM1; i++) < for (int j = 0; j < DIM2; j++) < ary[i][j] = (i + 1) * 10 + (j + 1); >> // .

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

Вывод значений массива на консоль

В продолжение предыдущего примера можно написать:

cout return 0; >

В результате получим следующий вывод на консоль:

11 12 13 14 15 21 22 23 24 25 31 32 33 34 35

Для трёхмерного массива можно написать код, использующий те же приёмы:

#include using namespace std; const unsigned int DIM1 = 3; const unsigned int DIM2 = 5; const unsigned int DIM3 = 2; int ary[DIM1][DIM2][DIM3]; int main() < for (int i = 0; i < DIM1; i++) < for (int j = 0; j < DIM2; j++) < for (int k = 0; k < DIM3; k++) < ary[i][j][k] = (i + 1) * 100 + (j + 1) * 10 + (k + 1); cout cout cout return 0; >

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

Расположение в памяти

Для многомерного C-массива выделяется единый блок памяти необходимого размера: размер_массива1 * размер_массива2 * . * размер_массиваN * sizeof(тип_элемента_массива) .

Значения располагаются последовательно. Самый левый индекс изменяется медленнее всего. Т.е. для трёхмерного массива сначала располагаются значения для первой (индекс 0) матрицы, затем для второй и т.д. Значения для матриц располагаются построчно (ср. со статической инициализацией массива выше).

Имя (идентификатор) многомерного C-массива является указателем на первый элемент массива (так же как и для одномерных массивов)

Если код из последнего примера немного изменить:

cout cout return 0; // точка останова здесь

поставить точку останова на return и посмотреть под отладчиком память, отведённую под переменную ary , то будет видно, что значения, расположенные в памяти, последовательно возрастают:

0x00A9F218 01 00 00 00 02 00 00 00 03 00 00 00 04 00 00 00 . 0x00A9F228 05 00 00 00 06 00 00 00 07 00 00 00 08 00 00 00 . 0x00A9F238 09 00 00 00 0a 00 00 00 0b 00 00 00 0c 00 00 00 . 0x00A9F248 0d 00 00 00 0e 00 00 00 0f 00 00 00 10 00 00 00 . 0x00A9F258 11 00 00 00 12 00 00 00 13 00 00 00 14 00 00 00 . 0x00A9F268 15 00 00 00 16 00 00 00 17 00 00 00 18 00 00 00 . 0x00A9F278 19 00 00 00 1a 00 00 00 1b 00 00 00 1c 00 00 00 . 0x00A9F288 1d 00 00 00 1e 00 00 00 00 00 00 00 00 00 00 00 .

Хаки

№1

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

> int *ptr = (int *)ary; // так не надо делать 😉 for (int i = 0; i < DIM1; i++) < for (int j = 0; j < DIM2; j++) < cout cout return 0; >
cout

В последнем фрагменте осуществляется доступ к значениям двумерного массива как к одномерному массиву. Цивилизованное решение реализуется через union .

№2

Из двух примеров, приведённых выше, следует, что работу с двумерным или многомерным массивом (в понимании на более высоком уровне абстракции) технически можно организовать посредством одномерного массива соответствующего размера:

> for (int i = 0; i < DIM1; i++) < for (int j = 0; j < DIM2; j++) < cout cout return 0; >

Этот приём достаточно распространён. Его выгода в том, что массив ary[DIM1 * DIM2] не обязательно должен быть выделен автоматически. Его можно выделять и динамически. Но при этом логически рассматривать как C-массив.

Вышеприведённый код написан в духе чистого C. В C++ обычно такие вещи прячут в класс, оставляя снаружи лаконичный интерфейс без всяких следов адресной арифметики.

Неродные близнецы

Теперь рассмотрим работу с «динамическими» многомерными массивами, т.е. с массивами, память для которых выделяется динамически.

Создание и уничтожение динамических многомерных массивов

Как правило, работа с такими массивами осуществляется следующим образом:

// работа с массивом for (int i = 0; i < DIM1; i++) < for (int j = 0; j < DIM2; j++) < ary[i][j] = (i + 1) * 10 + (j + 1); >> for (int i = 0; i < DIM1; i++) < for (int j = 0; j < DIM2; j++) < cout cout // уничтожение for (int i = 0; i < DIM1; i++) < delete [] ary[i]; >delete [] ary; return 0; >

(1) Для доступа к двумерному массиву объявляется переменная ary типа указатель на указатель на тип (в данном случае это указатель на указатель на int ).

(2) Переменная инициализируется оператором new , который выделяет память для массива указателей на int .

(3) В цикле каждый элемент массива указателей инициализируется оператором new , который выделяет память для массива типа int .

Освобождение памяти происходит строго в обратном порядке: сначала уничтожаются массивы значений типа int , а затем уничтожается массив указателей.

Работа с динамическим многомерным массивом синтаксически полностью совпадает с работой с многомерным C-массивом.

Пример кода для трёхмерного массива:

> // работа с массивом for (int i = 0; i < DIM1; i++) < for (int j = 0; j < DIM2; j++) < for (int k = 0; k < DIM3; k++) < ary[i][j][k] = cnt++; cout cout cout // уничтожение for (int i = 0; i < DIM1; i++) < for (int j = 0; j < DIM2; j++) < delete [] ary[i][j]; >delete [] ary[i]; > delete [] ary; return 0; >

Где собака порылась

Работа с динамическим многомерным массивом синтаксически полностью совпадает с работой с многомерным C-массивом. (Цитирую предыдущий раздел.) Синтаксически — да, но между этими массивами есть глубокое различие, о котором начинающие программисты часто забывают.

Во-первых, для динамического массива выделяется другой объём памяти.

Если посчитать, сколько памяти будет выделяться для двумерного массива из примера выше, то получится: первый оператор new выделил память для 3 указателей, второй оператор new в цикле трижды выделил память для 5 элементов типа int . Т.е. получилось, что выделили памяти для 15 значений типа int и для 3 значений типа указатель на int . Для C-массива компилятором была выделена память только для 15 значений типа int . (Всяческие выравнивания и прочие оптимизации не учитываем!)

Во-вторых, память, выделенная для динамического массива, не непрерывна. Следовательно, хак №1 (обращение с двумерным массивом как с одномерным) работать не будет.

В-третьих, передача многомерных массивов в функции и работа с ними будет отличаться для динамических массивов и C-массивов.

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

Динамический многомерный массив НЕ является C-массивом.

Парадоксально, но факт, что наиболее близким родственничком для этих неродных близнецов, является хак №2, реализующий работу с многомерным массивом посредством одномерного массива (см. раздел Хаки). Все три вышеперечисленных различия для него неактуальны.

Стоит отметить, что массив указателей на массивы — структура более гибкая, чем двумерный C-массив. Например, для массива указателей на массивы размеры массивов могут быть разными, или какой-то массив может вообще отсутствовать. Наиболее распространённым примером является «массив строк», т.е. массив указателей на массивы типа char (пример — см. в следующем разделе).

Ещё раз о предосторожности

Из вышеизложенного следует, что нужно чётко отличать многомерные C-массивы вида

от массивов указателей на массивы.

Иногда внешние отличия весьма незначительны. К примеру С-строка — это одномерный массив элементов типа char , заканчивающийся нулевым байтом. Как реализовать массив строк?

Это — пример определения и инициализации двумерного C-массива

Каждая С-строка занимает ровно 10 байт, включая завершающий ноль (считаем, тип char имеет размер 1 байт). Неиспользуемые байты у коротких строк, вроде «May», содержат «мусор» (или нули, если об этом позаботился компилятор). Весь массив занимает один непрерывный блок памяти размером 120 байт (12 строк по 10 символов).

А здесь определён и инициализирован одномерный (!) массив указателей на массивы элементов типа char .

Вся информация, доступная через переменную month , занимает 13 блоков памяти: массив из 12 указателей и 12 блоков памяти, адреса которых хранятся в указателях, содержащих С-строки с названиями месяцев. И нет никакой гарантии, что 12 блоков памяти с С-строками будут расположены в памяти последовательно и в порядке, соответствующем перечислению в инициализаторе.

Но в обоих случаях доступ к символу b в строке «February» будет осуществляться выражением month[1][2] .

И, в заключение, ещё одно предостережение.

Поскольку многомерные C-массивы, как правило, занимают большой объём памяти, их надо с особой осторожностью объявлять внутри функций, в том числе в main() . И с осторожностью в n-ной степени в рекурсивных функциях. Можно легко получить переполнение стека и, как следствие, аварийное завершение программы.

Многомерные массивы при работе с функциями

Поскольку многомерные C-массивы и многомерные динамические массивы — совершенно разные типы данных, то и при работе с функциями подходы будут разные.

Передача в функцию многомерного C-массива

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

// (1) void func(int ary[][DIM2]) < . >// (2)

Форма (1) — наиболее распространённая.

Форма (2). При передаче многомерного C-массива в функцию можно не указывать длину самого левого измерения. Компилятору для расчёта доступа к элементам массива эта информация не нужна.

Как всегда в C/C++, параметр передаётся в функцию по значению. Т.е. в функции доступна копия фактического параметра. Поскольку имя C-массива является указателем на его первый элемент (т.е. адресом первого элемента), то в функцию передаётся копия адреса начала массива. Следовательно, внутри функции можно изменять значения элементов массива, т.к. доступ к ним осуществляется через переданный адрес, но нельзя изменить адрес начала массива, переданный в качестве параметра, т.к. это — копия фактического параметра.

Возвратить многомерный C-массив из функции в качестве результата стандартными средствами невозможно.

Передача в функцию многомерного динамического массива

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

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

#include using namespace std; const unsigned int DIM1 = 3; const unsigned int DIM2 = 5; int **array_generator(unsigned int dim1, unsigned int dim2) < int **ptrary = new int * [dim1]; for (int i = 0; i < dim1; i++) < ptrary[i] = new int [dim2]; >return ptrary; > void array_destroyer(int **ary, unsigned int dim1) < for (int i = 0; i < dim1; i++) < delete [] ary[i]; >delete [] ary; > int main() < int **matrix; // создание массива matrix = array_generator(DIM1, DIM2); // использование for (int i = 0; i < DIM1; i++) < for (int j = 0; j < DIM2; j++) < matrix[i][j] = (i + 1) * 10 + (j + 1); cout > // уничтожение array_destroyer(matrix, DIM1); return 0; >

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

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

Массив указателей используется в каждой программе, которая может получать входную информацию из командной строки (или при её вызове от операционной системы). Одна из классических форм функции main() имеет вид:

Аргументами функции являются количество строк argc (размер массива указателей) и массив указателей на строки — argv . Т.е. argv — это массив указателей на массивы значений типа char .

Пожалуй это всё, что я хотел рассказать в этой статье. Надеюсь, что кто-то сочтёт её полезной для себя.

Да пребудет с вами святой Бьярн и апостолы его! 😉

Автор статьи: Cranium aka Череп.

Источник: code-live.ru

Урок 5 — Двумерные массивы. Теория и примеры

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

Const n = 5; m = 10; Турe arr=Array[1..n] Of Аrrау[1..m] of ; Var Mas: arr;
4) И снова сократив запись, получим:
Const n = 5; m = 10; Type arr = Array[1..n,1..m] of ; Var Mas: arr;
Для обработки содержимого матрицы, удобно пользоваться вложенными циклами:
For i:= 1 To n Do For j:= 1 To m Do

Например, для заполнения массива случайнми числами:
for i:=1 to n do for j:=1 to n do x[i,j]:=random(100);
Для вывода двумерного массива вещественных чисел размером n строк, m столбцов:
for i:=1 to n do begin for j:=1 to m do write(x[i,j]:5:2); writeln; end;
В следующей программе массив сначала заполняется числами с клавиатуры, а затем выводиться на экран.

program input_and_output_array; uses crt; const n=3; m=3; var i, j: integer; mas: array[1..n, 1..m] of integer; begin for i:=1 to n do for j:=1 to m do begin write(‘ Элемент ‘, i,’ строки, ‘,j,’ столбца = ‘); readln(mas[i, j]); end; writeln(‘ Получившаяся матрица: ‘); for i:=1 to n do begin for j:=1 to m do begin write(mas[i, j]:5); end; writeln end; end.

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

sum:=0; for i:=1 to n do for j:=1 to n do sum:=sum+x[i,j]; writeln(‘Сумма=’,sum);

Сумма элементов главной диагонали квадратной матрицы (элементы главной диагонали имеют одинаковые индексы -x[1,1], x[2,2] и т.д.):

sum:=0; for i:=1 to n do sum:=sum+x[i,i]; writeln(‘Сумма=’,sum);

Сумма элементов побочной диагонали (диагонали противоположной главной). Индексы элементов побочной диагонали в сумме равны n+1, т.е. i+j=n+1 или j=n+1-i :

sum:=0; for i:=1 to n do sum:=sum+x[i,n+1-i]; writeln(‘Сумма=’,sum);
Сумма элементов ниже главной диагонали квадратной матрицы (строго ниже):
sum:=0; for i:=1 to n do for j:=1 to n do if i>j then sum:=sum+x[i,j]; writeln(‘Сумма=’,sum);
Можно не просматривать весь массив, а брать только нужные элементы:
sum:=0; for i:=2 to n do for j:=1 to i-1 do sum:=sum+x[i,j]; writeln(‘Сумма=’,sum);
Сумма элементов выше и на главной диагонали квадратной матрицы:
sum:=0; for i:=1 to n do for j:=1 to n do if i
Здесь также можно не просматривать весь массив, а брать только нужные элементы:
sum:=0; for i:=1 to n do for j:=i to n do sum:=sum+x[i,j]; writeln(‘Сумма=’,sum);
Сумма элементов ниже побочной диагонали квадратной матрицы (строго ниже) :
sum:=0; for i:=1 to n do for j:=1 to n do if i+j>n+1 then sum:=sum+x[i,j]; writeln(‘Сумма=’,sum);
Можно не просматривать весь массив, а брать только нужные элементы:
sum:=0; for i:=2 to n do for j:=n+2-i to n do sum:=sum+x[i,j]; writeln(‘Сумма=’,sum);

Если надо посчитать сумму элемсентов ниже побочной диагонали и на ней, то в предыдущем примере, при просмотре всего массива в предыдущем примере надо заменить знак отношения > на >=, а при просмотре толко нужных элементов применить такой код:

sum:=0; for i:=1 to n do for j:=n+1-i to n do sum:=sum+x[i,j]; writeln(‘Сумма=’,sum);

При подсчете суммы элементов выше и на главной диагонали, выше и на побочной диагонали возможно применине такого кода:

sum:=0; for i:=1 to n do for j:=1 to n do if (i<=j) and (i+j<=n+1) then sum:=sum+x[i,j]; writeln(‘Сумма=’,sum);
Подсчет сумм элементов по строкам:
for i:=1 to n do begin sum:=0; for j:=1 to n do sum:=sum+x[i,j]; writeln(‘Сумма ‘,i,’-й строки’,sum); end;
Подсчет сумм элементов по столбцам:
for j:=1 to n do begin sum:=0; for i:=1 to n do sum:=sum+x[i,j]; writeln(‘Сумма ‘,j,’-го столбца ‘,sum); end;

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

for i:=1 to n do sum[j]:=0; for i:=1 to n do for j:=1 to n do zum[j]:=sum[j]+x[i,j]; for i:=1 to n do write(sum[i]:4); writeln;

Суммы элементов по диагоналям, параллельным главной диагонали. Очевидно, что таких сумм будет 2n-1. Кроме того, разности индексов эдементов, стоящих на одной диагонали будут равны друг другу. Имеется в виду разность «номер строки минус номер столбца».

Эти разности будут меняться от -n+1 для самой верхней диагонали s1, содержащей всего лишь один элемент, до n-1 для диагонали s2N-1, расположенной в самом низу матрицы и содержащей также всего один элемент. Таким образом, для подсчета сумм мы должны объявить массив: Var sum:array[-n+1..n-1] of integer; Число элементов в этом массиве будет 2n-1. Код для подсчета этих сумм:

for i:=-n+1 to n-1 do sum[i]:=0; for i:=1 to n do for j:=1 to n do sum[i-j]:=sum[i-j]+x[i,j]; for i:=-n+1 to n-1 do write(sum[i]);
Суммы элементов по диагоналям, параллельным побочной диагонали.
for i:=2 to 2*n do sum[i]:=0; for i:=1 to n do for j:=1 to n do sum[i+j]:=sum[i+j]+x[i,j]; for i:=2 to 2*n do write(sum[i]);

Суммы элементов по периметрам двумерного массива.
Cледует различать четный или нечетный порядок матрицы n. Число сумм будет равно k=n div 2 при четном n и k=n div 2 +1 при нечетном значении n. Счет суммы начинается по строке i от столбца j равного i и заканчивается столбцом n-i+1 , т.е. начинается с элемена находящегося на главной диагонали и заканчивается элементом на побочной диагонали. Одновременно учитываются элементы из параллельной строки, индекс которой равен n-i+1 . Затем считаем элементы по двум паралельным столбцам i и n-i+1 (не учитывая элементы, стоящие в строках). Если n -нечетное число, то выводим значение центрального элемента массива x[k+1,k+1] .

k:=n div 2; for i:=1 to k do begin sum:=0; for j:=i to n-i+1 do sum:=sum+x[i,j]+x[n-i+1,j]; for j:=i+1 to n-i do sum:=sum+x[j,i]+x[j,n-i+1]; writeln(sum); end; if n mod 2=1 then writeln(x[k+1,k+1]);

Источник: pro-prof.com

Многомерные массивы (Руководство по программированию на C#)

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

int[,] array = new int[4, 2];

Следующее объявление создает массив из трех измерений: 4, 2 и 3.

int[,,] array1 = new int[4, 2, 3];

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

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

// Two-dimensional array. int[,] array2D = new int[,] < < 1, 2 >, < 3, 4 >, < 5, 6 >, < 7, 8 >>; // The same array with dimensions specified. int[,] array2Da = new int[4, 2] < < 1, 2 >, < 3, 4 >, < 5, 6 >, < 7, 8 >>; // A similar array with string elements. string[,] array2Db = new string[3, 2] < < «one», «two» >, < «three», «four» >, < «five», «six» >>; // Three-dimensional array. int[,,] array3D = new int[,,] < < < 1, 2, 3 >, < 4, 5, 6 >>, < < 7, 8, 9 >, < 10, 11, 12 >> >; // The same array with dimensions specified. int[,,] array3Da = new int[2, 2, 3] < < < 1, 2, 3 >, < 4, 5, 6 >>, < < 7, 8, 9 >, < 10, 11, 12 >> >; // Accessing array elements. System.Console.WriteLine(array2D[0, 0]); System.Console.WriteLine(array2D[0, 1]); System.Console.WriteLine(array2D[1, 0]); System.Console.WriteLine(array2D[1, 1]); System.Console.WriteLine(array2D[3, 0]); System.Console.WriteLine(array2Db[1, 0]); System.Console.WriteLine(array3Da[1, 0, 1]); System.Console.WriteLine(array3D[1, 1, 2]); // Getting the total count of elements or the length of a given dimension. var allLength = array3D.Length; var total = 1; for (int i = 0; i < array3D.Rank; i++) < total *= array3D.GetLength(i); >System.Console.WriteLine(» equals «, allLength, total); // Output: // 1 // 2 // 3 // 4 // 7 // three // 8 // 12 // 12 equals 12

Можно также инициализировать массив без указания ранга.

int[,] array4 = < < 1, 2 >, < 3, 4 >, < 5, 6 >, < 7, 8 >>;

Чтобы объявить переменную массива без инициализации, используйте оператор new для присвоения массива переменной. Использование оператора new показано в следующем примере.

int[,] array5; array5 = new int[,] < < 1, 2 >, < 3, 4 >, < 5, 6 >, < 7, 8 >>; // OK //array5 = , , , >; // Error

В следующем примере присваивается значение конкретному элементу массива.

array5[2, 1] = 25;

Аналогичным образом, в следующем примере получается значение конкретного элемента массива, которое присваивается переменной elementValue .

int elementValue = array5[2, 1];

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

int[,] array6 = new int[10, 10];

См. также

• Руководство по программированию на C#
• Массивы
• Одномерные массивы
• Массивы массивов

Источник: learn.microsoft.com