Под структурой данных типа массив понимают совокупность индексированных упорядоченных однотипных элементов, имеющих общее имя. Массивы используются для хранения однородной по составу информации: элементов таблиц, коэффициентов уравнений, матриц. Элементами массива могут быть данные различных типов, включая структурированные. каждый элемент массива однозначно определяется именем массива и индексом(номером этого элемента в массиве) или индексами, если массив многомерный.
Количество индексных позиций определяет размерность массива (одномерный, двумерный и т.д.). Индексы элементов массива должны принадлежать порядковому типу.
К типовым операциям с массивами относятся:
поиск в массиве
7.1.1. Одномерный массив Объявление массива.Перед использованием массив, как и любая переменная, должен быть объявлен в разделе объявления переменных. В общем виде объявление массива выглядит так:
Имя: аrrау [нижний индекс ..верхний индекс]ofТип;
где Имя — имя переменной-массива;
Информатика. Язык Pascal: Массивы в Pascal. Центр онлайн-обучения «Фоксфорд»
аrrау -ключевое слово, обозначающее, что переменная является
нижний_индексиверхний_индекс -целые числа, определяющие диапазон изменения индексов (номеров) элементов массива и, неявно, количество
элементов (размер) массива;
Тип — тип элементов массива.
Объявление массива осуществляется одним из следующих способов:
a) в разделе описания переменных
a : array [1..5] of byte;
b : array [1..3] of integer;
z : array [‘d’..’g’] of char;
name:array[1..30]of string[25];
б) с помощью типизированной переменной
mar =array[1..5] of byte;
При описании массивов в программе удобно использовать именованные константы как значения верхних границ индексов массива.
Именованная константа объявляется в разделе описания констант, который располагают перед разделом объявления переменных. Начинается раздел объявления констант словом const.
b : array [1..n ] of integer;
temp: array[1..s] of string[25];
Каждая отдельная величина массива называется элементом. Тип элементов может быть любым, принятым в языке Pascal, кроме файлового типа.
Тип элементов называется базовым типом. Вся совокупность элементов определяется одним именем. Для обозначения отдельных элементов массива используется конструкция, называемая переменной с индексом или с индексами: a[5]s[k+1]b[3,5]
Чтобы использовать элемент массива, нужно указать имя массива и индекс элемента. Первый индекс обычно соответствует номеру строки таблицы второй — номеру колонки.
В качестве индекса может быть использовано выражение. Тип индексов может быть только целым, интервальным или перечисляемым b. Индексы интервального типа, для которого базовым является целый тип, могут принимать отрицательные, нулевое и положительные значения.
Ввод массива. Под вводом массива понимается ввод значений элементов массива. Для ввода или вывода массива в список ввода или вывода помещается переменная с индексом, а операторы ввода или вывода выполняются в цикле.
Двумерный массив что это. Многомерные массивы. Пример. Теория. Что такое массив. Array. C++ #30
Чтобы пользователь программы знал, ввода какого элемента массива ожидает программа, следует организовать вывод подсказок перед вводом очередного элемента массива. В подсказке обычно указывают индекс элемента массива. 1
1) Ввод элементов одномерного массива с помощью клавиатуры:
for i:=1 to n do
2) Ввод элементов одномерного массива с помощью типизированных констант.
Ввод элементов массива с помощью констант называется еще инициализацией массива.
A1 : array [1..6] of integer = (-5,8,5,0,7,-8);
A2 : array [ 1..3] of char = (‘a’,’b’,’c’);
б) type
Dim10= array[1..10] of Real;
raM10:Dim10 = ( 0, 2.1, 4, 5.65, 6.1, 6.7, 7.2, 8, 8.7, 9.3 );
3) Ввод элементов одномерного массива с помощью датчика случайных чисел
for i:=1 to 10 do
В этом случае значениями элементов массива a[i] будут произвольные значения от 0 до 19 .Для того чтобы получились дробные числа нужно в функцииrandomопустить параметр.
Источник: studfile.net
Массивы
Массив — это набор элементов (компонентов), которые имеют одинаковый тип данных. Причём этот тип данных может быть как простым, так и сложным.
Элементы массива в памяти компьютера расположены друг за другом. Получить доступ к отдельному элементу массива можно по индексу этого элемента.
Любой массив имеет фиксированный размер. Таким образом, размерность массива — это количество индексов, необходимое для однозначного доступа к элементу массива.
Массив может быть как одномерным, так и многомерным. Например, таблица — это двухмерный массив (строки таблицы — это одна размерность массива, столбцы таблицы — вторая). Разумеется, таблицу можно представить как два одномерных массива. Но легче работать с одним массивом, нежели с двумя.
Наиболее часто используются одномерные и двухмерные массивы. Реже — трёхмерные. Массивы с большей размерностью я использовать не рекомендую (особенно новичкам), так как это чревато большим количеством труднонаходимых ошибок.
В качестве индекса массива может использоваться переменная. Эта переменная должна обязательно иметь порядковый тип.
Некоторые языки программирования и средства разработки имеют в своём арсенале динамические массивы, то есть массивы не с фиксированной, а с неопределённой размерностью.
Зачем нужны массивы? Ответ простой — для удобства (как, впрочем, и все языковые конструкции). Во многих случаях работать с массивом данных более удобно, чем с отдельными переменными.
Синтаксис массива в Паскале:
var ИмяМассива : array[0..15] of ТипДанных;
Здесь ИмяМассива — это имя переменной, связанной с этим массивом. ТипДанных — это тип данных элементов массива. Пример:
var M1 : array[0..15] of byte;
Здесь мы объявили массив с именем М1, который содержит 16 элементов типа byte с индексами от 0 до 15. первый элемент массива имеет индекс 0, второй — индекс 1 и так далее.
Работать с отдельным элементом массива можно так:
var m : byte;
M1[0] := 100;
m := M1[0];
Здесь мы сначала в первый элемент массива записываем значение 100, а потом в переменную m записываем значение первого элемента массива. Догадайтесь, какое значение будет в переменной m после этого))).
Но понять всю прелесть использования массивов вы сможете только тогда, когда попробуете обработать все элементы массива в цикле. Например, так:
for i := 0 to 15 do M1[i] := i;
for i := 0 to 15 do Write(M1[i], ‘ ‘);
Надеюсь, не надо объяснять, что делает этот код. А теперь представьте, сколько бы строк кода вам пришлось написать, если бы то же самое вы делали с помощью обычных переменных.
Двухмерный массив объявляется так:
M2 : array[1..4, 1..2] of byte;
Это будет матрица (или таблица) 4х2. То есть такой массив имеет некоторое количество строк (в нашем примере 4) и некоторое количество столбцов (в нашем примере 2). Того же результата можно достичь, если объявить массив массивов:
M2e : array[1..4] of array[1..2] of byte;
Здесь новичкам обычно трудно сообразить, что со всем этим “многомерьем” делать. Ну ничего, привыкайте. Первый массив — это строки таблицы. Второй — это столбцы. То есть каждый элемент первого массива содержит массив array[0..1]. Таблица (матрица), представленная нашим примером, выглядит так:
| Строка 1, Столбец 1 | Строка 1, Столбец 2 |
| Строка 2, Столбец 1 | Строка 2, Столбец 2 |
| Строка 3, Столбец 1 | Строка 3, Столбец 2 |
| Строка 4, Столбец 1 | Строка 4, Столбец 2 |
М2[1, 1] — это ячейка 1.1 (первая строка, первый столбец)
М2[1, 2] — это ячейка 1.2 (первая строка, второй столбец)
М2[2, 1] — это ячейка 2.1 (вторая строка, первый столбец)
Если вы попробуете использовать, например, М2[1, 3], то компилятор выдаст предупреждение, так как столбца 3 в нашем массиве не существует. Однако будьте осторожны! В некоторых средствах разработки программа при этом будет создана (зависит от настроек среды)! И вы можете получить ошибку, которую в последствии будет трудно обнаружить.
А теперь пример использования нашего двухмерного массива:
//Заполняем массив for i := 1 to 4 do for j := 1 to 2 do M2[i, j] := i * 10 + j; //Выводим массив на экран for i := 1 to 4 do for j := 1 to 2 do Write(M2[i, j], ‘ ‘);
Как видите, здесь мы используем ДВЕ индексных переменных (i и j) и вложенные циклы. Как работают вложенные циклы — попробуйте догадаться сами. Если не получится — задайте вопрос в разделе ВОПРОСЫ. Этот раздел я стараюсь проверять хотя бы раз в день.
Надеюсь, с этим кодом вы разобрались. Или хотя бы запустили его и посмотрели, что он делает. А он выводит двухмерный массив на экран. Но вывод выполняется в одну строку. И это не очень удобно для двухмерного массива.
Ведь обычно в таких массивах представлены матрицы (таблицы). То есть удобнее воспринимать информацию, если она будет выводиться в виде таблицы. В нашем случае хотелось бы получить 4 строки и 2 столбца.
Попробуйте решить эту задачу самостоятельно. А если у вас не получится, то вот один из вариантов решения:
for i := 1 to 4 do for j := 1 to 2 do case j of 1 : Write(M2[i, j], ‘ ‘); 2 : WriteLn(M2[i, j], ‘ ‘); end;
Это решение не является универсальным, так как его сложно применить к массивам с другой размерностью (с другим количеством столбцов). Но зато оно простое. И во многих случаях его можно использовать.
const k = 8; //Количество столбцов var i, j : byte; M2f : array[1..4] of array[1..k] of byte; //Заполняем массив for i := 1 to 4 do for j := 1 to k do M2f[i, j] := i * 10 + j; //Выводим таблицу for i := 1 to 4 do for j := 1 to k do case j of k : WriteLn(M2f[i, j], ‘ ‘); else Write(M2f[i, j], ‘ ‘); end;
Изучите внимательно этот пример и найдите все участки кода, где используется константа k. Дальше, надеюсь, вы разберётесь с этим кодом самостоятельно.
Ну и напоследок добавлю, что для определения индексов массива можно использовать уже известные нам по первым урокам стандартные функции Low и High. Например, так:
WriteLn(‘Индекс первого элемента М1 : ‘, Low(M1));
WriteLn(‘Индекс последнего элемента М1 : ‘, High(M1));
Статья получилась больше, чем я ожидал. Но надеюсь, у вас хватило терпения дочитать её до конца.
Источник: info-master.su
Как выглядит массив в программе
Нередко возникает необходимость работы не с одиночными данными, а с наборами данных. И для этого в языке Си применяются массивы. Массив представляет набор однотипных значений. Объявление массива выглядит следующим образом:
тип_переменной название_массива [длина_массива]
После типа переменной идет название массива, а затем в квадратных скобках его размер. Например, определим массив из 4 чисел:
int main(void)
Используя номера элементов массиве, которые называются индексами, мы можем обратиться к отдельным элементам. Например:
#include int main(void) < int numbers[4]; numbers[0] = 1; numbers[1] = 2; numbers[2] = 3; numbers[3] = 4; printf(«numbers[0] = %d n», numbers[0]); // 1 — первый элемент printf(«numbers[2] = %d n», numbers[2]); // 3 — третий элемент return 0; >
Индексы указываются в квадратных скобках после названия массива и начинаются с нуля, поэтому для обращения к первому элементу необходимо использовать выражение numbers[0] .
Также мы можем сразу объявить и инициализировать массив значениями. Для этого переменной массива присваивается набор значений через запятую в фигурных скобках:
int numbers[4] = < 1, 2, 3, 5 >; // инициализация массива printf(«numbers[2] = %d», numbers[2]); // 3
То есть в данном случае у нас будет следующее соответствие между значениями элементов и их индексами:
| Значение | 1 | 2 | 3 | 5 |
| Индекс | 1 | 2 | 3 |
При инициализации массива можно явно не указывать его длину, в этом случае длина массива будет вычисляться исходя из количества его элементов:
int numbers[] = < 1, 2, 3, 5 >;
Используя циклические конструкции, можно перебрать массив:
#include int main(void) < int numbers[] = < 10, 12, 13, 54, 43 >; for(int i =0; i < 5; i++) < printf(«numbers[%d] = %d n», i, numbers[i]); >return 0; >
При этом необязательно инициализировать массив значениями для всех его элементов:
int numbers[5] = < 10, 12>; // 10, 12, 0, 0, 0
В данном случае в рамках инициализации предоставляются значения для двух первых элементов, остальные элементы по умолчанию получают значение 0.
Многомерные массивы
Массивы могут быть многомерными. Элементы таких массивов сами в свою очередь являются массивами, в которых также элементы могут быть массивами. В большинстве случаев многмерные массивы представляют двухмерные массивы, которые можно представить в виде таблицы. Например, определим двухмерный массив чисел:
int numbers[3][2] = < , , >;
Здесь массив numbers имеет три элемента (3 строки), но каждый из этих элементов сам представляет массив из двух элементов (2 столбцов). Такой массив еще можно представить в виде таблицы:
| 1 | 2 |
| 4 | 5 |
| 7 | 8 |
И чтобы обратиться к элементам вложенного массива, потребуется два индекса:
int numbers[3][2] = < , , >; printf(«numbers[1][0] = %d n», numbers[1][0]); // 4
другой пример, двухмерный массив с двумя строками и тремя столбцами:
int numbers[2][3] = < , >;
Такой массив графически можно представить следующим образом:
| 1 | 2 | 4 |
| 5 | 7 | 8 |
Для перебора двухмерного массива применются вложенные циклы:
#include int main(void) < int numbers[3][2] = < , , >; // проходим по 3 строкам таблицы for(int i =0; i < 3; i++) < // проходим по 2 столбцам каждой строки for(int j =0; j> return 0; >
Строки
Выше рассматривались массивы чисел, но с массивами остальных типов данных все будет аналогично. Но отдельно стоит остановиться на массивах символов.
В различных языках программирования есть специальные типы данных для представления строк. В языке программирования Си для представления строк используются массивы символов, ведь по сути строка — это и есть набор символов. Например, определим строку:
#include int main(void) < char message[] = «Hello»; printf(«message: %s n», message); // message: Hello return 0; >
Строки определяются в двойных кавычках. И если нам в программе нужны строки, то как раз можно использовать массивы символов.
Но стоит отметить, что кроме самих символов, которые заключены двойные кавычки, каждая строка в качестве завершающего символа содержит символ или нулевой символ (нулевой байт). Он же самый первый символ из таблицы ASCII. В Си нулевой байт служит признаком окончания строки. Поэтому в строке «Hello» на самом деле будет не 5 символов, а 6.
| H | e | l | l | o |
К примеру, переберем все символы строки и выведем их десятичный код ASCII:
char message[] = «Hello»; for(int i=0; i
На консоли при запуске программы мы сможем увидеть в конце нулевой символ:
72 101 108 108 111 0
Если бы мы определяли массив message не как строку, а именно как массив символов, то последним элементом должен был бы идти нулевой символ:
char message[] = ;
Размер и количество элементов массива
Не всегда в программе может быть известен размер массива. В этом случае можно использовать оператор sizeof , который возвращает размер массива в байтах.
#include int main(void) < int numbers[] = < 5, 6, 7>; int size = sizeof(numbers); printf(«numbers size: %d n», size); // numbers size: 12 return 0; >
В этом примере оператор sizeof() для массива < 5, 6, 7>возвращает 12 байт (так как массив содержит 3 значения типа int, которое обычно занимает 4 байта).
Используя размер типа, мы можем получить количество элементов в массиве:
#include int main(void) < int numbers[] = < 5, 6, 7>; int size = sizeof(numbers); int count = sizeof(numbers) / sizeof(int); printf(«numbers size: %d n», size); // numbers size: 12 printf(«numbers count: %d n», count); // numbers count: 3 return 0; >
Также можно получить количество элементов в массиве, разделив его размер на размер первого элемента:
#include int main(void) < int numbers[] = < 5, 6, 7>; int size = sizeof(numbers); int count = sizeof(numbers) / sizeof(numbers[0]); printf(«numbers size: %d n», size); // numbers size: 12 printf(«numbers count: %d n», count); // numbers count: 3 return 0; >
Динамическая установка размера массива
Размер массива можно установить динамически с помощью переменной/константы:
#include int main(void) < int maxSize = 3; int array[maxSize]; array[0] = 1; array[1] = 2; array[2] = 3; for (int i = 0; i < maxSize; i++) < printf(«%d», array[i]); >return 0; >
Стоит отметить, что при динамической установке нельзя при определении инициализировать массив:
int maxSize = 3; int array[maxSize] = ; // ! Ошибка, так нельзя
Задачи с массивы
Рассмотрим работу с массивами на примере умножения матриц:
#include int main(void) < const int r1 = 3, c1r2=2, c2=1; int matrix1[3][2] = ,,>; int matrix2[2][1] = ,>; int matmult[r1][c2]; // инициализируем результирующую матрицу for(int i=0;i > for(int i=0;i > > printf(«Result n»); for(int i=0;i printf(«n»); > >
Здесь у нас определены две матрицы. Матрица matrix1[3][2] имеет три строки и два столбца:
| 1 | 2 |
| 3 | 4 |
| 5 | 6 |
Вторая матрица фактически состоит из одно столбца:
| 10 |
| 20 |
Для хранения размера столбцов и строк определены переменные
const int r1 = 3, // число строк в 1-й матрице c1r2=2, // число строк в 1-й и число столбцов во 2-й матрице c2=1; // число столбцов во 2-й матрице
Также определяем результирующую матрицу — результат произведения — matmul:
int matmult[r1][c2];
И инициализируем ее нулями.
При произведении матриц мы получаем матрицу, где количество строк равно количеству строк первой матрицы, а количество столбцов — количеству столбцов второй матрицы. А элемент результирующей матрицы на i-й строке j-м столбце равен сумме произведений элементов на i-й строке первой матрицы на соответствующие элементы j-го столбца второй матрицы.
c2,1 = a2,1 * b1,1 + a2,2 * b2,1
Соответственно при вычислении произведения в цикле по i проходим по всем строкам первой матрицы:
for(int i=0;i
Далее в цикле по j проходим по всем столбцам второй матрицы:
for(int j=0;j
В цикле по k умножаем значения из k-столбца первой матрицы на значения k-строки второй матрицы и прибавляем к результату:
for(int k=0;k
В результате мы получим матрицу из трех строк и одного столбца:
Источник: metanit.com