• Введение
• Процедуры и функции
• Перечисляемый тип, тип-диапазон и оператор CASE
• Одномерные и многомерные массивы
• Литература

Введение

Описание:

<имя параметра>: <тип параметра>

Процедуре передается копия фактического параметра, и в ходе выполнения процедуры изменяется только эта копия. Ее изменение никак не влияет на значение фактического параметра. Это называется передачей параметра по значению. Параметру-значению при вызове процедуры должен соответствовать фактический параметр ? выражение указанного типа.

2. Параметр-переменная.

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

Описание:

var <имя параметра>: <тип параметра>

Процедуре передается адрес фактического параметра, поэтому изменение соответствующего формального параметра внутри процедуры изменяют и фактический параметр. Это называется передачей параметра по ссылке (имеется в виду ссылка на адрес фактического параметра). Параметру-переменной при вызове процедуры должен соответствовать фактический параметр ? переменная указанного типа.

3. Параметр-константа.

Описание:

const <имя параметра>: <тип параметра>

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

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

Параметры одного типа и назначения можно перечислить через запятую. Описание параметров разных типов и разного назначения отделяются точкой с запятой, например:

Procedure P (const c123: integer;

i, j: integer;

a, b, c: real;

var f1: real);

За заголовком процедуры могут следовать директивы. Стандартными директивами языка Turbo Pascal являются директивы assembler, external, far, near, forward, inline, interrupt. Например, использование директивы assembler указывает, что процедура представляет собой последовательность команд встроенного в компилятор языка Turbo Pascal ассемблера. Директива far определяет так называемую дальнюю модель памяти, т.е. обеспечивает возможность обратиться к процедурам и функциям, сопровождаемым этой директивой, из любого участка программы. Указание этой директивы необходимо, например, при использовании процедурных типов (см. ниже). Напротив, директива near определяет ближнюю модель памяти. Директива forward используется при опережающем описании процедуры, ? так бывает, например, когда одна из процедур содержит обращение ко второй процедуре, а вторая, в свою очередь, к первой. Поскольку каждая процедура должна быть описана до обращения к ней, заголовок второй процедуры нужно объявить перед описанием первой процедуры, снабдив ее директивой forward. Директива forward, таким образом, указывает, что описание процедуры помещается далее в тексте программы, но обращаться к ней можно уже сейчас (из первой процедуры, описание которой предшествует описанию второй процедуры).

Функция отличается от процедуры тем, что результатом ее работы является единственное значение, поэтому обращение к функции можно использовать в выражениях наряду с переменными и константами.

Описание функции:

ЗАГОЛОВОК ФУНКЦИИ:

Function <имя функции> (<описание формальных

параметров>): <тип результата>;

РАЗДЕЛ ОПИСАНИЙ (описание локальных констант,

переменных, типов, процедур и

функций низшего уровня)

РАЗДЕЛ ОПЕРАТОРОВ

begin

end.

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

<имя функции>: = <вычисленное значение>;

В предыдущем примере находилось значение функции с заданной точностью с помощью суммирования ряда. Результат сравнивался со значением, полученным с помощью стандартной функции языка Turbo Pascal. Проиллюстрируем на том же примере использование процедур и функций.

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

В нашем примере достаточно описать в основной программе переменные: epsilon ? заданная точность вычисления; x ? аргумент функции; sinus ? результат вычисления функции с помощью ряда. Эти переменные будут глобальными по отношению к процедуре вычисления функции sinus. Вспомогательные переменные будут локальными (локализованными внутри процедуры).

В процедуре суммирования ряда sin1 используются следующие формальные параметры: e1 ? заданная точность вычисления; x1 ? аргумент функции.

Эти параметры не изменяются при выполнении процедуры и поэтому передаются по значению (как параметры-значения). s1 ? результат вычисления; он должен быть передан в основную программу и поэтому описывается как параметр-переменная. В принципе, можно было использовать для формальных параметров имена epsilon, x, sinus, поскольку в данном случае это не должно привести к недоразумению.

Результатом работы процедуры является единственное значение s1. Поэтому в данном случае можно было использовать функцию.

