Массивы кратко. Обозначение элементов многомерного массива. Вычисление индекса массива Паскаля
При решении задач с большим количеством данных одинакового типа использование переменных с различными именами, не упорядоченных по адресам памяти, затрудняет программирование. В подобных случаях в языке Си используют объекты, называемые массивами.
— это непрерывный участок памяти, содержащий последовательность объектов одинакового типа, обозначаемый одним именем.
Массив характеризуется следующими основными понятиями:
Элемент массива (значение элемента массива)
– значение, хранящееся в определенной ячейке памяти, расположенной в пределах массива, а также адрес этой ячейки памяти.
Каждый элемент массива характеризуется тремя величинами:
- адресом элемента — адресом начальной ячейки памяти, в которой расположен этот элемент;
- индексом элемента (порядковым номером элемента в массиве);
- значением элемента.
Адрес массива – адрес начального элемента массива.
Имя массива – идентификатор, используемый для обращения к элементам массива.
Размер массива – количество элементов массива
Размер элемента – количество байт, занимаемых одним элементом массива.
Графически расположение массива в памяти компьютера можно представить в виде непрерывной ленты адресов.
Представленный на рисунке массив содержит 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;
}
Любой, кто изучал программирование в университете, знает, что преподаватели стремятся дать только основной, базисный материал для своих студентов. Тема массивов также рассматривается, но на более поздних курсах. Почему? Потому что массивы - это основа, позволяющая программисту работать с большими объёмами информации.
Введение
Сегодняшнюю тему мы начнем с того, что введём определение данному термину. Массивы - это элементы представляющие собой набор данных в форме таблицы или строки. Представьте себе ряд случайных чисел: 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 - текстовыми. При необходимости вы всегда сможете конвертировать необходимые данные в нужный формат и объединить ячейки.
Массив - это сложный (составной, структурированный) тип данных, который характеризуется следующим:
· элементы массива имеют одинаковый тип в отличие от структур, поэтому каждый элемент массива занимает одинаковый объём памяти;
· массив располагается в оперативной памяти, а не на внешнем устройстве, как файлы (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-й семестр).
Описание массива позволяет использовать в программе любой из его элементов. Для обозначения элементов массива в Си используются индексированные переменные.
Индексированная переменная (индексное выражение) – обозначение ячейки для хранения элемента массива. Именуется указанием идентификатора массива и индекса (индексов) элемента.
ü Внимание! Особенность обозначения элементов массива в Си - нумерация индексов от 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.
Таким образом, индексное выражение полностью определяет конкретную ячейку хранения соответствующего элемента.
Описание многомерного массива позволяет использовать в программе любой из его элементов как индексированную переменную.
Индексированная переменная (индексное выражение) – обозначение ячейки для хранения конкретного элемента массивауказанием идентификатора массива и индексов элемента по каждому измерению.
В массивах Си/Си++ индексы элементов на единицу меньше заданных математически. Это обстоятельство должно учитываться в программе, особенно при формировании условия повторения (выхода из) цикла.
Особенность работы с массивами в Си/Си++ – любой двумерный массив можно представить в виде одномерного при условии укрупнения единицы хранения (элемента).
Например, если в качестве элементов выбрать строки (столбцы), то двумерный массив превратится в одномерный массив строк (столбцов).
Хранение двумерного массива, например 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.
Похожая информация.