Как обозначается массив. Что такое массив дерева

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

Энциклопедичный YouTube

1 / 5

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

Количество используемых индексов массива может быть различным: массивы с одним индексом называют одномерными, с двумя - двумерными, и т. д. Одномерный массив («колонка», «столбец») - нестрого соответствует вектору в математике; двумерный - матрице . Чаще всего применяются массивы с одним или двумя индексами; реже - с тремя; ещё большее количество индексов - встречается крайне редко.

Пример фиксированного массива на языке Паскаль

{Одномерный массив целых чисел. Нумерация элементов от 1 до 15} a : array [ 1 .. 15 ] of Integer ; {Двумерный массив символов. Нумерация по столбцам по типу Byte (от 0 до 255) по строкам от 1 до 5} multiArray : array [ Byte , 1 .. 5 ] of Char ; {Одномерный массив из строк. Нумерация по типу word (от 0 до 65536)} rangeArray : array [ Word ] of String ;

Пример фиксированного массива на С/С++

Int Array [ 10 ]; // Одномерный массив: целых чисел, размера 10; // Нумерация элементов - от 0 до 9. double Array [ 12 ][ 15 ]; // Двумерный массив: // вещественных чисел двойной точности, // размера 12 на 15; // Нумерация: по строкам - от 0 до 11, // по столбцам - от 0 до 14.

В некоторых языках программирования многомерные массивы создаются на основе одномерных, у которых элементы являются массивами .

Пример двумерного массива на JavaScript

//ES6. Создание двумерного массива чисел: var array = [ [ 11 , 12 , 13 , 14 , 15 , 16 ], // Первая строка-массив [ 21 , 22 , 23 , 24 , 25 , 26 ], // Вторая [ 31 , 32 , 33 , 34 , 35 , 36 ] // Третья ]; // Вывод массива на консоль: array . forEach ((subArray ) => { // Для каждого под-массива, subArray . forEach ((item ) => { // для каждого его элемента, console . log (item ); // - вывести этот элемент на консоль. }); });

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

В языках программирования, допускающих объявления программистом собственных типов , как правило, существует возможность создания типа «массив». В определении такого типа могут указываться: размер, тип элемента, диапазон значений и типы индексов. В дальнейшем возможно определение переменных созданного типа. Все такие переменные-массивы имеют одну структуру. Некоторые языки поддерживают для переменных-массивов операции присваивания (когда одной операцией всем элементам массива присваиваются значения соответствующих элементов другого массива).

Объявление типа «массив» в языке Паскаль

Type TArrayType = array [ 0 .. 9 ] of Integer ; (* Массивы, имеющие заданные параметры: 1. Размер - 10 ячеек; 2. Тип элементов, пригодных для хранения - - целые числа диапазона [−32 768; 32 767], - объявляются типом операндов, называющимся "TArrayType". *) var arr1 , arr2 , arr3 : TArrayType ; (* Объявление трёх переменных-массивов одного типа (вышеуказанного "TArrayType"). *)

Специфические типы массивов

Динамические массивы

«Динамическим» называется массив такого размера, который может «динамически» меняться при выполнении программы (например, - уменьшаться после выгрузки неактуальных данных). Язык программирования , предоставляющий такую возможность, называется поддерживающим динамические массивы. Динамические массивы делают работу с данными более гибкой, так как не требуют предварительного определения хранимых объёмов данных, а позволяют регулировать размер массива в соответствии с реальными потребностями. Обычные (не динамические) массивы называют ещё фиксированными .

Пример динамического массива на Delphi

ByteArray : Array of Byte ; // Одномерный массив multiArray : Array of Array of string ; // Многомерный массив

Пример динамического массива на Си

Float * array1 ; // Одномерный массив int ** array2 ; // Двумерный массив array1 = (float * ) malloc (10 * sizeof (float )); // выделение 10 блоков по sizeof(float) байт каждый array2 = (int ** ) malloc (16 * sizeof (int * )); // выделение 16 блоков по sizeof(int*) байт каждый. Сюда будут записаны указатели на одномерные массивы-строки for (i = 0 ; i < 16 ; ++ i ) array2 [ i ] = (int * ) malloc (8 * sizeof (int )); // выделение 8 блоков по sizeof(int) байт каждый. Это одномерные массивы - строки матрицы. // Обращение к массиву array1 [ i ] = 5.0 ; * (array1 + i ) = 5.0 ; array2 [ i ][ j ] = 6 ; // Записи эквивалентны. Первая с использованием индекса, * (* (array2 + i ) + j ) = 6 ; // вторая с операцией разыменования. free (array1 ); for (i = 0 ; i < 16 ; ++ i ) free (array2 [ i ]); free (array2 );

Пример динамического массива на С++

Float * array1 ; // Одномерный массив int ** array2 ; // Многомерный массив array1 = new float [ 10 ]; // выделение 10 блоков размером типа float array2 = new int * [ 16 ]; // выделение 16 блоков размером типа указателя на int for (int i = 0 ; i < 16 ; ++ i ) array2 [ i ] = new int [ 8 ]; // Работаем с массивами. delete array1 ; // Важно не забывать возвращать выделенную память системе. for (int i = 0 ; i < 16 ; ++ i ) delete array2 [ i ]; // Возвращаем память, используемую для строк матрицы. delete array2 ; // Возвращаем память, используемую для столбцов матрицы.

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

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