Такая функция описана далее в программе под именем sin2. Используются формальные параметры: e2 ? заданная точность вычисления; x2 ? аргумент функции. Значение функции имеет тип extended.

Program Procedures_and_functions_1;

{Описание глобальных переменных}

var

epsilon, x, sinus: extended;

Procedure sin1 (e1, x1: extended; var s1: extended);

{Описание вспомогательных (локальных) переменных}

var

s, sqrx: extended;

n: byte;

{Раздел операторов процедуры sin1}

begin {sin1}

s: = x1; {Первый член ряда}

n: = 1; {Степень члена ряда}

s1: = 0; {Сумма ряда}

sqrx: = sqr (x1);

while abs (s) > e1

do begin

s1: = s1 + s;

n: = n + 2;

s: = - s * sqrx / ( (n - 1) * n)

end

end; {sin1}

Function sin2 (e2, x2: extended): extended;

{Описание вспомогательных (локальных) переменных}

var

s, sqrx, s2: extended;

n: byte;

{Раздел операторов функции sin2}

begin {sin2}

s: = x2; {Первый член ряда}

n: = 1; {Степень члена ряда}

s2: = 0; {Сумма ряда}

sqrx: = sqr (x2)

while abs (s) > e2

do begin

s2: = s2 + s;

n: = n + 2;

s: = - s * sqrx / ( (n - 1) * n)

end;

{Присваивание вычисленного значения s2

функции sin2}

sin2: = s2

end; {sin2}

{Основной текст - исполняемая часть программы}

begin {Program}

writeln ('Вычисление функции SIN (X): ');

write ('Введите заданную точность: ');

readln (epsilon);

write ('Введите аргумент функции: ');

readln (x);

{Вызов процедуры sin1}

sin1 (epsilon, x, sinus);

{При обращении к процедуре sin1 формальные

параметры e1, x1, s1 заменяются фактическими

epsilon, x, sinus}

write ('Значение, вычисленное с помощью ');

writeln ('суммирования ряда: ');

write ('Результат выполнения ');

write ('процедуры sin1 ');

writeln (sinus: 20: 18);

write ('Результат использования ');

write ('функции sin2: ');

writeln (sin2 (epsilon, x): 20: 18);

{Здесь обращение к функции происходит внутри

оператора writeln, что допустимо, поскольку

аргументом этого оператора является выражение}

write ('Значение, вычисленное с помощью ');

write ('стандартной функции: ');

writeln (sin (x): 20: 18);

writeln;

end. {Program}

Заметим, что операторы write, writeln, read, readln на самом деле осуществляют вызов стандартных процедур ввода-вывода языка Turbo Pascal. Так же, как и стандартные функции, эти процедуры не нуждаются в предварительном описании, в отличие от создаваемых программистом процедур и функций.

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

Program Procedures_and_functions_2;

{Описание глобальных переменных n, summa}

var

n: longint;

summa: byte;

Procedure Sum (n: longint; var ss: byte);

{Имя формального параметра n совпадает с именем

глобальной переменной n}

{Раздел операторов процедуры Sum}

begin {Sum}

if n <> 0

then begin

ss: = ss + abs (n mod 10);

Sum (n div 10, ss)

{Рекурсивный вызов процедуры Sum}

end

end; {Sum}

{Основной текст - исполняемая часть программы}

begin {Program}

writeln ('Вычисление суммы цифр: ');

write ('Введите любое целое число, которое ');

write ('по модулю не превосходит ');

writeln ('2 147 483 647');

readln (n);

summa: = 0;

Sum (n, summa);

writeln ('Сумма цифр ', n: 9, ' равна ', summa: 3)

end. {Program}

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

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

Описание процедурного типа:

type

<имя типа> = <заголовок процедуры или

функции без указания имени

процедуры или функции>;

Рассмотрим, например, фрагмент программы, в котором нам необходимо вывести на экран таблицы значений нескольких функций. Пусть это будут функции f1, f2.

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

