Что такое массив? Что такое массив дерева Понятие массива в программировании

Кроме файлового типа. Тип компонент называется базовым типом . Каждая компонента может быть явно обозначена с помощью имени переменной-массива, за которым в квадратных скобках следует индекс . Их тип называется типом индекса . Время, требуемое для доступа любой компоненты, не зависит от значения индекса. Поэтому о массивах можно говорить как об объектах, структура которых допускает случайный (или прямой ) доступ .

Объявление переменных массивового типа

Переменная массивового типа описывается в разделе описания переменных в следующей форме:

Var <идентификатор>: array[<тип индекса>] of <тип компонент>

Чаще всего в качестве типа индекса употребляется интервальный тип . Например, одномерный массив среднемесячных температур опишется так:

Var T: array of real;

Описание массива определяет, во-первых, размещение массива в памяти, во-вторых, правила его дальнейшего употребления в программе. Последовательные элементы массива располагаются в последовательных ячейках памяти (T, T и т.д.), причем значения индекса не должны выходить из диапазона 1...12. В качестве индекса может употребляться любое выражение соответствующего типа. Например:

T, T

Тип индекса может быть любым скалярным порядковым типом, кроме integer (в реализации Turbo Pascal). Например, в программе могут присутствовать следующие описания:

Var Cod: array of 1..100; L: array of Char;

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

Cod["x"]; L; cod; L;

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

Type Index=(А, В, С, D); Var Class_10: array of byte;

И если, например, элемент Class_10[A] равен 35, то это означает, что в 10 «А» классе 35 человек. Такое индексирование улучшает наглядность программы.

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

Type Mas1 = array of integer; Mas2 = array[-10..10] of char; var Num: Mas1; Sim: Mas2;

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

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

Var H: array of array of real;

Вот примеры обозначения некоторых элементов этого массива:

Н; Н; Н;

Однако чаще употребляется другая, эквивалентная форма обозначения элементов двумерного массива:

Н; Н; Н;

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

Type Month = array of real; Year = array of Month; var H: Year;

Наиболее краткий вариант описания данного массива такой:

Var H: array of real;

Трехмерный массив можно определить как одномерный массив, у которого элементами являются двумерные массивы. Вот пример описания трехмерного массива:

Var A: array of integer;

Это массив, состоящий из 10x20x30 = 6000 целых чисел и занимающий в памяти 6000x2 = 12000 байт. В Паскале нет ограничения сверху на размерность массива. Однако в каждой конкретной реализации Паскаля ограничивается объем памяти, выделяемый под массивы.

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

Сonst Imax=10; Jmax=20; var Mas: array of integer;

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

Операции над массивами

Действия над массивом как единым целым. Такие действия допустимы лишь в двух случаях:

• присваивание значений одного массива другому;
• операции отношения «равно», «не равно».

В обоих случаях массивы должны иметь одинаковые типы (тип индексов и тип элементов). Пример:

Var P, Q: Array Of Real;

При выполнении операции присваивания P:= Q все элементы массива P станут равны соответствующим элементам массива Q.

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

Н := Н;

А если нужно поменять местами значения этих строк, то это делается через третью переменную того же типа:

Р:= Н; Н := Н; Н := Р;

где P описана так:

Var P: Array Of Real;

Обработка массивов

Обработка массивов в программах производится покомпонентно. Вот примеры ввода значений в массивы:

For I:= 1 to 12 do readln(T[I]); for I:= 1 to IMax do for J:= 1 to JMax do readln(Mas);

Здесь каждое следующее значение будет вводиться с новой строки. Для построчного ввода используется оператор read . Аналогично в цикле по индексной переменной организуется вывод значений массива. Например:

For I:= 1 tо 12 do write(T[I]:8:4);

Следующий фрагмент программы организует построчный вывод матрицы на экран:

For I:= 1 to IMax do begin for J:= l to JMax do write(Mas:6); writeln; end;

После печати очередной строки матрицы оператор writeln без параметров переведет курсор в начало новой строки. Следует заметить, что в последнем примере матрица на экране будет получена в естественной форме прямоугольной таблицы, если JMax не превышает 12.

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

Во FreePascal, Delphi добавлена интересная возможность описания массивов без указания размерностей и, соответственно, пределов изменения индексов:

