Обработка исключений и условные конструкции

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

1 2 3 4 5 6 7 8 9

static void Main(string[] args) { Console.WriteLine("Введите число"); int x = Int32.Parse(Console.ReadLine());   x *= x; Console.WriteLine("Квадрат числа: " + x); Console.Read(); }

Если пользователь введет не число, а строку, какие-то другие символы, то программа выпадет в ошибку. С одной стороны, здесь как раз та ситуация, когда можно применить блок try..catch, чтобы обработать возможную ошибку. Однако гораздо оптимальнее было бы проверить допустимость преобразования:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

static void Main(string[] args) { Console.WriteLine("Введите число"); int x; string input = Console.ReadLine(); if (Int32.TryParse(input, out x)) { x *= x; Console.WriteLine("Квадрат числа: " + x); } else { Console.WriteLine("Некорректный ввод"); } Console.Read(); }

Метод Int32.TryParse() возвращает true, если преобразование можно осуществить, и false - если нельзя. При допустимости преобразования переменная x будет содержать введенное число. Так, не используя try...catch можно обработать возможную исключительную ситуацию.

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

25

Язык C# предоставляет разработчикам возможности для обработки таких ситуаций. Для этого в C# предназначена конструкция try...catch...finally.

При использовании блока try...catch..finally вначале выполняются все инструкции в блоке try. Если в этом блоке не возникло исключений, то после его выполнения начинает выполняться блок finally. И затем конструкция try..catch..finally завершает свою работу.

Если же в блоке try вдруг возникает исключение, то обычный порядок выполнения останавливается, и среда CLR начинает искать блок catch, который может обработать данное исключение. Если нужный блок catch найден, то он выполняется, и после его завершения выполняется блок finally.

Если нужный блок catch не найден, то при возникновении исключения программа аварийно завершает свое выполнение.

26

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

Например, в нашей программе происходит ввод строки, и мы хотим, чтобы, если длина строки будет больше 6 символов, возникало исключение:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

static void Main(string[] args) { try { Console.Write("Введите строку: "); string message = Console.ReadLine(); if (message.Length > 6) { throw new Exception("Длина строки больше 6 символов"); } } catch (Exception e) { Console.WriteLine($"Ошибка: {e.Message}"); } Console.Read(); }

После оператора throw указывается объект исключения, через конструктор которого мы можем передать сообщение об ошибке. Естественно вместо типа Exception мы можем использовать объект любого другого типа исключений.

Затем в блоке catch сгенерированное нами исключение будет обработано.

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

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

try { try { Console.Write("Введите строку: "); string message = Console.ReadLine(); if (message.Length > 6) { throw new Exception("Длина строки больше 6 символов"); } } catch { Console.WriteLine("Возникло исключение"); throw; } } catch (Exception ex) { Console.WriteLine(ex.Message); }

В данном случае при вводе строки с длиной больше 6 символов возникнет исключение, которое будет обработано внутренним блоком catch. Однако поскольку в этом блоке используется оператор throw, то исключение будет передано дальше внешнему блоку catch.

27

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

• InnerException: хранит информацию об исключении, которое послужило причиной текущего исключения
• Message: хранит сообщение об исключении, текст ошибки
• Source: хранит имя объекта или сборки, которое вызвало исключение
• StackTrace: возвращает строковое представление стека вызывов, которые привели к возникновению исключения
• TargetSite: возвращает метод, в котором и было вызвано исключение

Например, обработаем исключения типа Exception:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

static void Main(string[] args) { try { int x = 5; int y = x / 0; Console.WriteLine($"Результат: {y}"); } catch (Exception ex) { Console.WriteLine($"Исключение: {ex.Message}"); Console.WriteLine($"Метод: {ex.TargetSite}"); Console.WriteLine($"Трассировка стека: {ex.StackTrace}"); }   Console.Read(); }

 

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

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

• DivideByZeroException: представляет исключение, которое генерируется при делении на ноль
• ArgumentOutOfRangeException: генерируется, если значение аргумента находится вне диапазона допустимых значений
• ArgumentException: генерируется, если в метод для параметра передается некорректное значение
• IndexOutOfRangeException: генерируется, если индекс элемента массива или коллекции находится вне диапазона допустимых значений
• InvalidCastException: генерируется при попытке произвести недопустимые преобразования типов
• NullReferenceException: генерируется при попытке обращения к объекту, который равен null (то есть по сути неопределен)

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

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22