Обе функции f1, f2 ? действительные функции одного действительного переменного. Введем процедурный тип func. Фрагмент программы, в котором значения функций f1 и f2 выводятся на экран, оформим в виде процедуры PrintFunction.

Program Procedures_and_functions_3;

type

func = function (x: real): real;

Function f1 (x: real): real; far;

begin

f1: = (sin (x) + 1) * exp (-x)

end;

Function f2 (x: real): real; far;

begin

f2: = (cos (x) + 1) * exp (-x)

end;

Procedure PrintFunction (f: func);

{Формальный параметр f имеет процедурный тип func}

{Описание локальных переменных}

var

a, b, delta: extended;

begin {PrintFunction}

write ('Задайте отрезок, на котором ');

writeln ('будут вычисляться значения функции: ');

write ('Начало отрезка: ');

readln (a);

write ('Конец отрезка: ');

readln (b);

write ('Задайте шаг вычисления ');

write ('значений функции: ');

readln (delta);

b: = b + 0.0001;

while a < b

do begin

write (' x = ', a: 5: 3);

writeln (' f = ', f (a): 5: 3);

{Обращение к функции f в операторе

writeln}

a: = a + delta

end;

writeln

end; {PrintFunction}

{Основной текст - исполняемая часть программы}

begin {Program}

writeln ('Таблица функции (SIN (X) +1) *EXP (-X): ');

{Обращение к процедуре PrintFunction

с фактическим параметром-функцией f1}

PrintFunction (f1);

writeln;

writeln ('Таблица функции (COS (X) +1) *EXP (-X): ');

{Обращение к процедуре PrintFunction

с фактическим параметром-функцией f2}

PrintFunction (f2);

writeln

end. {Program}

Перечисляемый тип, тип-диапазон и оператор CASE

Описание перечисляемого типа:

type

<имя типа> = (<список значений

через запятую>);

Пример: пусть нам необходима переменная, которая должна принимать значения, соответствующие названиям месяцев.

Определим тип month (месяц) и переменную m1 этого типа.

type

Month = (January, February, March, April,

May, June, July, August, September,

October, November, December);

var

m1: Month;

Здесь каждое значение переменной m1 является строковой константой. К сожалению, русские слова употреблять нельзя!

Альтернативно, переменную перечисляемого типа можно объявлять в программе без предварительного описания самого типа.

var

<имя переменной>: (<список принимаемых

значений через запятую>);

var

m2: (January, February, March, April, May,

June, July, August, September, October,

November, December);

Перечислимый тип относится к порядковым типам данных.

Данные любого порядкового типа имеют конечное множество возможных значений, которые можно определенным образом упорядочить. Каждому значению порядкового типа можно сопоставить порядковый номер значения.

Первое значение в списке, определяющем перечисляемый тип, получает порядковый номер 0, следующие значения ? 1, 2 и т.д.

Максимальное число возможных значений? 65536.

Ко всем порядковым типам применимы следующие функции:

К порядковым типам относятся также все целые типы, логический (boolean) и символьный (char), а также тип-диапазон.

Тип-диапазон ? это подмножество элементов другого порядкового типа, задаваемое своим первым и последним значениями.

Описание типа-диапазона:

type

<имя типа> = <минимальное значение>.

<максимальное значение>;

Пример: определим тип MonthNumber (номер месяца) как интервал целых значений от 1 до 12.

type

MonthNumber = 1.12;

var

n1: MonthNumber;

Альтернативно, переменную типа-диапазона можно объявлять в программе без предварительного описания самого типа.

var

<имя переменной>: <минимальное значение>.

<максимальное значение>;

var

n2: 1.12;

К переменным типа-диапазона применимы следующие функции:

Использование перечисляемых типов и типов-диапазонов повышает надежность программы благодаря возможности контролировать множество значений, которые могут принимать переменные перечисляемых типов. Для контроля возможного выхода значений переменных за границы допустимого диапазона служит опция RANGE CHECKING (меню OPTIONS ? COMPILER ? RUNTIME ERRORS ? RANGE CHECKING). В активном состоянии она позволяет контролировать выход значений переменных за границы диапазона.