Var IntArray: array of integer;

Такие массивы являются динамическими и изначально имеют нулевую длину. Установка размера массива и определение его во время выполнения программы производится так же как и для строк, с помощью функций SetLength и Length , соответственно. Элементы в данном случае нумеруются от нуля.

Program UsingDynamicArrays1; var А, В: Array of Integer; {Описание двух переменных - динамических массивов целочисленных элементов} begin SetLength(A, 5); {Установка размера массива А (5 элементов) } А := 1; {Присвоение значения 1 элементу массива А с номером 0 } end.

Переменные-динамические массивы являются указателями и операции с ними производятся как с указателями. Например, при присвоении одного массива другому элементы одного массива не копируются во второй, а копируется адрес массива. Соответственно, сравнение двух массивов в логических выражениях типа «равно - не равно» производится сравнением адресов. Пример присвоения одного массива другому:

Program UsingDynamicArrays2; var А, В: array of integer; {Описание двух переменных - динамических массивов целочисленных элементов} begin SetLength(A, 5); { Установка размера массива А (5 элементов) } А := 14; {Присвоение значения 14 нулевому элементу массива А} В:= А; {Присвоение массива А массиву В, теперь переменные А и В указывают на один и тот же массив} В := 2; {Присвоение нулевому элементу массива В значения 2, теперь нулевой элемент массива А также имеет значение 2} end.

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

. Форма или структура массива - сведения о количестве размерностей и размере (протяжённость) массива для каждой из размерностей ; может быть представлена одномерным массивом .

Энциклопедичный YouTube