static void Main(string[] args) { try { int[] numbers = new int[4]; numbers[7] = 9; // IndexOutOfRangeException   int x = 5; int y = x / 0; // DivideByZeroException Console.WriteLine($"Результат: {y}"); } catch (DivideByZeroException) { Console.WriteLine("Возникло исключение DivideByZeroException"); } catch (IndexOutOfRangeException ex) { Console.WriteLine(ex.Message); }   Console.Read(); }

В данном случае блоки catch обрабатывают исключения типов IndexOutOfRangeException, DivideByZeroException и Exception. Когда в блоке try возникнет исключение, то CLR будет искать нужный блок catch для обработки исключения. Так, в данном случае на строке

1	numbers[7] = 9;

происходит обращение к 7-му элементу массива. Однако поскольку в массиве только 4 элемента, то мы получим исключение типа IndexOutOfRangeException. CLR найдет блок catch, который обрабатывает данное исключение, и передаст ему управление.

Следует отметить, что в данном случае в блоке try есть ситуация для генерации второго исключения - деление на ноль. Однако поскольку после генерации IndexOutOfRangeException управление переходит в соответствующий блок catch, то деление на ноль int y = x / 0 в принципе не будет выполняться, поэтому исключение типа DivideByZeroException никогда не будет сгенерировано.

Однако рассмотрим другую ситуацию:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

static void Main(string[] args) { try { object obj = "you"; int num = (int)obj; // InvalidCastException Console.WriteLine($"Результат: {num}"); } catch (DivideByZeroException) { Console.WriteLine("Возникло исключение DivideByZeroException"); } catch (IndexOutOfRangeException) { Console.WriteLine("Возникло исключение IndexOutOfRangeException"); }   Console.Read(); }

В данном случае в блоке try генерируется исключение типа InvalidCastException, однако соответствующего блока catch для обработки данного исключения нет. Поэтому программа аварийно завершит свое выполнение.

Мы также можем определить для InvalidCastException свой блок catch, однако суть в том, что теоретически в коде могут быть сгенерированы сами различные типы исключений. А определять для всех типов исключений блоки catch, если обработка исключений однотипна, не имеет смысла. И в этом случае мы определить блок catch для базового типа Exception:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22

static void Main(string[] args) { try { object obj = "you"; int num = (int)obj; // InvalidCastException Console.WriteLine($"Результат: {num}"); } catch (DivideByZeroException) { Console.WriteLine("Возникло исключение DivideByZeroException"); } catch (IndexOutOfRangeException) { Console.WriteLine("Возникло исключение IndexOutOfRangeException"); } catch (Exception ex) { Console.WriteLine($"Исключение: {ex.Message}"); } Console.Read(); }

И в данном случае блок catch (Exception ex){} будет обрабатывать все исключения кроме DivideByZeroException и IndexOutOfRangeException. При этом блоки catch для более общих, более базовых исключений следует помещать в конце - после блоков catch для более конкретный, специализированных типов. Так как CLR выбирает для обработки исключения первый блок catch, который соответствует типу сгенерированного исключения. Поэтому в данном случае сначала обрабатывается исключение DivideByZeroException и IndexOutOfRangeException, и только потом Exception (так как DivideByZeroException и IndexOutOfRangeException наследуется от класса Exception).

Операторы checked и unchecked

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

staticvoidMain()

{

bytex= 200;bytey= 200;

byte result = (byte) (x + y);

Console.WriteLine(result);

}

Здесь произведение значений а и b превышает диапазон представления значений типа byte. Следовательно, результат данного выражения не может быть записан в переменную result, тип которой byte.

Для управления подобными исключениями в С# используются операторы checked и unchecked. Чтобы указать, что некоторое выражение должно быть проконтролировано на предмет переполнения, используйте ключевое слово checked. А чтобы проигнорировать переполнение, используйте ключевое слово unchecked. В последнем случае результат будет усечен так, чтобы его тип соответствовал типу-результату выражения.

Замечание. По умолчанию проверка переполнения отключена (галочка не стоит). В результате код выполняется быстро, но тогда программист должен быть уверен, что переполнения не случится или предусмотреть его возникновение. Как мы уже упоминали, можно включить проверку переполнения для всего проекта, однако она не всегда нужна. С помощью использования операторов checked и unchecked в С# реализуется механизм гибкого управления проверкой

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

1. Щелкнуть правой кнопкой мыши на имени проекта
2. В выпадающем меню выбрать Properties
3. В появившемся окне (см. рис.) выбрать слева страницу Build
4. Щелкнуть на кнопке Advanced
5. В появившемся окошке поставить или убрать галочку напротив Check for arithmetic overflow/underflow property.

Оператор checked имеет две формы:

1. проверяет конкретное выражение и называется операторной checked-формой

checked ((тип-выражения) expr)

где expr — выражение, значение которого необходимо контролировать. Если значение контролируемого выражения переполнилось, генерируется исключение типа OverflowException.

1. проверяет блок инструкций

checked

{

// Инструкции, подлежащие проверке.

}

Оператор unchecked также имеет две формы:

1. операторная форма, которая позволяет игнорировать переполнение для заданного выражения

unchecked ((тип-выражения) expr)

где ехрr — выражение, которое не проверяется на предмет переполнения. В случае переполнения это выражение усекается.

1. игнорирует переполнение, которое возможно в блоке инструкций

unchecked

{

// Инструкции, для которых переполнение игнорируется.

}

Рассмотрим пример программы, которая демонстрирует использование checked и unchecked.

static void Main()

{

byte x = 200; byte y = 200;

try

{

byte result = unchecked((byte)(x + y));

Console.WriteLine("1: {0}", result);

result = checked((byte)(x + y));

Console.WriteLine("2: ", result);

}

catch (OverflowException)

{

Console.WriteLine("возникло переполнение");

}

}

Результат выполнения программы:

1: 144

возникло переполнение

28

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

Данные одинакового типа удобно хранить и обрабатывать с использованием массива.
Массив — это непрерывный участок памяти, в котором содержатся элементы одного типа. Массив имеет идентификатор (имя массива), который используется для обращения к отдельным его элементам.
Каждый элемент массива хранится в отдельной ячейке (или ячейках) памяти и имеет свой индекс (порядковый номер в составе массива) и значение.
Все массивы можно условно разделить на

· одномерные массивы;

· многомерные массивы;

· массивы массивов.

В данной статье речь пойдет об одномерных массивах.

Для использования массива его необходимо объявить и выделить память для хранения его элементов. Для объявления одномерного массива используется следующий синтаксис:

 

тип имя;

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

 

имя new тип[количество];
имя new тип[] {выражение1, выражение2, выражениеn};

Результатом выполнения операции new является ссылка на выделенный участок памяти для хранения массива.
При выделении памяти всем элементам массива присваивается значение по умолчанию (для базовых типов данных это значение равно 0).
Объявление массива и выделение памяти для хранения его элементов можно осуществить в одной строке. Например,

 

int [] mas = new int[5];

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

 

имя[индекс]

Начальный элемент массива всегда имеет индекс 0, последний элемент имеет индекс КоличествоЭлементов-1. То есть если массив содержит 5элементов, то эти элементы имеют индексы 0, 1, 2, 3, 4.

Создание массива

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

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

using System;
namespace MyProgram
{
class Program
{
static void Main(string[] args)
{
int n = int.Parse(Console.ReadLine());
int [] arr = new int [n];
for (int i = 0; i < n; i++)
arr[i] = int.Parse(Console.ReadLine());
int max = arr[0];
for (int i = 0; i < n; i++)
if (arr[i] > max) max = arr[i];
Console.WriteLine(max);
Console.ReadKey();
}
}
}

Результат выполнения программы представлен на рисунке.

Поиск максимума можно осуществить с использованием цикла перебора элементов foreach.

 

13
14

foreach (int a in arr)
if (a > max) max = a;

Все массивы в C# являются наследниками класса System.Array, который, в свою очередь, наследует класс System.Object. Поэтому все массивы обладают рядом свойств и методов, присущих классу Array.
Среди свойств класса Array наиболее популярным является свойство Length, возвращающее количество элементов в массиве.
Кроме того, класс Array содержит ряд методов для работы с массивами, некоторые из которых будут рассмотрены ниже.

Запись и считывание элементов массива

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

 

· SetValue(значение, индекс) — для записи значения в элемент массива;

· GetValue(индекс) — для считывания значения из элемента массива. Функция возвращает объект типа Object, для дальнейшего использования которого необходимо явное приведение его к типу элементов массива.

Пример использования этих методов, а также свойства Length, для нахождения максимума в массиве

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

using System;
namespace MyProgram
{
class Program
{
static void Main(string[] args)
{
int n = int.Parse(Console.ReadLine());
int [] mas = new int [n];
for (int i = 0; i < mas.Length; i++)
mas.SetValue(int.Parse(Console.ReadLine()), i);
int max = (int)mas.GetValue(0);
for (int i = 0; i < mas.Length; i++)
{
int a = (int)mas.GetValue(i);
if (a > max) max = a;
}
Console.WriteLine(max);
Console.ReadKey();
}
}
}

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

using System;
namespace MyProgram
{
class Program
{
static void Main(string[] args)
{
int n = int.Parse(Console.ReadLine());
int [] arr = new int [n];
for (int i = 0; i < arr.Length; i++)
arr[i] = int.Parse(Console.ReadLine());
for (int i = 0; i < arr.Length; i++)
Console.Write(arr[i] + " ");
Array.Clear(arr,1,2);
Console.WriteLine();
for (int i = 0; i < arr.Length; i++)
Console.Write(arr[i] + " ");
Console.ReadKey();
}
}
}

Результат работы программы:

Копирование массива

Для копирования массивов можно использовать один из двух методов класса Array – Clone() и CopyTo(). Оба метода создают поверхностную копию массива, то есть копируют элементы из одного массива в другой массив. При этом если элементы массива являются ссылками, то копируются сами значения этих ссылок, а сам объект, на который они ссылаются, остается единственным.
Кардинальное отличие методов Clone() и CopyTo() заключается в том, что метод Clone() самостоятельно выделяет память под вновь создаваемый массив и заполняет ее копиями элементов, а метод CopyTo() предусматривает, что память должна быть предварительно выделена под заполняемый этим методом массив в достаточном объеме.

Метод Clone() возвращает объект класса Object, который необходимо явно привести к ссылке на массив указанного типа.
Рассмотрим пример копирования массива с помощью функции Clone():

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

using System;
namespace MyProgram
{
class Program
{
static void Main(string[] args)
{
int n = int.Parse(Console.ReadLine());
int [] arra = new int [n];
for (int i = 0; i < arra.Length; i++)
arra[i] = int.Parse(Console.ReadLine());
int[] arrb = (int[])arra.Clone();
for (int i = 0; i < arrb.Length; i++)
Console.Write(arrb[i] + " ");
Console.ReadKey();
}
}
}

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

using System;
namespace MyProgram
{
class Program
{
static void Main(string[] args)
{
int n = int.Parse(Console.ReadLine());
int [] arra = new int [n];
for (int i = 0; i < arra.Length; i++)
arra[i] = int.Parse(Console.ReadLine());
int[] arrb = new int[n];
arra.CopyTo(arrb, 0);
for (int i = 0; i < arrb.Length; i++)
Console.Write(arrb[i] + " ");
Console.ReadKey();
}
}
}

Кроме того, для копирования массива можно использовать статические методы класса Array:

· Copy(), в качестве аргументов которого передаются ссылка на копируемый массив, ссылка на массив-приемник (память для хранения элементов этого массива предварительно должна быть выделена в достаточном количестве) и количество копируемых элементов. Возможна также перегрузка данного метода с указанием начального индекса массива-источника и массива-приемника.

· ConstrainedCopy() — метод, имеющий единственный вариант вызова, и в качестве аргументов ему передаются

o ссылка на копируемый массив,

o индекс элемента, с которого начинается копирование

o ссылка на массив-приемник

o индекс элемента, на место которого начинается копирование

o количество копируемых элементов.

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

Рассмотрим пример, копирования массива с использованием метода Copy():

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

using System;
namespace MyProgram
{
class Program
{
static void Main(string[] args)
{
int n = int.Parse(Console.ReadLine());
int [] arra = new int [n];
for (int i = 0; i < arra.Length; i++)
arra[i] = int.Parse(Console.ReadLine());
int[] arrb = new int[n];
Array.Copy(arra, arrb, arra.Length);
for (int i = 0; i < arrb.Length; i++)
Console.Write(arrb[i] + " ");
Console.ReadKey();
}
}
}

Использование метода ConstrainedCopy() для копирования массива:

13

Array.ConstrainedCopy(arra, 0, arrb, 0, arra.Length);

Изменение размеров массива

При выделении памяти под элементы массива, выделенный участок памяти может хранить фиксированное число элементов. Если размер массива необходимо увеличить или уменьшить, то необходимо сначала создать новый массив, потом скопировать в него значения требуемых элементов текущего массива, после чего освободить память, выделенную под старый массив.
С этой целью может использоваться статический метод Resize() класса Array, который в качестве аргументов принимает ссылку на массив и новое количество его элементов. Если количество элементов необходимо уменьшить, то последние элементы массива не будут сохранены. Если количество элементов необходимо увеличить, то вновь созданные элементы заполнятся значениями по умолчанию.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

using System;
namespace MyProgram
{
class Program
{
static void Main(string[] args)
{
int n = int.Parse(Console.ReadLine());
int [] arr = new int [n];
for (int i = 0; i < arr.Length; i++)
arr[i] = int.Parse(Console.ReadLine());
Array.Resize(ref arr, 4);
for (int i = 0; i < arr.Length; i++)
Console.Write(arr[i] + " ");
Console.ReadKey();
}
}
}

 

Сортировка, поиск и переворот массива

Для сортировки массива используется статический метод Sort() класса Array, в качестве аргумента которому передается ссылка на сортируемый массив. Выбор метода сортировки осуществляется в зависимости от длины сортируемого массива.
Для поиска значения элемента в отсортированном массиве может использоваться статический метод BinarySearch() класса Array, которому в качестве аргументов передаются ссылка на массив и искомое значение. Метод возвращает индекс элемента в массиве с заданным значением. Если элемент в массиве не найден, возвращается отрицательное значение. Если массив содержит несколько искомых элементов, возвращается индекс одного из них.
Для поиска элемента в неотсортированном массиве по значению также можно воспользоваться статическими методами IndexOf() и LastIndexOf()класса Array, в качестве аргументов которым передаются ссылка на массив и искомое значение. Возвращаемое значение функций — индекс первого и последнего элементов соответственно в массиве, равных искомому. Если элемент с искомым значением в массиве не найден, возвращается отрицательное значение индекса.
Класс Array содержит метод Reverse(), предназначенный для изменения порядка следования всех элементов массива на противоположный.
Ниже приведен пример использования перечисленных методов.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

using System;
namespace MyProgram
{
class Program
{
static void Main(string[] args)
{
int n = int.Parse(Console.ReadLine());
int [] arr = new int [n];
for (int i = 0; i < arr.Length; i++)
arr[i] = int.Parse(Console.ReadLine());
for (int i = 0; i < arr.Length; i++)
Console.Write(arr[i] + " ");
Console.WriteLine();
Console.WriteLine("First(5)=" + Array.IndexOf(arr, 5));
Console.WriteLine("Last(5) =" + Array.LastIndexOf(arr, 5));
Array.Sort(arr);
for (int i = 0; i < arr.Length; i++)
Console.Write(arr[i] + " ");
Console.WriteLine();
Console.WriteLine("Find(5) =" + Array.BinarySearch(arr, 5));
Array.Reverse(arr);
for (int i = 0; i < arr.Length; i++)
Console.Write(arr[i] + " ");
Console.WriteLine();
Console.ReadKey();
}
}
}

Результат выполнения программы представлен на рисунке.

29/30

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

⇑

2. Какая общая форма объявления многомерного массива?

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

тип [,...,] имя_массива = new тип [ размер1, размер2,..., размерN ];

где

· тип – непосредственно тип элементов массива;

· размер1, размер2, размерN – размерность каждого измерения массива. Значение N означает, что массив N-мерный.

Двумерные массивы могут быть двух видов:

· прямоугольный массив в виде таблицы;

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

Общая форма объявления ступенчатого массива:

тип [][] имя_массива = new тип [ размер ][];

где

· тип – тип элементов массива;

· размер – количество строк в массиве.

⇑

Пример объявления и использования ступенчатого массива

// ступенчатые массивы

// объявление массива из 4-х строк, элементы которого имеют тип ulong

ulong[][] A = new ulong[4][];

 

// выделение памяти для каждой строки

A[0] = new ulong[5]; // в строке с индексом 0 есть 5 элементов

A[1] = new ulong[3]; // в строке с индексом 1 есть 3 элемента

A[2] = new ulong[6];

A[3] = new ulong[4];

 

// демонстрация доступа к элементам массива A

A[0][0] = 2003;

A[0][4] = 199008;

A[1][2] = 302909;

A[3][3] = 10000000;

 

for (int i = 0; i < 6; i++)

A[2][i] = (ulong)(i * i * i);

Как видно из примера, доступ к элементам ступенчатого массива происходит иначе чем в прямоугольном массиве.

⇑