Существуют также директивы компилятора, которые позволяют включать (директива {$R+}) и отключать (директива {$R-}) контроль границ диапазона.

Однако, значение переменной перечисляемого типа нельзя ввести с клавиатуры с помощью оператора read или вывести на экран с помощью оператора write, т.е. такие операторы, как

readln (m1);

write (m2);

недопустимы. Для ввода-вывода данных перечисляемого типа необходимо писать специальные процедуры (см. ниже).

В этих процедурах удобно использовать оператор выбора case ? оператор, который позволяет выполнить то или иное действие в зависимости от значения специального параметра, называемого ключом выбора. Этот параметр может принимать значения любого порядкового типа.

Оператор выбора:

case <ключ выбора> of

<значение ключа выбора>: <оператор 1>;

<значение ключа выбора>: <оператор 2>;

<значение ключа выбора>: <оператор N>;

else <оператор N+1>

end;

Оператор выбора работает следующим образом: сначала вычисляется значение параметра ? ключа выбора, затем выполняется оператор, соответствующий вычисленному значению (он может быть составным). Если в списке выбора не будет найдена константа, соответствующая вычисленному значению, будут выполнен оператор, стоящий за служебным словом else. Ветвь else можно опускать. Если ветвь else опушена, а константа, соответствующая вычисленному значению ключа выбора не найдена, оператор case не выполнит никаких действий.

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

процедура функция turbo pascal

Процедура ReadMonthNumber присваивает значение переменной m1, когда пользователь вводит номер месяца. В программе процедура заменяет оператор read.

Процедуру присваивания значения переменной перечисляемого типа можно организовать и иначе. В следующей процедуре используется вспомогательная строковая переменная name (типа string, причем количество символов в строковой переменной не превышает 8). Строковая переменная не является переменной перечисляемого типа, поэтому в данном случае невозможно использовать оператор case.

Процедура WriteMonth выводит на экран название месяца, соответствующее значению переменной m1. В программе процедура заменяет оператор write.

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

Program Case_operator;

Procedure ReadMonthNumber (var m1: Month);

var

n1: MonthNomber;

begin {ReadMonthNumber}

write ('Введите номер месяца: ');

readln (n1);

case n1 of

1: m1: = January;

2: m1: = February;

3: m1: = March;

4: m1: = April;

5: m1: = May;

6: m1: = June;

7: m1: = July;

8: m1: = August;

9: m1: = September;

10: m1: = October;

11: m1: = November;

12: m1: = December

end

end; {ReadMonthNumber}

Procedure ReadMonthName (var m1: Month);

var

name: string [8];

begin {ReadMonthName}

write ('Введите название месяца: ');

readln (name);

if (name = 'январь') or (name = 'Январь')

or (name = 'ЯНВАРЬ')

then m1: = January;

if (name = 'февраль') or (name = 'Февраль')

or (name = 'ФЕВРАЛЬ')

then m1: = February;

if (name = 'март') or (name = 'Март')

or (name = 'МАРТ')

then m1: = March;

if (name = 'апрель') or (name = 'Апрель')

or (name = 'АПРЕЛЬ')

then m1: = April;

if (name = 'май') or (name = 'Май')

or (name = 'МАЙ')

then m1: = May;

if (name = 'июнь') or (name = 'Июнь')

or (name = 'ИЮНЬ')

then m1: = June;

if (name = 'июль') or (name = 'Июль')

or (name = 'ИЮЛЬ')

then m1: = July;

if (name = 'август') or (name = 'Август')

or (name = 'АВГУСТ')

then m1: = August;

if (name = 'сентябрь') or (name = 'Сентябрь')

or (name = 'СЕНТЯБРЬ')

then m1: = September;

if (name = 'октябрь') or (name = 'Октябрь')

or (name = 'ОКТЯБРЬ')

then m1: = October;

if (name = 'ноябрь') or (name = 'Ноябрь')

or (name = 'НОЯБРЬ')

then m1: = November;

if (name = 'декабрь') or (name = 'Декабрь')

or (name = 'ДЕКАБРЬ')

then m1: = December

end; {ReadMonthName}

