Понятие массива в программировании. Что такое массив
Массив - это однородный, упорядоченный структурированный тип данных с прямым доступом к элементам. Элементы массива объединяются общим именем и занимают в компьютере определенную конечную область памяти. К любому элементу массива можно обратиться, указав имя массива и индекс элемента в массиве.
Одномерные и двумерные массивы
Если в массиве для обращения к элементам используется только один порядковый номер, то такой массив называется линейным, или одномерным . Одномерный массив можно представить в виде таблицы, в которой существует только одна строка.
Количество индексов элементов массива определяет размерность массива.
Массивы с двумя индексами называют двумерными . Такие массивы можно представить в виде таблицы, в которой номер строки соответствует первому индексу, а номер ячейки в строке (номер столбца) - второму индексу.
Чаще всего применяются одномерные массивы и двумерные массивы .
Объявление массива
Чтобы объявить массив (это необходимо для выделения памяти, в которой будут храниться значения элементов массива), следует указать его имя и размерность при помощи ключевого слова МАССИВ .
массив А
В данном примере будет объявлен одномерный массив А, состоящий из 10 элементов.
массив М
В данном примере будет объявлен двумерный массив М, который можно представить в виде таблицы, состоящей из 4-х строк по 5 ячеек в каждой строке.
Ограничение на размер одномерного массива - 1000 элементов, для двумерных - 1000х1000. В учебных целях лучше не использовать массивы более чем из 500 элементов, чтобы не замедлять время обработки. Все массивы в Game Logo имеют числовой тип (действительные числа).
Работа с массивами
После объявления массива каждый его элемент можно обработать, указав идентификатор (имя) массива и индекс элемента в квадратных скобках. Например, запись M позволяет обратиться ко второму элементу массива M.
При работе с двумерным массивом указываются два индекса. Например, запись
M делает доступным для обработки значение элемента, находящегося в третьей строке четвертого столбца массива M.
Индексированные элементы массива называются индексированными переменными и могут быть использованы так же, как и простые переменные. Например, они могут находиться в выражениях в качестве операндов или использоваться в качестве аргументов в командах.
Присваивание значений элементам массива
А = 15
Третьему элементу массива А будет присвоено значение 15.
М = 25
Элементу массива М, находящемуся во второй строке четвертого столбца, будет присвоено значение 25.
Ввести значение в элемент массива можно также при помощи команды СПРОСИ.
спроси А
Загрузить данные в массив можно при помощи команды ЗАГРУЗИ.
Примеры для одномерного массива А.
загрузи в A
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
конец загрузки
загрузи в A
1 2 3 4 5
6 7 8 9 10
11 12 13 14 15
конец загрузки
Если данных будет недостаточно, то часть элементов останется незаполненной. Если избыточно, то они отсекутся.
Пример для двумерного массива М.
загрузи в M
56 78 56 36 24 15 17 25 36 25
15 17 25 36 24 56 78 56 36 24
15 17 25 36 24 56 78 56 36 24
78 56 36 24 15 17 17 25 36 25
36 24 56 78 24 56 78 56 36 24
39 78 56 36 24 25 15 15 89 71
конец загрузки
Заполнение массива случайными числами
Заполнить массив случайными числами можно при помощи цикла.
Пример заполнения элементов массива А псевдослучайными целыми числами в диапазоне от 10 до 99:
массив А
переменная х
Повторить для х = 1 до 100 {
А[х] = Int(случайное * 89) + 10
}
Вывод значений элементов массива
ПИШИ A
На экран будет выведено значение третьего элемента одномерного массива А.
ПИШИ# A
Будут выведены значения всех элементов массива А.
Знак # в команде ПИШИ выводит массив целиком. Для одномерных массивов вывод осуществляется с переносом строк. Для двумерных - как есть в виде таблицы, поэтому возможен выход за пределы поля.
Вывод массива в графическом виде
Массив может быть выведен в виде ряда точек (или таблицы из точек для двумерных массивов), цвет которых соответствует значению элемента массива (диапазон от 0 до 15, все числа меньше 0 отображаются черным цветом, больше 15 - белым). Этот способ удобен для моделирования клеточных автоматов, для визуализации сортировки и во многих других случаях, когда требуется визуальное восприятие происходящего в массиве.
ТОЧКА# [, ]
Необязательные параметры и взяты в скобки. Они обеспечивают отступ от начала координат (верхнего левого угла).
точка# M, 150, 50
Замена и копирование значений в массивах
Команда для замены во всем массиве одного значения на другое.
заменить в на
Команда для копирования всех значений одного массива в другой массив. Количество элементов и размерность массивов должны совпадать.
копировать в
Любой, кто изучал программирование в университете, знает, что преподаватели стремятся дать только основной, базисный материал для своих студентов. Тема массивов также рассматривается, но на более поздних курсах. Почему? Потому что массивы - это основа, позволяющая программисту работать с большими объёмами информации.
Введение
Сегодняшнюю тему мы начнем с того, что введём определение данному термину. Массивы - это элементы представляющие собой набор данных в форме таблицы или строки. Представьте себе ряд случайных чисел: 1, 6, 2, 4, 8. Это и будет массивом. Каждая цифра, написанная в строке, имеет свой порядковый номер, и именно это позволяет соотнести (занести) их с массивом в программировании.
Запись
Рассмотрим, как записываются массивы на практике. Записать, обозначить массивы - это означает указать для создаваемой программы их тип (какие значения будут храниться в массиве) и количество ячеек. Иногда программисты создают безмерные массивы, без указания точного количества элементов, но тогда при обращении к ним надо быть очень внимательными, чтобы программа не зациклилась и не начала обращаться к пустым ячейкам.
- D: array of real; - так записывается Если вы при создании программы знаете, что у вас будет максимум 5 элементов, то можете воспользоваться записью D: array of real;
Как вы могли догадаться D - это буква, означающая имя массива; real - это тип (формат) данных, которые могут содержаться в - это количество элементов массива.
Обращение
Для того чтобы работать с элементом массива, к нему надо обратиться из программы. Массивы - это такие же числа или слова, как и любые другие. Для того чтобы работать с элементом массива, надо ввести: D. Это позволит выбрать первый элемент массива и проводить с ним операции. Например:
- print (D); - данная команда позволит вывести на экран пользователя значение, содержащееся в 1-ой ячейке массива.
Стоит отметить, что если вы собираетесь проводить математические операции с массивами, то вам следует обратить внимание на тип. Вы сможете это проделать, только если у вас имеется массив чисел. Чтобы было понятнее:
- Если у вас имеется массив D: array of text; - и в ячейке D=1, то вы не сможете использовать данный элемент в математических операциях, потому что для программы "1" - это будет просто слово "один", а не цифра. Поэтому следите за переменными и их типами.
Если вы планируете математические операции, или в массиве просто должны будут храниться числа, лучше обеспокойтесь его типом заранее и присвойте "real" или "integer".
Таблица
Давайте теперь поговорим про окружающее нас пространство. Мы живем в трехмерном мире, и большинство объектов может быть описано 3-мя параметрами: длина, ширина, высота. Так и у массивов существует размерность. Двумерные массивы - это таблицы с данными, в которых каждому элементу присуждается не один порядковый номер, а два - номер строки и номер столбца. При обращении к двумерному массиву нужно указывать оба числа - D.
Соответственно, такой массив будет в состоянии хранить больший объём данных. К сожалению, в старых языках программирования в большинстве случаев номером элемента массива могут выступать исключительно цифры. Поэтому хранение данных из больших таблиц становится весьма проблематичным из-за того, что каждому столбцу таблицы придется создавать отдельный массив.
Например, пусть у нас есть таблица, в которой записаны данные учеников. У них указаны: год рождения, фамилия, класс.
| 1989 | Иванов | Иван | 9 |
| 1988 | Петров | Петр | 10 |
| .... |
В обычных условиях нам придется создавать несколько массивов, в зависимости от потребностей. Мы можем создать один двумерный массив числового типа, чтобы хранить год рождения и класс, и второй массив для хранения текстовой информации (Ф.И.). Но это неудобно. Во-первых, фамилию и имя, возможно, придется обрабатывать по отдельности. Во-вторых, можно запросто запутаться при заполнении массива с годом и классом. Поэтому проще будет создать 4 отдельных массива для каждого столбца. Согласитесь, очень громоздко?
PHP
PHP массивы позволяют решить проблему, о которой упоминалось выше. Дело в том, что в данном языке программирования вы можете задать не только тип данных в массиве, но и тип счетчика (индекса). Кроме того, в одном массиве могут содержаться данные самых различных типов. Создание (если необходимо взять один столбец):
- $array = array(1989, 1988, ...);
Это пример создания простейшего массива. Индекс создаётся автоматически и считается от нуля. То есть нулевой элемент массива - 1989, первый - 1988 и т.д. Но что если нам необходимо поместить всю таблицу в многомерный массив? Что представляют собой многомерные Это конструкции, в которых каждый элемент также является массивом. Как разобрать данный нам пример?
array(1989, "Иванов", "Иван", 9),
array(1988, "Петров", "Петр", 10),
Что мы имеем в итоге? Перед нами массив с именем $table, у которого строки соотвествуют строкам в представленной таблице. Если коворить об элементах массива, то выглядеть они будут так:
- $table = 1989, $table = "Иванов", $table = "Иван", $table = 9.
- $table = 1988, $table = "Петров", $table = "Петр", $table = 10.
При этом 0 и 3 столбцы массива будут числовыми, а 1 и 2 - текстовыми. При необходимости вы всегда сможете конвертировать необходимые данные в нужный формат и объединить ячейки.
Описание многомерного массива позволяет использовать в программе любой из его элементов как индексированную переменную.
Индексированная переменная (индексное выражение) – обозначение ячейки для хранения конкретного элемента массивауказанием идентификатора массива и индексов элемента по каждому измерению.
В массивах Си/Си++ индексы элементов на единицу меньше заданных математически. Это обстоятельство должно учитываться в программе, особенно при формировании условия повторения (выхода из) цикла.
Особенность работы с массивами в Си/Си++ – любой двумерный массив можно представить в виде одномерного при условии укрупнения единицы хранения (элемента).
Например, если в качестве элементов выбрать строки (столбцы), то двумерный массив превратится в одномерный массив строк (столбцов).
Хранение двумерного массива, например X(m n), реализуется схемой распределения оперативной памяти (рис. 9.4).
Для хранения трехмерного массива, например S(k m n), схема распределения оперативной памяти представлена на рис 9.5 (первая и последняя страницы).
 | x 00 | x 01 | . | . | . | x 0j | . | . | . | x 0 n-1 |