• 1 / 5

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

  Количество используемых индексов массива может быть различным: массивы с одним индексом называют одномерными, с двумя - двумерными, и т. д. Одномерный массив («колонка», «столбец») - нестрого соответствует вектору в математике; двумерный - матрице . Чаще всего применяются массивы с одним или двумя индексами; реже - с тремя; ещё большее количество индексов - встречается крайне редко.

  Пример фиксированного массива на языке Паскаль

  {Одномерный массив целых чисел. Нумерация элементов от 1 до 15} a : array [ 1 .. 15 ] of Integer ; {Двумерный массив символов. Нумерация по столбцам по типу Byte (от 0 до 255) по строкам от 1 до 5} multiArray : array [ Byte , 1 .. 5 ] of Char ; {Одномерный массив из строк. Нумерация по типу word (от 0 до 65536)} rangeArray : array [ Word ] of String ;

  Пример фиксированного массива на С/С++

  Int Array [ 10 ]; // Одномерный массив: целых чисел, размера 10; // Нумерация элементов - от 0 до 9. double Array [ 12 ][ 15 ]; // Двумерный массив: // вещественных чисел двойной точности, // размера 12 на 15; // Нумерация: по строкам - от 0 до 11, // по столбцам - от 0 до 14.

  В некоторых языках программирования многомерные массивы создаются на основе одномерных, у которых элементы являются массивами .

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

  //ES6. Создание двумерного массива чисел: var array = [ [ 11 , 12 , 13 , 14 , 15 , 16 ], // Первая строка-массив [ 21 , 22 , 23 , 24 , 25 , 26 ], // Вторая [ 31 , 32 , 33 , 34 , 35 , 36 ] // Третья ]; // Вывод массива на консоль: array . forEach ((subArray ) => { // Для каждого под-массива, subArray . forEach ((item ) => { // для каждого его элемента, console . log (item ); // - вывести этот элемент на консоль. }); });

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

  В языках программирования, допускающих объявления программистом собственных типов , как правило, существует возможность создания типа «массив». В определении такого типа могут указываться: размер, тип элемента, диапазон значений и типы индексов. В дальнейшем возможно определение переменных созданного типа. Все такие переменные-массивы имеют одну структуру. Некоторые языки поддерживают для переменных-массивов операции присваивания (когда одной операцией всем элементам массива присваиваются значения соответствующих элементов другого массива).

  Объявление типа «массив» в языке Паскаль

  Type TArrayType = array [ 0 .. 9 ] of Integer ; (* Массивы, имеющие заданные параметры: 1. Размер - 10 ячеек; 2. Тип элементов, пригодных для хранения - - целые числа диапазона [−32 768; 32 767], - объявляются типом операндов, называющимся "TArrayType". *) var arr1 , arr2 , arr3 : TArrayType ; (* Объявление трёх переменных-массивов одного типа (вышеуказанного "TArrayType"). *)

  Специфические типы массивов

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

  «Динамическим» называется массив такого размера, который может «динамически» меняться при выполнении программы (например, - уменьшаться после выгрузки неактуальных данных). Язык программирования , предоставляющий такую возможность, называется поддерживающим динамические массивы. Динамические массивы делают работу с данными более гибкой, так как не требуют предварительного определения хранимых объёмов данных, а позволяют регулировать размер массива в соответствии с реальными потребностями. Обычные (не динамические) массивы называют ещё фиксированными .

  Пример динамического массива на Delphi

  ByteArray : Array of Byte ; // Одномерный массив multiArray : Array of Array of string ; // Многомерный массив

  Пример динамического массива на Си

  Float * array1 ; // Одномерный массив int ** array2 ; // Двумерный массив array1 = (float * ) malloc (10 * sizeof (float )); // выделение 10 блоков по sizeof(float) байт каждый array2 = (int ** ) malloc (16 * sizeof (int * )); // выделение 16 блоков по sizeof(int*) байт каждый. Сюда будут записаны указатели на одномерные массивы-строки for (i = 0 ; i < 16 ; ++ i ) array2 [ i ] = (int * ) malloc (8 * sizeof (int )); // выделение 8 блоков по sizeof(int) байт каждый. Это одномерные массивы - строки матрицы. // Обращение к массиву array1 [ i ] = 5.0 ; * (array1 + i ) = 5.0 ; array2 [ i ][ j ] = 6 ; // Записи эквивалентны. Первая с использованием индекса, * (* (array2 + i ) + j ) = 6 ; // вторая с операцией разыменования. free (array1 ); for (i = 0 ; i < 16 ; ++ i ) free (array2 [ i ]); free (array2 );

  Пример динамического массива на С++

  Float * array1 ; // Одномерный массив int ** array2 ; // Многомерный массив array1 = new float [ 10 ]; // выделение 10 блоков размером типа float array2 = new int * [ 16 ]; // выделение 16 блоков размером типа указателя на int for (int i = 0 ; i < 16 ; ++ i ) array2 [ i ] = new int [ 8 ]; // Работаем с массивами. delete array1 ; // Важно не забывать возвращать выделенную память системе. for (int i = 0 ; i < 16 ; ++ i ) delete array2 [ i ]; // Возвращаем память, используемую для строк матрицы. delete array2 ; // Возвращаем память, используемую для столбцов матрицы.

  Гетерогенные массивы

  Гетерогенным называется массив, в разные элементы которого могут быть непосредственно записаны значения, относящиеся к различным типам данных . Массив, хранящий указатели на значения различных типов, не является гетерогенным, так как собственно хранящиеся в массиве данные относятся к единственному типу - типу «указатель». Гетерогенные массивы удобны как универсальная структура для хранения наборов данных произвольных типов. Реализация гетерогенности требует усложнения механизма поддержки массивов в трансляторе языка.

  Реализация

  Одним из способов реализации статических массивов с одним типом элементов является следующий (в

  До сих пор мы работали с простыми типами данных – логический (boolean), целый (integer , word , byte , longint), вещественный (real), символьный (char). Любой алгоритм можно запрограммировать с помощью этих четырех базовых типов. Но для обработки информации о многообразном реальном мире требуются данные, имеющие более сложное строение. Такие сложные конструкции, основанные на простейших скалярных типах, называются структурами. Структура – некоторый составной тип данных, составленный из базовых скалярных. Если структура не изменяет своего строения на протяжении всего выполнения программы, в которой она описана, то такую структуру называют статической.

  Массив – однородная совокупность элементов

  Самой распространенной структурой, реализованной практически во всех языках программирования, является массив.

  Массивы состоят из ограниченного числа компонент, причем все компоненты массива имеют один и тот же тип, называемый базовым. Структура массива всегда однородна. Массив может состоять из элементов типа integer , real или char , либо других однотипных элементов. Из этого, правда, не следует делать вывод, что компоненты массива могут иметь только скалярный тип.

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

  Индекс массива

  Номер элемента массива называется индексом . Индекс – это значение порядкового типа, определенного, как тип индекса данного массива. Очень часто это целочисленный тип (integer , word или byte), но может быть и логический и символьный.

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

  Type < имя _ типа >= array [ I ] of T;

  где I – тип индекса массива, T – тип его элементов.

  Можно описывать сразу переменные типа массив, т.е. в разделе описания переменных:

  Var a,b: array [ I ] of T;

  Обычно тип индекса характеризуется некоторым диапазоном значений любого порядкового типа: I 1 .. I n . Например, индексы могут изменяться в диапазоне 1..20 или " a ".." n ".

  При этом длину массива Паскаля характеризует выражение:

  ord (I n)- ord (I 1)+1.

  Вот, например, объявление двух типов: vector в виде массива Паскаля из 10 целых чисел и stroka в виде массива из 256 символов:

  Type
  Vector=array of integer;
  Stroka=array of char;

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

  Опишем переменные типа vector и stroka:

  Вычисление индекса массива Паскаля

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

  Этот механизм – весьма мощное средство программирования. Но он порождает распространенную ошибку: результат вычислений может оказаться за пределами интервала допустимых значений индекса, то есть будет произведена попытка обратиться к элементу, которого не существует. Эта типичная ошибка называется «выход за пределы массива».

  Пример программы с ошибкой массива Паскаля

  Program primer _ error ;
  Type
  vector=array of word;
  var
  n: integer;
  a: vector;
  begin
  n:=45;
  a:=25;
  end .

  Хотя данная программа полностью соответствует синтаксису языка, и транслятор «пропустит» ее, на стадии выполнения произойдет ошибка выхода за пределы массива Паскаля. При n =45 выражение n *2=90, компьютер сделает попытку обратиться к элементу массива a , но такого элемента нет, поскольку описан массив размерностью 80.

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

  Из всего этого следует сделать вывод: программисту надо быть очень аккуратным при работе с индексами массива.

  Основные действия с массивами Паскаля

  Как известно, определение типа данных означает ограничение области допустимых значений, внутреннее представление в ЭВМ, а также набор допустимых операций над данными этого типа. Мы определили тип данных как массив Паскаля. Какие же операции определены над этим типом данных? Единственное действие, которое можно выполнять над массивами целиком, причем только при условии, что массивы однотипны, – это присваивание. Если в программе описаны две переменные одного типа, например,

  Var
  a , b: array of real ;

  то можно переменной a присвоить значение переменной b (a:= b). При этом каждому элементу массива a будет присвоено соответствующее значение из массива b . Все остальные действия над массивами Паскаля производятся поэлементно (это важно!) .

  Ввод массива Паскаля

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

  Пример фрагмента программы ввода массива Паскаля

  Var
  A: array of integer ;
  Begin
  For i:=1 to 10 do
  Readln (a[i]); { ввод i- го элемента производится с клавиатуры }

  Рассмотрим теперь случай, когда массив Паскаля заполняется автоматически случайными числами, для этого будем использовать функцию random (N).

  Пример фрагмента программы заполнения массива Паскаля случайными числами

  Var
  I: byte ; {переменная I вводится как индекс массива}
  Begin
  For i:=1 to 10 do
  A [ i ]:= random (10); { i -му элементу массива присваивается «случайное» целое число в диапазоне от 0 до 10}

  Вывод массива Паскаля

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

  Пример фрагмента программы вывода массива Паскаля

  Var
  A: array of integer;
  I: byte ; {переменная I вводится как индекс массива}
  Begin
  For i:=1 to 10 do
  Write (a [ i ]," "); {вывод массива осуществляется в строку, после каждого элемента печатается пробел}

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

  Пример программы вывода массива Паскаля в столбик

  Var
  A: array of integer;
  I: byte ; {переменная I вводится как индекс массива}
  Begin
  For i:=1 to 10 do
  Writeln ("a[", i,"]=", a[i]); { вывод элементов массива в столбик }

  На экране мы увидим, к примеру, следующие значения:

  a =2
  a =4
  a =1 и т.д.
  

  Пример решения задачи с использованием массивов Паскаля

  Задача: даны два n -мерных вектора. Найти сумму этих векторов.

  Решение задачи:

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

    var a , b: array of integer ;

  • Выходными данными будут элементы результирующего массива, назовем его c . Тип результирующего массива также должен быть целочисленным.
  • Кроме трех массивов нам потребуется переменная – параметр цикла и индекс массива, назовем ее i , а также переменная n для определения количества элементов в каждом массиве.

  Ход решения задачи:

  • определим количество элементов (размерность) массивов, введем значение n ;
  • введем массив a ;
  • введем массив b ;
  • в цикле, перебирая значения индекса i от 1 до n , вычислим последовательно значения элементов массива c по формуле:

    c [ i ]= a [ i ]+ b [ i ];

  • выведем на экран полученный массив.

  Текст программы:

  Пример программы суммирования векторов

  Program summa;
  Var
  a, b, c: array of integer;
  I, n: byte;
  Begin
  Write ("введите размерность массивов:");
  Readln(n);
  For i:=1 to n do
  Readln (a[i]); { ввод массива a}
  For i:=1 to n do
  Readln (b[i]); { ввод массива b}
  For i:=1 to n do
  C[i]:=a[i]+b[i]; { вычисление суммы массивов }
  For i:=1 to n do
  write (c[i]," "); { вывод массива с }
  end.

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

  Массив в программировании

  Чтобы добиться понимания, начнем с самого простого определения массива.

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

  Для наглядности приведем пример из жизни. Так список студентов в журнале будет представлять собой массив. Порядковый номер каждого студента (обычно они идут по алфавиту, т.е. фамилии на "А" будут первыми) - это его индекс.

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

  Массивы используют для решения различных задач программирования.

  Виды массивов

  Можно говорить о двух видах массивов:

  1. одномерные;
  2. многомерные.

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

  • Чтобы нагляднее представить, что такое одномерный массив, представим тетрадный листок в клетку. Так, любая линия по вертикали или горизонтали (а можно и по диагонали) - вот он, одномерный массив. А количество клеточек будет определять размерность данного одномерного массива. В каждый элемент (клеточку) можно записать значение (например, число), но только одно (!). Найти это значение можно, указав его порядковый номер (в квадратных скобочках).
  • Рассмотрим, что такое массив двумерный все на том же примере тетрадного листка в клеточку. Несколько клеток по горизонтали, несколько по вертикали - и у нас образуется некоторая прямоугольная табличка (о квадратной читайте ниже). Она и будет двумерным массивом. Здесь можно говорить о строках матрицы (клетки по вертикали) и столбцах (соответственно, горизонтальные клетки). Как и в массиве одномерном, в каждой клеточке хранится одно значение. Отличие - в поиске нужного значения. Здесь уже нужно указывать номер строчки и номер столбца, пересечение которых даст нужный нам элемент.

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

  В квадратной матрице есть два вида диагоналей:

  1. главная - из верхнего левого уголка в нижний правый (т.е. где номер строки и столбца совпадает);
  2. побочная - идет из верхнего правого уголка в нижний левый.

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

  Итак, жильцы подъезда, - пусть это будет массив под именем К.

  Индекс здесь - номер квартиры. Этот элемент (квартира) представляет собой еще один массив - жильцы квартиры. Например, в 1-ой квартире живер 4 человека, во 2-ой - 3 человека, в 3-ей - 5 человек.

  Так, одномерный массив - это перечисление в квадратных скобках (!) количества жильцов: 4, 3, 5.

  Двумерный массив (вместо квадр. скобок у нас будет "*"): **1, 1, 1, 1*, *1,1,1*, *1, 1, 1, 1, 1**

  Собственно и все. А о том, что такое raid-массив, Вы можете прочитать .

  Массив - это набор элементов (компонентов), которые имеют одинаковый . Причём этот тип данных может быть как простым, так и сложным.

  Элементы массива в памяти компьютера расположены друг за другом. Получить доступ к отдельному элементу массива можно по индексу этого элемента.

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

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

  Наиболее часто используются одномерные и двухмерные массивы. Реже - трёхмерные. Массивы с большей размерностью я использовать не рекомендую (особенно новичкам), так как это чревато большим количеством труднонаходимых ошибок.

  В качестве индекса массива может использоваться переменная. Эта переменная должна обязательно иметь .

  Некоторые языки программирования и средства разработки имеют в своём арсенале динамические массивы, то есть массивы не с фиксированной, а с неопределённой размерностью.

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

  Синтаксис массива в Паскале:

  var ИмяМассива: array of ТипДанных;

  Здесь ИмяМассива - это имя переменной, связанной с этим массивом. ТипДанных - это тип данных элементов массива. Пример:

  var M1: array of byte;

  Здесь мы объявили массив с именем М1 , который содержит 16 элементов типа byte с индексами от 0 до 15. первый элемент массива имеет индекс 0, второй - индекс 1 и так далее.

  Работать с отдельным элементом массива можно так:

  var m: byte;
  M1 := 100;
  m:= M1;

  Здесь мы сначала в первый элемент массива записываем значение 100, а потом в переменную m записываем значение первого элемента массива. Догадайтесь, какое значение будет в переменной m после этого))).

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

  for i:= 0 to 15 do M1[i] := i;
  for i:= 0 to 15 do Write(M1[i], " ");

  Надеюсь, не надо объяснять, что делает этот код. А теперь представьте, сколько бы строк кода вам пришлось написать, если бы то же самое вы делали с помощью обычных переменных.

  Двухмерный массив объявляется так:

  M2: array of byte;

  Это будет матрица (или таблица) 4х2. То есть такой массив имеет некоторое количество строк (в нашем примере 4) и некоторое количество столбцов (в нашем примере 2). Того же результата можно достичь, если объявить массив массивов:

  M2e: array of array of byte;

  Здесь новичкам обычно трудно сообразить, что со всем этим “многомерьем” делать. Ну ничего, привыкайте. Первый массив - это строки таблицы. Второй - это столбцы. То есть каждый элемент первого массива содержит массив array. Таблица (матрица), представленная нашим примером, выглядит так:

  
  

  Таким образом,

  М2 - это ячейка 1.1 (первая строка, первый столбец)
  М2 - это ячейка 1.2 (первая строка, второй столбец)
  М2 - это ячейка 2.1 (вторая строка, первый столбец)

  Если вы попробуете использовать, например, М2 , то компилятор выдаст предупреждение, так как столбца 3 в нашем массиве не существует. Однако будьте осторожны! В некоторых средствах разработки программа при этом будет создана (зависит от настроек среды)! И вы можете получить ошибку, которую в последствии будет трудно обнаружить.

  А теперь пример использования нашего двухмерного массива:

  //Заполняем массив for i:= 1 to 4 do for j:= 1 to 2 do M2 := i * 10 + j; //Выводим массив на экран for i:= 1 to 4 do for j:= 1 to 2 do Write(M2, " ");

  Как видите, здесь мы используем ДВЕ индексных переменных (i и j ) и вложенные . Как работают вложенные циклы - попробуйте догадаться сами. Если не получится - задайте вопрос в разделе . Этот раздел я стараюсь проверять хотя бы раз в день.

  Надеюсь, с этим кодом вы разобрались. Или хотя бы запустили его и посмотрели, что он делает. А он выводит двухмерный массив на экран. Но вывод выполняется в одну строку. И это не очень удобно для двухмерного массива. Ведь обычно в таких массивах представлены матрицы (таблицы). То есть удобнее воспринимать информацию, если она будет выводиться в виде таблицы. В нашем случае хотелось бы получить 4 строки и 2 столбца.

  Попробуйте решить эту задачу самостоятельно. А если у вас не получится, то вот один из вариантов решения:

  For i:= 1 to 4 do for j:= 1 to 2 do case j of 1: Write(M2, " "); 2: WriteLn(M2, " "); end;

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

  Const k = 8; //Количество столбцов var i, j: byte; M2f: array of array of byte; //Заполняем массив for i:= 1 to 4 do for j:= 1 to k do M2f := i * 10 + j; //Выводим таблицу for i:= 1 to 4 do for j:= 1 to k do case j of k: WriteLn(M2f, " "); else Write(M2f, " "); end;

  Изучите внимательно этот пример и найдите все участки кода, где используется константа k . Дальше, надеюсь, вы разберётесь с этим кодом самостоятельно.

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

  WriteLn("Индекс первого элемента М1: ", Low(M1));
  WriteLn("Индекс последнего элемента М1: ", High(M1));

  Статья получилась больше, чем я ожидал. Но надеюсь, у вас хватило терпения дочитать её до конца...