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