Реализация

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

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

Введение

Сегодняшнюю тему мы начнем с того, что введём определение данному термину. Массивы - это элементы представляющие собой набор данных в форме таблицы или строки. Представьте себе ряд случайных чисел: 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 - текстовыми. При необходимости вы всегда сможете конвертировать необходимые данные в нужный формат и объединить ячейки.

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

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

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

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

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

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

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

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

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

var ИмяМассива: array of ТипДанных;

Здесь ИмяМассива - это имя переменной, связанной с этим массивом. ТипДанных - это тип данных элементов массива. Пример:

var M1: array of byte;

Здесь мы объявили массив с именем М1 , который содержит 16 элементов типа byte с индексами от 0 до 15. первый элемент массива имеет индекс 0, второй - индекс 1 и так далее.

Работать с отдельным элементом массива можно так:

var m: byte;
M1 := 100;
m:= M1;

Здесь мы сначала в первый элемент массива записываем значение 100, а потом в переменную m записываем значение первого элемента массива. Догадайтесь, какое значение будет в переменной m после этого))).

Но понять всю прелесть использования массивов вы сможете только тогда, когда попробуете обработать все элементы массива в . Например, так:

for i:= 0 to 15 do M1[i] := i;
for i:= 0 to 15 do Write(M1[i], " ");

Надеюсь, не надо объяснять, что делает этот код. А теперь представьте, сколько бы строк кода вам пришлось написать, если бы то же самое вы делали с помощью обычных переменных.

Двухмерный массив объявляется так:

M2: array of byte;

Это будет матрица (или таблица) 4х2. То есть такой массив имеет некоторое количество строк (в нашем примере 4) и некоторое количество столбцов (в нашем примере 2). Того же результата можно достичь, если объявить массив массивов:

M2e: array of array of byte;

Здесь новичкам обычно трудно сообразить, что со всем этим “многомерьем” делать. Ну ничего, привыкайте. Первый массив - это строки таблицы. Второй - это столбцы. То есть каждый элемент первого массива содержит массив array. Таблица (матрица), представленная нашим примером, выглядит так:

Таким образом,

М2 - это ячейка 1.1 (первая строка, первый столбец)
М2 - это ячейка 1.2 (первая строка, второй столбец)
М2 - это ячейка 2.1 (вторая строка, первый столбец)

Если вы попробуете использовать, например, М2 , то компилятор выдаст предупреждение, так как столбца 3 в нашем массиве не существует. Однако будьте осторожны! В некоторых средствах разработки программа при этом будет создана (зависит от настроек среды)! И вы можете получить ошибку, которую в последствии будет трудно обнаружить.

А теперь пример использования нашего двухмерного массива:

//Заполняем массив for i:= 1 to 4 do for j:= 1 to 2 do M2 := i * 10 + j; //Выводим массив на экран for i:= 1 to 4 do for j:= 1 to 2 do Write(M2, " ");

Как видите, здесь мы используем ДВЕ индексных переменных (i и j ) и вложенные . Как работают вложенные циклы - попробуйте догадаться сами. Если не получится - задайте вопрос в разделе . Этот раздел я стараюсь проверять хотя бы раз в день.

Надеюсь, с этим кодом вы разобрались. Или хотя бы запустили его и посмотрели, что он делает. А он выводит двухмерный массив на экран. Но вывод выполняется в одну строку. И это не очень удобно для двухмерного массива. Ведь обычно в таких массивах представлены матрицы (таблицы). То есть удобнее воспринимать информацию, если она будет выводиться в виде таблицы. В нашем случае хотелось бы получить 4 строки и 2 столбца.

Попробуйте решить эту задачу самостоятельно. А если у вас не получится, то вот один из вариантов решения:

For i:= 1 to 4 do for j:= 1 to 2 do case j of 1: Write(M2, " "); 2: WriteLn(M2, " "); end;

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

Const k = 8; //Количество столбцов var i, j: byte; M2f: array of array of byte; //Заполняем массив for i:= 1 to 4 do for j:= 1 to k do M2f := i * 10 + j; //Выводим таблицу for i:= 1 to 4 do for j:= 1 to k do case j of k: WriteLn(M2f, " "); else Write(M2f, " "); end;

Изучите внимательно этот пример и найдите все участки кода, где используется константа k . Дальше, надеюсь, вы разберётесь с этим кодом самостоятельно.

Ну и напоследок добавлю, что для определения индексов массива можно использовать уже известные нам по стандартные функции Low и High . Например, так:

WriteLn("Индекс первого элемента М1: ", Low(M1));
WriteLn("Индекс последнего элемента М1: ", High(M1));

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

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

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

В массивах Си/Си++ индексы элементов на единицу меньше заданных математически. Это обстоятельство должно учитываться в программе, особенно при формировании условия повторения (выхода из) цикла.

Особенность работы с массивами в Си/Си++ – любой двумерный массив можно представить в виде одномерного при условии укрупнения единицы хранения (элемента).

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

Хранение двумерного массива, например 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.

Программирование задачи с графическим интерфейсом

Программирование задачи при использовании графического интерфейса предварим его разработкой.

ListBoxХi

ListBoxYi

Для ввода количества столбцов и строк массива планируем однострочные поля редактирования (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

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.

Похожая информация.