| s 0i0 | s 0i1 | . | . | . | s 0ij | . | . | . | s 0i n-1 |
. . . . . . . . . . . . . . . . . . . . . . . . . . . .
| s 0m-1 0 | s 0 m-1 1 | . | . | . | s 0 m-1 j | . | . | . | s 0 m-1 n-1 |
. . . . . . . . . . . . . . . . . . . . . . . . . . . .
| s k-100 | s k-101 | . | . | . | s k-10j | . | . | . | s k-10 n-1 |
. . . . . . . . . . . . . . . . . . . . . . . . . . . .
| s k-1i0 | s k-1i1 | . | . | . | s k-1ij | . | . | . | s k-1i n-1 |
. . . . . . . . . . . . . . . . . . . . . . . . . . . .
| s k-1m-10 | s k-1 m-1 1 | . | . | . | s k-1 m-1 j | . | . | . | s k-1 m-1 n-1 |
Рис. 9.5. Хранение элементов трехмерного массива
Анализ схем показывает, что все элементы многомерного массива располагаются в оперативной памяти линейно (непрерывно и последовательно). При этом двумерный массив представляется последовательностью строк, трехмерный – последовательностью страниц, каждая из которых в свою очередь является последовательностью строк.
Изменение индексов происходит последовательно – справа налево . Например, для трёхмерного массива вначале полностью перебирается крайний правый индекс (столбцов), затем средний (строк) и последним – левый (страниц).
Длина ячейки хранения каждого элемента определяется типом массива.
Таким образом, любой трехмерный массив представляется в виде одномерного массива двумерных матриц (страниц), каждая из которых, в свою очередь, рассматривается как одномерный массив строк (столбцов).
Следовательно, n-мерный массив в Си/Си++ интерпретируется как совокупность массивов (n-1) размерности, которые также могут быть представлены совокупностью массивов еще меньшей размерности.
Структура обозначения индексированной переменной многомерного массива:
где имя – идентификатор массива;
индекс_i – целая константа, задающая номер элемента по i-му измерению;
– ограничители индекса элемента по каждому измерению.
Так, в описанном ранее массиве D(20 30) элемент, расположенный в первом столбце первой строки, обозначается индексным выражением d, во втором столбце той же строки – d, в первом столбце второй строки – d, текущий – d[i][j], элемент последнего столбца, последней строки – d.
Рассмотренный пример идентификации элементов массива D применим к любому из двумерных массивов, указанных в соответствующем описателе.
Для трехмерных массивов обозначение элементов выполняется аналогично. Например, в массиве S(10 5 15) (описан ранее) элемент первой страницы на пересечении первой строки и первого столбца обозначается индексным выражением s, элемент второго столбца первой строки той же страницы – s, второго столбца второй строки первой страницы – s, текущий – s[k][i][j], а элемент последнего столбца, последней строки, последней страницы – s.
Индекс, при необходимости, может задаваться арифметическим выражением. Например, d, d[i], s, s[i].
ü Внимание! Индекс на момент использования переменной должен быть определен (рассчитан) и укладываться в заданный описателем диапазон.
Рассмотренные формы представления индексированных переменных позволяют осуществить программную реализацию элементов алгоритма с использованием многомерных массивов.
Непрерывное и последовательное расположение элементов многомерного массива в оперативной памяти позволяет адрес каждого элемента представить зависимостью:
а = а1 + смещение,
где а – адрес некоторого текущего элемента массива;
а1 – адрес первого элемента массива;
смещение – номер текущего элемента относительно первого.
Смещение рассчитывается для массивов различной размерности по аналогичным методикам.
Так для двумерного массива
т.е. произведение номера текущей строки на ее размер (число столбцов) плюс номер текущего столбца. Первое слагаемое определяет число элементов в вышерасположенных строках, второе – число элементов в текущей строке от ее начала до искомого включительно.
Для трехмерного массива
смещение = индекс_1*(разм_2* разм_3) +
Первое слагаемое определяет число элементов в ранее расположенных страницах, второе – в предыдущих строках текущей страницы, третье – число элементов в текущей строке текущей страницы.
ü Внимание! Для любого массива размер первого измерения (разм_1) в расчете смещения не используется.
В качестве сомножителей (разм_i) используются значения, указанные в описателях массивов.
Описатели массивов определяют максимально возможные значения (размеры) каждого измерения. Это позволяет использовать зарезервированное пространство оперативной памяти полностью, либо частично, обеспечивая универсальность размеров в сторону уменьшения. Для двумерного массива это утверждение поясняется схемой (рис. 9.6):
| Размер, заданный в описателе (максимальное число столбцов n max) | ||||||||||||
| Размер, используемый в расчетах (n) | ||||||||||||
| Размер, использу-емый в расчетах (m) | Размер, заданный в описателе (максимальное число строк m max) | |||||||||||
Рис. 9.6. Соответствие реальных размеров описанным
Размеры, указанные в описателе определяют количество зарезервированных в оперативной памяти ячеек. При этом ячейки создаваемого двумерного массива располагаются последовательно и линейно (построчно). Если в расчетах зарезервированное пространство используется частично (с меньшим числом строк и/или столбцов), то участки с хранимыми значениями будут чередоваться с неиспользуемыми, количество которых должно быть учтено при указании длины каждой строки в индексном выражении. Суммарное количество элементов каждой строки задано в описателе массива. Поэтому адреса любой ячейки определяется индексным выражением, использующим в качестве одного из параметров указанный в описателе размер.
Так, если двумерный массив z описан как z, а в задаче используется с размерами m=7, n=12, то адрес текущего элемента &z[i][j] = z + i * 20 + j, а не &z[i][j] = z + i * n + j.
Исходя из изложенного, адрес i-го, j-го элемента массива D(20х30) вычисляется по формуле
&(d[i][j]) = d + i * 30 + j,
а адрес k-го, i-го, j-го элемента массива S(10х5х15) вычисляется как
&(s[k][i][j]) = s + k * (5 * 15) + i * 15 + j
Таким образом, индексное выражение полностью определяет адрес конкретной ячейки для хранения соответствующего элемента через параметры описателя, а не укороченные, реально заданные.
С учетом изложенного идентификация переменных алгоритма и создаваемой программы представлена в табл. 9.1.
Таблица 9.1
На основании схемы алгоритма и таблицы идентификации составим программу решения задачи.
Классический вариант программирования задачи
#include
#include
#include
#define M 10 /* увеличенные */
#define N 12 /* размеры массивов */
main() /* заголовок головной функции */
char buf; /*описание символьного массива*/
CharToOem(" Введите m (m<= ",buf); /* запрос */
printf("\n %s %d):",buf,M); /* и */
scanf("%d", &m); /* ввод */
CharToOem(" Введите n (n<= ",buf); /* фактических */
printf("\n %s %d):",buf,N); /* размеров */
scanf("%d", &n); /* массивов */
printf("\n n=%d m=%d ", n, m); /*вывод размеров массивов*/
for(i = 0; i < m; i++) /*заголовок внешнего цикла ввода x[i][j]*/
for(j = 0; j < n; j++) /*заголовок внутр. цикла ввода x[i][j]*/
CharToOem(" Введите значение ",buf); /* ввод */
printf("\n %s x[%d][%d]:",buf,i+1, j+1); /* элементов */
scanf("%f", & x[i][j]); /*массива Х*/
CharToOem(" Массив X",buf); /* вывод */
for(i = 0; i < m; i++)/* заголовок внешн. цикла вывода x[i][j]*/
for(j=0; j < n; j++)/*заголовок внутр. цикла вывода x[i][j]*/
printf(" %5.2f", x[i][j]);
for(i = 0; i < m ; i++ /*заголовок внешн. цикла расчета y[i][j]*/
for(j = 0; j < n; j++)/*заголовок внутр. цикла расчета y[i][j]*/
CharToOem(" Массив Y",buf); /* вывод */
printf("\n %s \n",buf); /*заголовка*/
for(i = 0 ; i < m ; i++)/*заголовок внешн. цикла вывода y[i][j]*/
for(j = 0; j < n; j++) /*заголовок внутр. цикла вывода y[i][j]*/
printf(" %5.2f", y[i][j]);
2 3 – размеры массива;
Результаты решения представлены в приложении 9.1.
Программирование задачи с графическим интерфейсом
Программирование задачи при использовании графического интерфейса предварим его разработкой.
|
|
Для ввода количества столбцов и строк массива планируем однострочные поля редактирования (EditN, EditМ). Для ввода элементов массива Х – многострочное поле редактирования (EditХ). Вывод элементов массивов X и Y реализуем в поля-списки (ListBoxXi, ListBoxYi).
Управление процессом решения реализуем двумя командными кнопками, расположенными в нижней части окна. Назначение каждой определяется ее названием.
Использование графического интерфейса для вывода числовых элементов двумерных массивов в виде таблицы требует:
· представления каждого числового данного соответствующей символьной строкой;
· формирования общей символьной строки (из полученных для каждого элемента строк), соответствующей числовой строке массива;
· размещение сформированной общей символьной строки в окне вывода.
Представление числовых данных символьными строками комментариев не требует.
Формирование элементов выводимой строки в единое целое выполняется функцией «склеивания» строк strcat.
Функция «склеивания» символьных строк strcat()
Функция предназначена для получения результирующей строки из двух исходных строк. Структура функции:
strcat(buf1, buf2)
где strcat – обозначение функции;
buf1 – имя исходной (результирующей) символьной строки;
buf2 – имя добавляемой символьной строки;
() – ограничители аргумента.
Функция располагается в библиотеке string.h.
Правила записи и использования
1. Операнды buf1 и buf2 – символьные строки. Строка buf1 увеличивает свое значение после выполнения функции на величину buf2.
2. Обязательное условие формирования строк buf1 и buf2 – окончание каждой символом «\0».
3. Пробелы, при необходимости, формируются структурой соответствующей строки (включением в нее).
4. Однократное использование функции – чтение строки buf1, добавление к ней строки buf2 и занесение результата в buf1. Поэтому размер buf1 в описателе создается увеличенным (на величину добавляемых компонентов).
5. Многократное использование функции – последовательное добавление второго операнда (buf2) к предварительно полученной строке buf1.
6. Повторное использование функции для создания новой результирующей строки требует предварительной очистки первого аргумента функции. Один из вариантов – присваивание строке buf1 пустой строки: sprintf(buf1,"%s","");
7. Проверка результирующей строки на переполнение не выполняется.
8. Функция используется как операнд арифметического выражения (присваивания) или самостоятельный оператор.
Общий вид фрагмента программы «склеивания» символьных строк str и buf:
#include
char str, buf; /*описатель символьных строк*/
EditStr->
EditBuf->GetText(buf, 10); /*ввод buf из поля EditBuf*/
Описатель типа определяет массивы str и buf как символьные максимальной длины 25 и 10 символов. Пятая и шестая строки предписывает ввод строк str и buf из полей EditStr и EditBuf соответственно. Оператор strcat(str, buf); формирует «склеенную» строку и хранит ее под именем str .
Многократное использование функции позволяет создать результирующую строку с любым количеством компонентов в пределах, предусмотренных размером buf1.
Вариант 1: последовательное соединение нескольких строк
#include
char str, buf1, buf2;/*описатель символьных строк*/
EditStr->GetText(str, 10); /*ввод строки str из поля EditStr*/
EditBuf1->GetText(buf1, 10); /*ввод buf1 из поля EditBuf1*/
EditBuf2->GetText(buf2, 10); /*ввод buf2 из поля EditBuf2*/
strcat(str, buf1); /*формирование результирующей строки str «склеиванием» исходных строк str и buf1*/
strcat(str, buf2); /*формирование результирующей строки str «склеиванием» полученных str и buf2*/
Описатель типа определяет массивы str, buf1 и buf2 как символьные, максимальной длины 25, 10 и 5 символов, соответственно. Пятая, шестая и седьмая строки предписывает ввод str, buf1 и buf2 из полей EditStr, EditBuf1 и EditBuf2 соответственно. Операторы strcat(str, buf1); и strcat(str, buf2); последовательно формируют «склеенную» строку из str, buf1 и buf2. Полученная строка имеет имя str .
Вариант 2: использование функции в теле цикла.
#include
char str = “ ”, buf;/*описание и инициализация
символьных строк*/
for(j = 0 ; j < 5 ; j++) /* заголовок цикла ввода buf и формирования str*/
EditBuf->GetLine(buf, 10, j); /* ввод buf */
strcat(str, buf); /*формирование результирующей строки str «склеиванием» исходных строк str и buf*/
Описатель типа определяет массивы str и buf как символьные максимальной длины 50 и 10 символов соответственно и инициализирует str пустой строкой. Оператор EditBuf->GetLine (buf, 10, j); предписывает ввод buf из j-й строки многострочного поля EditBuf. Оператор strcat(str, buf); формирует в теле цикла, из последовательно вводимых строк buf, «склеенную» строку и хранит ее под именем str .
С учетом планируемого интерфейса выполним программирование задачи.
#include
#include
#include
void TSumprDlgClient::Ok()
// INSERT>> Your code here.
float x[M][N], y[M][N]; /* описатели массивов */
char buf,buf1=" "; /*описание символьного массива*/
ListBoxYi->
ListBoxXi->ClearList(); /*очистка поля вывода*/
EditN->
n = atoi(buf); /* столбцов массива*/
EditM->GetText(buf, 10); /*ввод количества*/
m = atoi(buf); /* строк массива*/
for(i = 0 ; i < m ; i++) /* заголовок внешн. цикла ввода x[i][j] */
for(j = 0 ; j < n ; j++) /* заголовок внутр. цикла ввода x[i][j] */
EditX->GetLine(buf, 30, i*n+j); /* ввод элементов */
x[i][j]=atof(buf); /* массива Х*/
for(i = 0; i < m; i++) /*заголовок внешн. цикла вывода x[i][j]*/
for(j = 0; j < n; j++)/*заголовок внутр. цикла вывода x[i][j]*/
sprintf(buf,"%11.3f",x[i][j]); /* вывод текущих*/
ListBoxXi->AddString(buf1); /*значений xi*/
sprintf(buf1,"%s","");
for(i = 0; i < m; i++)/*заголовок внешн. цикла расчета y[i][j]*/
for(j = 0; j < n; j++) /*заголовок внутр. цикла расчета y[i][j]*/
y[ i ][ j ] = x[ i ][ j ] / 2.;
for(i = 0 ; i < m ; i++)/*заголовок внешн. цикла вывода y[i][j]*/
for(j = 0; j < n; j++)/*заголовок внутр. цикла вывода y[i][j]*/
sprintf(buf,"%11.6f",y[i][j]); /* вывод текущих*/
strcat(buf1, buf); /*склеенных*/
ListBoxYi->AddString(buf1); /*значений yi*/
sprintf(buf1,"%s","");
3 2 – размеры массива;
10. 20. 30. – элементы первой строки;
100. 200. 300. – элементы второй строки.
Под закрывающей скобкой приведены исходные данные для решения задачи.
Результаты решения представлены в приложении 9.2.
Похожая информация.
>> Статьи
Что такое массивы в программировании?
Массив – это переменная, которая является совокупностью компонентов одного типа. Чтобы использовать массивы в программировании, потребуется предварительное описание определенного типа и указание доступа к элементам. Элементы массива в программировании объединены общим именем. Если требуется обратиться к определенному элементу массива, то достаточно указать имя и индекс. В математике есть понятный пример массива – это векторы и последовательности чисел, в которых группа чисел может обозначаться одним именем. Обратившись к конкретному числу, используют разные индексы.Виды массивов: одномерные и двухмерные
Если для обращения к элементам использован единственный порядковый номер , то массив называется одномерный или линейный. Выглядит как таблица с одной строкой. Размерность массива определяется посредством количества индексов элементов.
Когда использовано два индекса, то массив будет двухмерным. Если массив представлен в идее таблицы, то номер строки будет соответствовать первому индексу, а номер столбца или ячейки – второму.
Как заполнить массив?
Одним из способов заполнения массива является оператор присваивания. Когда элементы связаны реккурентно и имеют определенную зависимость, подойдет такой способ заполнения. Также можно заполнить однородный массив однородными элементами или значениями, которые получены посредством датчика случайных чисел..
Какие действия производятся с элементами массива?
Сортировка элементов в определенном порядке – убывание или возрастание
Поиск значений
Подсчет количества элементов в массиве, соответствующих определенному условию
Когда два массива эквивалентны, то возможно присвоение одному массиву имени другого. Все компоненты копируются в тот массив, которому и присваивается значение.
Как объявить массив
Чтобы объявить массив и выделить в памяти ячейку для хранения элементов, следует указать размерность и имя. Ключевое слово – массив. К примеру, А 20 означает, что одномерный массив состоит из двадцати элементов. К 6,5 означает, что это двухмерный массив , который представлен в виде таблицы из шести строк и пяти ячеек. Если говорить об ограничениях одномерного массива в программировании, то оно составляет тысячу элементов. Для двухмерных массивов максимально допустимым значением станет таблица из тысячи строк и тысячи ячеек.
Массивы в программировании: работа с ними
Когда массив объявлен, каждый элемент подлежит обработке с указанием имени и индекса в квадратных скобках. Чтобы отличить одномерный массив от двухмерного, используются два индекса. Элементы массива с присвоением индекса называются индексированными переменными, но могут использоваться и в качестве простых переменных. К примеру, быть аргументом в команде.
Типы имени, элементов, индексов
Как придумать имя массиву? Подойдет произвольный идентификатор. По правилам стиля имя должно начинаться с буквы Т большого шрифта. Таким образом, можно отличить идентификатор от других. Последующую часть имени можно придумать в соответствии с конкретными данными для хранения в массиве. Вторая составляющая имени также должна начинаться с заглавной буквы. T Vector может хранить информацию о координатах абстрактного вектора.
Что касается типа элементов в массиве, то это может быть ранее введенный или стандартный. Для создания индексов используются целые числа, а типом станет диапазон. Допустим, тип 1…20 говорит о том, что массив состоит из двадцати элементов, каждый из которых соответствует целому числу от одного до двадцати.
Массив - это сложный (составной, структурированный) тип данных, который характеризуется следующим:
· элементы массива имеют одинаковый тип в отличие от структур, поэтому каждый элемент массива занимает одинаковый объём памяти;
· массив располагается в оперативной памяти, а не на внешнем устройстве, как файлы (2-й семестр);
· элементы массива занимают подряд идущие ячейки, в отличие, например, от списков (2-й семестр).
Доступ к элементам массива в языке С++ осуществляется двумя способами.
Первый, с помощью порядкового номера элемента массива, который называется индексом , характерен для многих языков программирования и рассматривается в первом семестре. Он более простой и привычный для тех, кто изучал язык Pascal. В качестве индекса можно использовать выражение целого или совместимого с ним типа, в том числе константу или переменную. В качестве индекса нельзя использовать выражение вещественного типа.
Кроме того, в языке С++ есть возможность обрабатывать массивы, используя указатели (адреса) , так как в С++ существует связь между массивами и указателями. Несмотря на то, что в первом способе в программе отсутствует специальный тип для работы с адресами, указатели всё равно используются.
Массивы могут иметь одну или несколько размерностей. В этом параграфе рассматривается одномерный массив, который иногда называют вектором , подразумевая вектор в n -мерном пространстве. Работа с двумерными массивами (матрицами ) рассматривается в гл. 5. Три и более размерностей на практике используются редко, так как такие массивы занимают большой объём оперативной памяти.
Везде в дальнейшем под словом “массив” будем понимать одномерный массив.
С точки зрения времени (этапа), когда распределяется память под массив, существуют два их вида. Память для динамического массива выделяется во время выполнения программы, и если массив не нужен, память для него можно освободить. Такие массивы рассматриваются во втором семестре.
Одномерный массив с фиксированной размерностью (назовём его статический ) объявляется в общем виде следующим образом:
тип имя [N];
Здесь тип - тип элементов массива. Вначале будем рассматривать простые типы (int, float, char ), но можно использовать и сложные, например, структуры. Имя записывается по правилам идентификаторов. Каждый элемент массива имеет одно и то же имя, меняется только индекс или номер элемента. N - размерность (или размер) массива в виде целочисленной константы или константного выражения. Эта величина определяет количество ячеек оперативной памяти, зарезервированной для массива. Например:
float A; или const n=10; float A[n];
Преимущество второго способа c предварительным объявлением размерности в виде константы заключается в следующем. Если надо будет изменить размерность массива, то это достаточно сделать в одном месте программы при определении константы.
В отличие от динамического массива, для статического на этапе компиляции резервируется память для размещения N чисел указанного типа (10 вещественных чисел). Для массива требуется память объёмом k*N байт (4*10 ), где k - необходимое количество байт для размещения одного элемента указанного типа (одного числа типа float ). Эта память сохраняется на всё время выполнения программы, а точнее, функции или блока, где описан массив. Программно необходимый объём памяти определяется с помощью операции sizeof следующим образом:
M=sizeof (тип)*N ; или M= sizeof (имя) ; или M= sizeof имя ;
где M - переменная целого типа, определяющая размер массива в байтах. Тип обязательно записывается в скобках, а имя может быть без скобок. Следующая программа выведет дважды число 40.
float A; int M1, M2;
M1=sizeof(float)*10; // но M1=sizeof float *10;- ошибка!
M2=sizeof(A); // или M2=sizeof A;
cout<
Во многих современных системах программирования, в том числе и в С++, нумерация элементов массива начинается с 0. Тогда A - последний элемент массива. Это связано с использованием указателей при работе с массивами (см. 2-й семестр). Поэтому в нашем примере индекс изменяется от 0 до 9 включительно, то есть индекс последнего элемента массива на единицу меньше его размерности. Объявленные 10 элементов массива обозначаются следующим образом: A, A, A ,…, A . В С++ отсутствует проверка границ массивов. Можно выйти за его границу и записать значение в некоторую переменную или даже в код программы. О таком контроле должен позаботиться программист.
При использовании статических массивов возникают проблемы в случае, если размер массива заранее мы не знаем. В таком случае объявляем массив максимальной размерности, которая, как правило, известна. Реальную размерность вводим и используем далее, например, в циклах и для других целей:
const nmax=100; float X;
int n; cout<<”Input the size of array ”; cin>>n;
/* Д альше работаем с n (а не с nmax ) элементами массива, например, вводим их.*/
for (int i=0; i
{ // Эту строку можно опустить вместе с фигурными скобками.
cout<<”X[“<
cin>>X[i];
Такой способ проще, но неэффективен с точки зрения распределения памяти, так как “заказываем” больше памяти, чем реально используем. В таких случаях профессионально используются более эффективные динамические массивы (см. 2-й семестр).