Procedure WriteMonth (m1: Month);

begin {WriteMonth}

case m1 of

January: writeln ('январь. ');

February: writeln ('февраль. ');

March: writeln ('март. ');

April: writeln ('апрель. ');

May: writeln ('май. ');

June: writeln ('июнь. ');

July: writeln ('июль. ');

August: writeln ('август. ');

September: writeln ('сентябрь. ');

October: writeln ('октябрь. ');

November: writeln ('ноябрь. ');

December: writeln ('декабрь. ')

end

end; {WriteMonth}

{Основной текст - исполняемая часть программы}

begin {Program}

{Задается номер месяца}

ReadMonthNumber (m1);

{На экран выводится название месяца}

write ('Этот месяц - ');

WriteMonth (m1);

{Задается название месяца}

ReadMonthName (m1);

{На экран выводится количество дней

в этом месяце}

write ('В этом месяце ');

case m1 of

February: writeln ('28 или 29 дней. ');

April, June, September,

November: writeln ('30 дней. ');

else writeln ('31 день. ')

end;

writeln

end. {Program}

Одномерные и многомерные массивы

Описание одномерного массива:

type

<имя типа> = array [<тип индекса>]

of <тип компонентов>;

Примеры:

type

symbolic = array [byte] of char;

{Массив символов, индексы принимают значения

типа byte}

vector = array [0.15] of real;

{Массив действительных чисел; индексы

принимают целочисленные значения от 0 до 15;

использован тип-диапазон}

var

s: symbolic;

a, b: vector;

Альтернативно, переменную типа array можно объявлять в программе без предварительного описания самого типа.

var

<имя переменной>: array [<тип индекса>]

of <тип компонентов>;

var

x: array [10.30] of byte;

Подобным образом, однако, нельзя описывать переменные в заголовке процедуры или функции. Например, объявление процедуры

Procedure P (y: array [0.15] of real);

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

Procedure P (y: vector);

причем тип vector описан перед описанием процедуры P.

Тип string [n] (строка) в языке Turbo Pascal во многом аналогичен типу array [0. n] of char, т.е. одномерному массиву символов (n ? максимальное количество символов в строке, некоторая константа).

В отличие от обычного массива, однако, количество символов в строке может меняться от 0 до n.

Максимальное количество символов в строке можно не указывать, при этом длина строки принимает максимально возможное значение n = 255. К каждому символу в строке можно обращаться так же, как к элементу массива, например,

var

st: string [40];

if st [5] = 'a' then.

Если при обращении к некоторой процедуре или функции необходимо использовать переменную типа string, этот тип, так же, как и в случае массива, должен быть описан заранее.

Иными словами, объявление процедуры

Procedure P1 (z: string [10]);

является недопустимым. Правильным в данном случае будет

type

str = string [10];

Procedure P1 (z: str);

Многомерные массивы можно понимать как "массив массивов" и описывать следующим образом, например,

type

multiarray1 = array [0.5] of array [-2.2]

of array [char] of integer;

Такое описание, однако, громоздко и неудобно. Существует более компактный способ.

Описание многомерного массива:

type

<имя типа> = array [<тип индекса>,.

<тип индекса>]

of <тип компонентов>;

type

multiarray2 = array [0.5, - 2.2, char]

of integer;

В языке Turbo Pascal можно с помощью одного оператора присвоить всем элементам одного массива значения, которые имеют элементы другого массива. Например, для массивов a и b, описанных выше, допустим оператор a: = b;

В то же время с помощью одного оператора присваивания нельзя присвоить всем элементам массива одно и то же значение, т.е. оператор типа b: = 0; недопустим; необходимо использовать оператор цикла.

Подобным образом, для того, чтобы сравнить элементы двух массивов, необходимо сравнивать их поэлементно, т.е. в цикле последовательно сравнивать соответствующие элементы. Использование оператора

if a = b then.

в данном случае является недопустимым.

Для того, чтобы ввести значения всех компонентов массива с клавиатуры или вывести значения всех компонентов массива на экран, также необходимо использовать операторы циклов. С помощью операторов read/write можно ввести/вывести только отдельные компоненты массива, иначе говоря, оператор

