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

Энциклопедичный 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 ; // Возвращаем память, используемую для столбцов матрицы.

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

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

  Реализация

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

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

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

  ü Внимание! Особенность обозначения элементов массива в Си - нумерация индексов от 0, а не от 1. Поэтому индексы в Си на единицу меньше заданных математически. Это обстоятельство должно учитываться в программе, особенно при формировании условия повторения (выхода из) цикла.

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

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

  · символьный – 1 байт;

  · целочисленный – 2 байта;

  · вещественный – 4 байта;

  · двойной точности – 8 байт.

  Структура обозначения индексированной переменной одномерного массива:

  имя[индекс]

  Где имя – идентификатор массива;

  индекс – операнд целого типа, определяющий номер элемента в ряду других, составляющих массив;

  – ограничители индекса.

  Например, в описанном ранее массиве D(16) первый элемент обозначается индексным выражением d, второй – d, текущий – d[i], предпоследний – d и последний – d.

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

  Рассмотренный пример идентификации элементов массива D применим к любому из описанных одномерных массивов.

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

  Адрес любой переменной определяется операцией & . Следовательно, у элемента d адрес – &d, у d[i] – &d[i], т.е. все элементы массива располагаются в оперативной памяти линейно, начиная с адреса &d.

  В языке Си идентификатор одномерного массива однозначно определяет адрес его первого элемента. Например, c º &c, d º &d.

  Адрес каждого элемента одномерного массива выражается зависимостью имя+индекс (индекс определяет сдвиг элемента относительно первого на указанное им количество элементов). Например, &c[i] (адрес i-го элемента массива С) вычисляется как c+i.

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

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

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

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

  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.

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

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

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

  Массив характеризуется следующими основными понятиями:

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

  • адресом элемента — адресом начальной ячейки памяти, в которой расположен этот элемент;
  • индексом элемента (порядковым номером элемента в массиве);
  • значением элемента.

  Адрес массива – адрес начального элемента массива.

  Имя массива – идентификатор, используемый для обращения к элементам массива.

  Размер массива – количество элементов массива

  Размер элемента – количество байт, занимаемых одним элементом массива.

  Графически расположение массива в памяти компьютера можно представить в виде непрерывной ленты адресов.
  

  Представленный на рисунке массив содержит q элементов с индексами от 0 до q-1 . Каждый элемент занимает в памяти компьютера k байт, причем расположение элементов в памяти последовательное.

  Адреса i -го элемента массива имеет значение

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

  Длина массива – количество байт, отводимое в памяти для хранения всех элементов массива.

  ДлинаМассива = РазмерЭлемента * КоличествоЭлементов

  Для определения размера элемента массива может использоваться функция
  

  int sizeof (тип);
  

  Например,
  

  sizeof (char ) = 1;
  sizeof (int ) = 4;
  sizeof (float ) = 4;
  sizeof (double ) = 8;
  

  Объявление и инициализация массивов

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

  тип имя[размерность]={инициализация};

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

  int a = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}; // массив a из 10 целых чисел
  

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

  int b = {0}; // массив b из 10 элементов, инициализированных 0
  

  
  

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

  int a = {1, 2, 3, 4, 5, 6, 7, 8, 9};
  

  При обращении к элементам массива индекс требуемого элемента указывается в квадратных скобках .

  Пример на Си
  

  1
  2
  3
  4
  5
  6
  7
  8

  #include
  int main()
  {
  int a = { 5, 4, 3, 2, 1 }; // массив a содержит 5 элементов
  printf("%d %d %d %d %d\n" , a, a, a, a, a);
  getchar();
  return 0;
  }
  

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

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

  int a;
  

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

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

  
  #include
  int main()
  {
  int a;
  int i;
  // Ввод элементов массива
  for (i = 0; i<5; i++)
  {
  printf("a[%d] = " , i);
  scanf("%d" , &a[i]);
  }
  // Вывод элементов массива
  for (i = 0; i<5; i++)
  printf("%d " , a[i]); // пробел в формате печати обязателен
  getchar(); getchar();
  return 0;
  }
  

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

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

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

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

  тип имя[размерность1][размерность2]...[размерностьm];
  

  Элементы многомерного массива располагаются в последовательных ячейках оперативной памяти по возрастанию адресов. В памяти компьютера элементы многомерного массива располагаются подряд, например массив, имеющий 2 строки и 3 столбца,
  

  int a;
  

  
  будет расположен в памяти следующим образом

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

  КоличествоСтрок * КоличествоСтолбцов = 2 * 3 = 6.

  Количество байт памяти, требуемых для размещения массива, определится как

  КоличествоЭлементов * РазмерЭлемента = 6 * 4 = 24 байта.

  Инициализация многомерных массивов

  Значения элементов многомерного массива, как и в одномерном случае, могут быть заданы константными значениями при объявлении, заключенными в фигурные скобки {} . Однако в этом случае указание количества элементов в строках и столбцах должно быть обязательно указано в квадратных скобках .

  Пример на Си
  

  1
  2
  3
  4
  5
  6
  7
  8
  9

  #include
  int main()
  {
  int a = { 1, 2, 3, 4, 5, 6 };
  printf("%d %d %d\n" , a, a, a);
  getchar();
  return 0;
  }
  

  
  
  

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

  Пример на Си
  

  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

  #define _CRT_SECURE_NO_WARNINGS
  #include
  int main()
  {
  int a; // массив из 2 строк и 3 столбцов
  int i, j;
  // Ввод элементов массива
  for (i = 0; i<2; i++) // цикл по строкам
  {
  for (j = 0; j<3; j++) // цикл по столбцам
  {
  printf("a[%d][%d] = " , i, j);
  scanf("%d" , &a[i][j]);
  }
  }
  // Вывод элементов массива
  for (i = 0; i<2; i++) // цикл по строкам
  {
  for (j = 0; j<3; j++) // цикл по столбцам
  {
  printf("%d " , a[i][j]);
  }
  printf("\n" ); // перевод на новую строку
  }
  getchar(); getchar();
  return 0;
  }
  

  
  
  

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

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

  • адрес массива,
  • размер массива.

  Исключение составляют функции обработки строк, в которые достаточно передать только адрес.

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

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

  Пример на Си Дан массив из 10 элементов. Поменять местами наибольший и начальный элементы массива. Для операций поиска максимального элемента и обмена использовать функцию.
  

  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
  30
  31
  32
  33
  34
  35
  36
  37
  38
  39
  40
  41
  42

  #define _CRT_SECURE_NO_WARNINGS
  #include
  // Функция обмена
  void change(int *x, int n)
  {
  // x - указатель на массив (адрес массива)
  // n - размер массива
  int i;
  int max, index;
  max = x;
  index = 0;
  // Поиск максимального элемента
  for (i = 1; i {
  if (x[i]>max)
  {
  max = x[i];
  index = i;
  }
  }
  // Обмен
  x = x;
  x = max;
  }
  // Главная функция
  int main()
  {
  int a;
  int i;
  for (i = 0; i<10; i++)
  {
  printf("a[%d] = " , i);
  scanf("%d" , &a[i]);
  }
  change(a, 10); // вызов функции обмена
  // Вывод элементов массива
  for (i = 0; i<10; i++)
  printf("%d " , a[i]);
  getchar();
  getchar();
  return
  p = p * x[i];
  }
  return p;
  }
  // Главная функция
  int main()
  {
  int a; // объявлен массив a из 5 элементов
  int i;
  int pr;
  // Ввод элементов массива
  for (i = 0; i<5; i++)
  {
  printf("a[%d] = " , i);
  scanf("%d" , &a[i]); // &a[i] - адрес i-го элемента массива
  }
  pr = func(a, 5); // вычисление произведения
  printf("\n pr = %d" , pr); // вывод произведения четных элементов
  getchar(); getchar();
  return 0;
  }
  

  
  
  

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

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

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

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

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

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

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

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

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

  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));

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