write (a [i]);

является правильным, а оператор

write (a);

недопустим. Для ввода-вывода компонентов массива удобно писать специальные процедуры.

Подчеркнем в связи с этим, что число компонентов массива всегда фиксировано. Это означает, в частности, что нельзя написать процедуру вывода на экран всех значений компонент одномерного массива, который содержит произвольное число компонентов. Недопустимо описание массива

var

n: byte;

type

c = array [1. n] of word;

где

n описана как переменная; если же n описана как константа, такое описание допустимо.

Существуют определенные способы, которые позволяют работать с массивами с переменным числом компонентов, например, открытые массивы, когда описывается только тип компонентов массива, но не тип его индексов.

В качестве примера работы с массивами рассмотрим программу, которая находит максимальные и минимальные элементы матрицы 55. Программу удобно разбить на несколько процедур.

Program Arrays;

type

matrix = array [1.5, 1.5] of integer;

var

m: matrix;

Procedure ReadMatrix (var m: matrix);

{Процедура позволяет ввести с клавиатуры элементы

матрицы m}

var

i, j: byte;

begin {ReadMatrix}

for i: = 1 to 5

do for j: = 1 to 5

do begin

write ('m [', i, ',', j,

'] = ');

read (m [i, j])

end

end; {ReadMatrix}

Procedure WriteMatrix (m: matrix);

{Процедура позволяет вывести на экран

элементы матрицы m}

var

i, j: byte;

begin {WriteMatrix}

for i: = 1 to 5

do begin

for j: = 1 to 5

do write (' m [', i, ',', j,

'] =', m [i, j]: 3);

writeln

end

end; {WriteMatrix}

Procedure MaxElement (m: matrix);

{Процедура находит максимальные элементы

матрицы m}

var

i, j: byte;

max: integer;

begin {MaxElement}

max: = m [1,1];

for i: = 1 to 5

do for j: = 1 to 5

do if m [i, j] > max

then max: = m [i, j];

writeln ('Максимальные элементы матрицы M: ');

for i: = 1 to 5

do for j: = 1 to 5

do if m [i, j] = max

then writeln (' m [', i, ',',

j, '] =', m [i, j]: 3)

end; {MaxElement}

Procedure MinElement (m: matrix);

{Процедура находит минимальные элементы

матрицы m}

var

i, j: byte;

min: integer;

begin {MinElement}

min: = m [1, 1];

for i: = 1 to 5

do for j: = 1 to 5

do if m [i, j] < min

then min: = m [i, j];

writeln ('Минимальные элементы матрицы M: ');

for i: = 1 to 5

do for j: = 1 to 5

do if m [i, j] = min

then writeln (' m [', i, ',',

j, '] =', m [i, j]: 3)

end; {MinElement}

begin {Program}

ReadMatrix (m);

WriteMatrix (m);

MaxElement (m);

MinElement (m)

end. {Program}

Литература

1. В.Э. Фигурнов, IBM PC для пользователя. Краткий курс, М., 1999.

2. В.В. Фаронов, Turbo Pascal 7.0. Начальный курс, М., Изд-во "Нолидж", 1998.

3. Л.А. Бугаев, Г.М. Чечин, К.Н. Жучков, Методические указания к проведению практических занятий по курсу "Информатика". Вып.1.1 Необходимые определения и команды для работы на компьютере. Элементы языка Pascal (часть I), Ростов-на-Дону, УПЛ РГУ, 1998.

4. Л.А. Бугаев, Г.М. Чечин, К.Н. Жучков, Методические указания к проведению практических занятий по курсу "Информатика". Вып.1.4 Задачи для самостоятельного решения на компьютере, Ростов-на-Дону, УПЛ РГУ, 1998.

5. Шестакова Т.П. Методические указания по курсу "Программирование и вычислительная физика". Часть I. Основные конструкции языка Turbo Pascal. Простейшие типы данных, Ростов-на-Дону, УПЛ РГУ, 2003.

Размещено на Allbest.ru