Турбо-Паскаль 7.0

BEGIN

WriteLn(perimetr(10,4)+ perimetr(20,30)+ perimetr(3,8));

END.

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

В заголовке функции после скобок с формальными параметрами должен быть указан тип функции (у нас это Integer).

Внутри описания функции между BEGIN и END ей хотя бы раз должно быть присвоено какое-нибудь значение (у нас это perimetr:=2*(dlina+shirina)).

Рассмотрим более сложный пример. Вспомним задачу из 12.3 о среднегодовой температуре, где исходными данными является массив из 365 значений температуры. Попробуем узнать, в январе (дни 1-31) или в декабре (дни 335-365) самый теплый день месяца был теплее. Мы можем предвидеть, что для вычисления понадобятся два похожих фрагмента программы, каждый длиной строчки по три-четыре. Чтобы не писать два раза похожие фрагменты, создадим функцию нахождения максимального элемента из заданного диапазона массива температур. Назовем ее max. Используя ее, мы можем в программе записать, например, так: u:=max(20,30), подразумевая, что переменной u должно быть присвоено значение максимального элемента массива температур, выбирая из элементов с 20-го по 30-й. Вот программа:

VAR t : array [1..365] of Integer; { t - массив температур за год}

FUNCTION max (perv,posledn:Word) :Integer;

VAR i,m :Integer;

BEGIN

m:=t[perv];

for i:=perv+1 to posledn do if t[i]>m then m:=t[i];

max:=m

END;

BEGIN

........ {Здесь присваиваем значения элементам массива температур}

if max(1,31)>max(335,365) then WriteLn(`В январе') else WriteLn(`В декабре');

END.

Задание 120: В Паскале не хватает функции для вычисления произвольной целой степени числа. Создайте функцию Power такого смысла: Power(2,3) должна иметь значение 23, то есть 8.

Задание 121: Если вы никак не можете смириться с системой координат графического режима, то напишите пару простеньких функций (например, с именами x и y), которые позволят вам считать, что отныне ось y направлена вверх, а центр координат расположен в центре экрана. Если вы правильно напишете эти функции, то, например, оператор Circle (x(310), y(230), 10) нарисует вам кружочек в правом верхнем углу экрана.

3.3.3 Подпрограммы. Локальные и глобальные переменные

Будем называть процедуры и функции подпрограммами, так как они входят внутрь программы.

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

Исследуем взаимодействие подпрограмм в такой программе. Для этого рассмотрим глупую простую "сложную" программу А, вся задача которой - выполнить по порядку следующие вещи:

присвоить значение 5 переменной х,

затем вызвать процедуру В, зачем-то возводящую 10 в квадрат и печатающую текст "Результат равен ",

и наконец, напечатать значение х:

VAR x,y : Integer;

PROCEDURE B; BEGIN y:=10*10; Write('Результат равен ') END;

begin

x:=5;

B;

WriteLn(x);

end.

Очевидно, программа напечатает Результат равен 5.

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

Сами подпрограммы тоже достаточно велики, и каждая из них может использовать десятки переменных. При этом возникает опасность, что автор какой-нибудь подпрограммы случайно использует внутри подпрограммы для ее нужд имя переменной, используемой в другой подпрограмме или в общей программе для других нужд, и таким образом испортит ее значение. Пусть, например, в нашей процедуре В ее автор опрометчиво присвоил бы значение 10*10 переменной с именем х. Тогда программа выглядела бы так:

VAR x,y : Integer;

PROCEDURE B; BEGIN x:=10*10; Write('Результат равен ') END;

begin

x:=5;

B;

WriteLn(x);

END.

Очевидно, данная программа напечатала бы Результат равен 100.

Для защиты от таких ошибок руководитель проекта должен внимательно следить, чтобы разные подпрограммы не использовали переменных с одинаковыми именами. Но для больших программ этот контроль очень трудоемок и неудобен. Вместо этого в современных языках программирования разработан механизм локальных переменных. Локальная переменная - это переменная, описанная не в главной программе, а внутри подпрограммы. Если программист В знает, что его число 10*10 нигде, кроме как в процедуре В, не нужно, он описывает соответствующую переменную х внутри процедуры В, ничуть не заботясь, что переменные с таким же именем встречаются в других местах программы:

VAR x : Integer;

PROCEDURE B;

VAR x : Integer;

BEGIN x:=10*10; Write('Результат равен ') END;

begin

x:=5;

B;

WriteLn(x);

END.

Данная программа напечатает Результат равен 5. Произойдет это вот по какой причине: Переменные, описанные внутри и снаружи подпрограммы, компилятор считает разными переменными, даже если они имеют одинаковые имена. Переменная х, описанная в программе, это совсем другая переменная, чем х, описанная в подпрограмме, и помещаются эти переменные в разных местах памяти. Поэтому и не могут друг друга испортить. Вы можете вообразить, что это переменные с разными именами xглоб и xлок.

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

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

Рассмотрим еще один пример:

VAR x,z : Integer;

PROCEDURE B;

VAR x,y : Integer;

BEGIN

x:=20; y:=30; z:=40

END;

begin

x:=1; z:=2;

B;

WriteLn(x,' ',z)

END.

Программа напечатает 1 40. Пояснение: Оператор WriteLn(x,z) находится снаружи процедуры В, и поэтому локальная переменная х=20, описанная внутри В, из него не видна. Зато прекрасно видна глобальная переменная х=1, которую он и печатает. Переменная же z не описана внутри В, поэтому она глобальна, и оператор z:=40 с полным правом меняет ее значение с 2 на 40.

Для полной ясности приведу порядок работы компьютера с этой программой:

В сегменте данных оперативной памяти компилятор отводит место под Х глобальное и Z глобальное.

Программа начинает выполняться с присвоения значений Х глобальное = 1 и Z глобальное = 2.

Вызывается процедура В. При этом в стеке оперативной памяти отводится место под Х локальное и У локальное.

Присваиваются значения Х локальное = 20, У локальное = 30 и Z глобальное = 40.

Программа выходит из процедуры В. При этом исчезают переменные Х локальное = 20 и У локальное = 30.

Компьютер печатает Х глобальное = 1 и Z глобальное = 40.

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

3.3.4 Массивы как параметры

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

Задача: Имеется два массива, по два числа в каждом. Напечатать сумму элементов каждого массива. Использовать функцию sum, единственным параметром которой является имя суммируемого массива.

Программа:

TYPE vector = array [1..2] of Integer;

VAR a,b : vector;

FUNCTION sum (c:vector):Integer;

BEGIN sum:=c[1]+c[2] END;

BEGIN

a[1]:=10; a[2]:=20;

b[1]:=40; b[2]:=50;

WriteLn (sum(a),' ',sum(b));

END.

Начиная вычислять функцию sum(a), Паскаль подставляет в ячейки для элементов массива c значения элементов массива a. Начиная же вычислять функцию sum(b), Паскаль подставляет в ячейки для элементов массива c значения элементов массива b.

В заголовке функции неправильно было бы писать

function sum (c: array [1..2] of Integer):Integer.

Необходимо было сначала определить тип массива в разделе TYPE, а затем использовать это определение и в описании a и b, и в заголовке функции. Таково требование синтаксиса Паскаля.

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

Указание: Создать функции min(c:vector), max(c:vector) и raznitsa(c:vector).

3.3.5 Параметры-значения и параметры-переменные

Многие процедуры не только рисуют или звучат, но и, подобно функциям, вычисляют что-нибудь полезное. Например, процедура B из следующей программы увеличивает глобальную переменную x на значение параметра y.

VAR x: Integer;

PROCEDURE B (y:Integer);

BEGIN x:=x+y END;

BEGIN

x:=1000;

B(1);

WriteLn(x)

END.

Будет напечатано число 1001.

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

VAR x: Integer;

PROCEDURE B (y:Integer; var c:Integer);

BEGIN c:=c+y END;

BEGIN

x:=1000;

B(1, x);

WriteLn(x)

END.

Здесь y - хорошо знакомый нам параметр. Называется он параметр-значение. При начале выполнения подпрограммы для параметра-значения выделяется место в стеке и туда посылается значение соответствующего фактического параметра (1).

c - незнакомый нам параметр-переменная, отличающийся от параметра-значения словом var. При начале выполнения подпрограммы для параметра-переменной никакого места в стеке не выделяется, а выделяется в стеке место только для адреса соответствующего фактического параметра. Подпрограмма через этот адрес работает непосредственно с переменной, являющейся фактическим параметром (x). Получается, что слово var «снимает защиту» со своего фактического параметра и вы вполне можете нечаянно его испортить.

Вопрос: имеет ли смысл писать B(1, 1000)? Ответ: не имеет, так как подпрограмма не будет знать, какой переменной присваивать результат 1001. Естественно, Паскаль выдаст сообщение об ошибке.

Задание 123: На двух станциях (A и B) в течение года измерялась температура. Соответственно созданы два массива чисел длиной 365. Затем оказалось, что на станции A термометр все время показывал температуру на 2 градуса выше настоящей, а на станции B - на 3 градуса ниже. Написать процедуру с двумя параметрами, которая исправляет исходный массив. Один формальный параметр - величина поправки, другой - параметр-переменная - массив температур.

3.3.6 Индукция. Рекурсия. Стек

Начну с классического примера о факториале. Факториалом целого положительного числа N называется произведение всех целых чисел от 1 до N. Например, факториал пяти равен 1*2*3*4*5, то есть 120. Факториал единицы считается равным 1.

Все понятно. Однако, существует еще один, совершенно ужасный способ объяснения, что такое факториал. Вот он:

“Факториал единицы равен 1. Факториал любого целого положительного числа N, большего единицы, равен числу N, умноженному на факториал числа N-1.”

Если вам уже все ясно, значит вы - математический талант. Для нормальных людей поясню. Чтобы последнее предложение было понятнее, возьмем какое-нибудь конкретное N, например, 100. Тогда это предложение будет звучать так: Факториал числа 100 равен числу 100, умноженному на факториал числа 99.

Ну и что? И как же отсюда узнать, чему равен какой-нибудь конкретный факториал, скажем, факториал трех? Будем рассуждать совершенно чудовищным образом:

Смотрю в определение: Факториал трех равен 3 умножить на факториал двух. Не знаю, сколько это. Спускаюсь на ступеньку ниже.

Смотрю в определение: Факториал двух равен 2 умножить на факториал единицы. Не знаю, сколько это. Спускаюсь еще на ступеньку.

Смотрю в определение: Факториал единицы равен 1. Вот - впервые конкретное число. Значит можно подниматься.

Поднимаюсь на одну ступеньку. Факториал двух равен 2 умножить на 1, то есть 2.

Поднимаюсь еще на ступеньку. Факториал трех равен 3 умножить на 2, то есть 6. Задача решена.

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

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

Обозначим кратко факториал числа N, как Factorial(N), и снова повторим наш индуктивный способ объяснения:

“Если N=1, то Factorial(N) = 1.

Если N>1, то Factorial(N) вычисляется умножением N на Factorial(N-1).”

В соответствии с этим объяснением напишем на Паскале функцию Factorial для вычисления факториала:

FUNCTION Factorial(N: Byte): LongInt;

BEGIN

if N=1 then Factorial :=1;

if N>1 then Factorial :=N* Factorial(N-1)

END;

BEGIN

WriteLn(Factorial(3))

END.

Обратите внимание, что в программе нигде не употребляется оператор цикла. Вся соль программы в том, что функция Factorial вместо этого включает в себя вызов самой себя - Factorial(N-1).

Что же происходит в компьютере во время выполнения программы? Механизм происходящего в точности соответствует нашему рассуждению по рекурсии.

Все начинается с того, что Паскаль пробует выполнить строку WriteLn(Factorial(3)). Для этого он вызывает функцию Factorial. Выполнение подпрограммы начинается с того, что в стеке отводится место для всех формальных параметров и локальных переменных, а значит и для нашего формального параметра N. Затем фактический параметр 3 подставляется на место формального параметра N, то есть в стек в ячейку N посылается 3. Затем выполняется тело функции. Так как 3>1, то Паскаль пытается выполнить умножение 3* Factorial(3-1) и сталкивается с необходимостью знать значение функции Factorial(2), для чего вызывает ее, то есть отправляется ее выполнять, недовыполнив Factorial(3), но предварительно запомнив, куда возвращаться.

Спускаюсь на ступеньку ниже. В соседнем месте стека отводится место для N. Это уже другое N, путать их нельзя. В эту ячейку N посылается 2. Затем выполняется тело функции. Пусть вас не смущает, что Паскаль второй раз выполняет тело функции, не закончив его выполнять в первый раз. Так как 2>1, то Паскаль пытается выполнить умножение 2* Factorial(2-1) и сталкивается с необходимостью знать значение функции Factorial(1), для чего вызывает ее.

Спускаюсь еще на ступеньку. В соседнем месте стека отводится место еще для одного N. В эту ячейку N посылается 1. Затем выполняется тело функции. Так как 1=1, то Паскаль вычисляет Factorial :=1. Вот - впервые конкретное число. Затем Паскаль пытается выполнить следующую строку if N>1 then Factorial :=N* Factorial(N-1). Поскольку нельзя сказать, что 1>1, то выполнение тела функции закончено. Значит можно подниматься.

Поднимаюсь на одну ступеньку. Паскаль возвращается внутрь тела функции (той, где N=2) и успешно выполняет умножение - Factorial :=2*1=2.

Поднимаюсь еще на ступеньку. Паскаль возвращается внутрь тела функции (той, где N=3) и успешно выполняет умножение - Factorial :=3*2=6. Задача решена.

После выхода из подпрограммы место в стеке освобождается.

Итак, рекурсией в программировании называется вызов подпрограммы из тела самой подпрограммы.

Теперь поговорим о переполнении стека. Размер стека в Паскале не превышает 64K. В нашем случае в стеке одновременно хранилось три копии формальных параметров и локальных переменных. Если бы мы вычисляли факториал десяти, то копий было бы десять. В более сложных, чем факториал, задачах стек может легко переполниться, о чем Паскаль сообщает, когда уже поздно.

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

Чем плох рекурсивный стиль программирования? Если мы для решения той же задачи напишем программу не с рекурсией, а с обычным циклом, то такая программа будет выполняться быстрее и потребует меньше памяти.

Задание 124: Напишите рекурсивную функцию fib для вычисления чисел Фибоначчи.

3.3.7 Сортировка

Пусть имеется ряд чисел: 8 2 5 4. Под сортировкой понимают их упорядочивание по возрастанию (2 4 5 8) или убыванию (8 5 4 2). Сортировать можно и символы (по алфавиту или коду ASCII) и строки (как слова в словаре).

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

Задача: Задан массив из 100 произвольных положительных чисел. Отсортировать его по возрастанию.

Если мы не можем сходу запрограммировать задачу, нужно подробно представить себе, в каком порядке мы решали бы ее вручную, без компьютера. Как бы мы сами сортировали 100 чисел? Мы бы запаслись пустым листом бумаги из 100 клеток. Затем нашли бы в исходном массиве максимальное число и записали его в самую правую клетку, а в исходном массиве на его месте записали бы число, меньшее самого маленького в массиве (в нашем случае подойдет 0). Затем нашли бы в изменившемся исходном массиве новое максимальное число и записали его на второе справа место. И так далее.

Вот программа для 10 чисел:

CONST N = 10;

TYPE vector = array[1..N] of Word;

CONST massiv_ishodn : vector =(3,8,4,7,20,2,30,5,6,9); {Это исходный массив}

VAR massiv_rezult : vector; {Это наш пустой лист бумаги}

i : Word;

FUNCTION maximum (m:vector; N:Word; var Nomer_max: Word):Word; {Это вспомогательная функция для поиска максимума в массиве}

VAR i,max:Word;

BEGIN

max:=m[1]; Nomer_max:=1; {Это порядковый номер максимального элемента }

for i:=2 to N do if max<m[i] then begin max:=m[i]; Nomer_max:=i end;

maximum:=max

END;

PROCEDURE sortirovka (mass_ish:vector; N:Word; var mass_rez:vector); {Основная процедура сортировки}

VAR i, Nom_max:Word;

BEGIN

for i:=1 to N do begin

mass_rez[N+1-i]:=maximum(mass_ish, N, Nom_max);

mass_ish[Nom_max]:=0

end{for};

END;

BEGIN

sortirovka (massiv_ishodn, N, massiv_rezult);

for i:=1 to N do Write (massiv_rezult[i],' '); {Распечатываем отсортированный массив}

END.

Функция maximum, кроме того, что сама имеет значение максимального элемента массива, выдает еще порядковый номер максимального элемента - Nomer_max. Это называется побочным эффектом функции.

Методов сортировки много. Приведенный метод - самый примитивный. Мало того, что нам пришлось расходовать память на второй массив, для выполнения сортировки массива из 100 элементов понадобилось бы около 100*100=10000 операций сравнения элементов массива между собой.

Существуют методы гораздо более эффективные. Приведу один из них - метод пузырька. Представьте себе тонкую вертикальную трубку с водой. Запустим снизу пузырек воздуха. Он поднимется до самого верха. Затем пустим еще один. Он поднимется наверх и остановится сразу же под первым. Затем запустим третий и так далее все сто пузырьков.

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

Вот алгоритм: Сравним первый элемент массива со вторым, и если второй больше, то ничего не делаем, а если первый больше, то меняем местами первый и второй элементы. В этом вся соль метода. Затем повторяем это со вторым и третьим элементами. Если третий больше, то ничего не делаем, а если второй больше, то меняем местами второй и третий элементы. Затем повторяем все это с третьим и четвертым элементами и так далее. Таким образом, максимальный элемент, как пузырек, поднимется у нас до самого верха.

Теперь, когда мы знаем, что элемент номер 100 у нас самый большой, нам предстоит решить задачу сортировки для массива из 99 элементов. Запускаем второй пузырек и так далее.

Метод пузырька не требует второго массива, да и сравнений здесь в два раза меньше.

Вот программа:

CONST N = 10;

TYPE vector = array[1..N] of Word;

CONST massiv : vector =(3,8,4,7,20,2,30,5,6,9);

VAR i : Word;

PROCEDURE puziryok (var mass:vector; Razmer:Word);

VAR i,m,c:Word;

BEGIN

for m:=Razmer downto 2 do begin {Всего пузырьков - 9}

for i:=1 to m-1 do begin {i увеличивается - пузырек ползет вверх}

if mass[i]>mass[i+1] then begin {Стоит ли обмениваться значениями}

c:=mass[i]; {Три оператора для обмена значений двух элементов с помощью}

mass[i]:= mass[i+1]; {транзитного элемента c}

mass[i+1]:=c

end{if}

end{for};

end{for};

END;

BEGIN

puziryok (massiv,N);

for i:=1 to N do Write (massiv[i],' '); {Распечатываем отсортированный массив}

END.

Задание 125: Отсортируйте по убыванию двумерный массив. Я имею в виду вот что:

a[1,1] >= a[1,2] >= … >= a[1,N] >=

>= a[2,1] >= a[2,2] >= …>= a[2,N] >=

>= a[3,1] >= a[3,2] >= …

3.4 Строгости Паскаля

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

3.4.1 Структура программы

Самая маленькая программа на Паскале имеет такой вид:

BEGIN END.

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

BEGIN WriteLn(1993); WriteLn(1994) END.

Обычно программа содержит переменные, константы, обращения к подпрограммам и прочие элементы. Все они должны быть описаны выше BEGIN. Например:

CONST k = 10;

VAR a : Real;

BEGIN

a:=5;

WriteLn(a+k)

END.

Таким образом, программа на Паскале состоит из двух и только двух разделов:

выше BEGIN расположен раздел описаний,

ниже BEGIN расположен раздел выполняемых операторов.

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

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

Переменные описываются после служебного слова VAR

Метки описываются после служебного слова LABEL

Константы описываются после служебного слова CONST

Процедуры описываются после служебного слова PROCEDURE

Функции описываются после служебного слова FUNCTION

Новые типы, определяемые программистом,

описываются после служебного слова TYPE

Если программа на Паскале использует модули, то они должны быть перечислены выше раздела описаний после служебного слова USES.

И наконец, программа может иметь заголовок, который состоит из служебного слова PROGRAM и в простейшем случае имени программы.

Пример программы:

PROGRAM Divan;

USES Crt,Graph;

Label met1,met2;

Const k = 100;

S = 'Хорошо!';

TYPE Kniga = array [1..k] of String;

Tablitsa = array [0..20,1..10] of Integer;

Minuta = 0..60;

VAR x,y : Real;

Uspevaemost : Tablitsa;

PROCEDURE Torpeda......

FUNCTION Invers......

begin

.......

end.

3.4.2 Структура процедур и функций

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

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

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

Приведу пример записи программы с вложенными подпрограммами:

PROGRAM Hard;

Uses ...

Label ...

Const ...

Type ...

Var ...

Procedure a1;

Const ...

Var ...

Procedure a11;

Label ...

Type ...

Var ...

begin

...

end;

Function f11

Var ...

begin

...

end;

begin

...

end;

Function f2;

Procedure a21;

begin

...

end;

begin

...

end;

begin

...

end.

Здесь в программу Hard входят процедура a1 и функция f2. В процедуру a1 вложены процедура a11 и функция f11. В функцию f2 вложена процедура a21.

Из f2 видна a1, но не видны a11 и f11. Точно так же из a21 видны a1 и f2, но не видны a11 и f11. Это значит, что в теле процедуры a21может содержаться вызов a1и f2, но не может содержаться вызов a11и f11.

3.4.3 Выражения

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

a := b+1 - здесь выражение - b+1

if c-6>f then … - здесь выражение - c-6>f

WriteLn (a+5) - здесь выражение - a+5

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

Арифметические выражения (то есть имеющие значением число):

0

2+5

Sqrt(b+1) - Sqr(a[4,i]+r) + 1

a[4,i] + vovka.ves

((w+b)/19)*(2/(w+1)+5)

Строковые выражения (то есть имеющие значением строку символов):

`Весна'

Copy(s,a,b)

Copy(s,a,b)+ `Весна'

Логические выражения (то есть имеющие значением true или false):

a>0

(a+c)/(d+8)<=b+1

c>'Ю'

stroka=`Весна'

Copy(s,a,b)+ `Весна' <> s1

a in b

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

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

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

3.4.4 Совместимость типов

Часто при запуске программы Паскаль выдает сообщение Type mismatch (несовместимость типов) и на этом основании отказывается выполнять программу. Так произойдет, например, при выполнении ошибочного фрагмента VAR y: Integer BEGIN y:=3/8: …., так как результат деления получается вещественный, а переменная y описана, как Integer. Нам нужно знать о том, какие типы совместимы, а какие нет.

Тип выражения с операндами разных типов. Что будет, если в одном выражении участвуют величины разных типов? Какого типа будет результат выражения? Например, какого типа будет сумма a+b в следующем фрагменте:

VAR a: Byte; b: Word;

BEGIN .... a+b ... ?

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

Если диапазон одного из типов входит в диапазон другого, то общим типом становится тип с большим диапазоном. В приведенном выше примере значение переменной a будет преобразовано к типу Word и полученная сумма также будет иметь этот тип.

Если диапазоны типов пересекаются, то общим типом становится ближайший тип, “охватывающий” оба типа.

В примере

VAR a: Integer; b: Word;

BEGIN .... a+b ...

значения a и b перед суммированием преобразуются к типу LongInt.

Если один из типов вещественный, а другой целочисленный, то общий тип - всегда вещественный.

Когда в выражение входит несколько операндов (например, a+b*c) то указанные правила применяются последовательно, пока не будет вычислено все выражение (сначала определяется тип произведения b*c и произведение вычисляется, затем исходя из получившегося типа определяется тип суммы и сумма вычисляется).

Требования к типам в операторе присваивания. Чтобы Паскаль мог выполнить оператор присваивания, тип переменной в левой части (тип 1) и тип выражения в правой части (тип 2) должны друг другу соответствовать по определенным правилам:

эти типы должны быть одинаковы

или, если эти типы не одинаковы, то диапазон типа 1 должен включать в себя диапазон типа 2, например:

Тип 1 Тип 2

(sun, mon, tue, wen) (sun, mon, tue)

String Char

или тип 1 - вещественный, тип 2 - целочисленный

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

3.4.5Форматы вывода данных

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

c:='Ф'; s:='хорошо'; i:=18; WriteLn(c,s,i)

мы увидим в строке экрана

Ф

х

о

р

о

ш

о

1

8

Мы можем приказать Паскалю отводить под каждое данное столько позиций в строке, сколько нам нужно:

WriteLn(c:3,s:8,i:4)

Вот что мы увидим в строке экрана:

Ф

х

о

р

о

ш

о

1

8

Здесь под c отведено поле в три позиции (с 1 по 3), начиная с левого края экрана. Под s отведено поле в 8 позиций (с 4 по 11). Под i отведено поле в 4 позиции (с 12 по 15). Информацией заполняется правая часть поля, а левая часть может остаться пустой.

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

r:=465.28073; WriteLn(r)

мы увидим на экране

	4	.	6	5	2	8	0	7	3	0	0	0	0	2	3	1	E	+	0	0	0	2

что означает 4.65280730000231 * 102 или, что то же самое, 465.280730000231. Обратите внимание на откуда-то взявшиеся цифры 231. Их появление связано с неточностью представления вещественных чисел в компьютере.

Еще один пример: r:=0.000000308; WriteLn(r)

	3	.	0	8	0	0	0	0	0	0	0	0	0	0	7	9	E	-	0	0	0	7

что означает 3.08000000000079 * 10-7 или, что то же самое, 0.000000308000000000079 .

Еще пример: r:= -0.000003; WriteLn(r)

-	2	.	9	9	9	9	9	9	9	9	9	9	9	9	5	3	E	-	0	0	0	6

что означает -2.99999999999953 * 10-6 или, что то же самое, -0.00000299999999999953, а это практически равно -0.000003.

Как избавиться от экспоненциального вида? Формат :9:3 прикажет Паскалю изобразить число типа Real в привычном для нас виде, отведя под него 9 позиций в строке, из них 3 позиции под дробную часть числа. Пример:

r:=465.28073; WriteLn(r:9:3)

		4	6	5	.	2	8	1

Обратите внимание, что дробная часть округлена, так как она целиком не умещается в отведенный формат.

Еще пример: r:=465.28073; WriteLn(r:10:0)

4

6

5

Еще пример: r:= -465.28073; WriteLn(r:10)

-	4	.	7	E	+	0	0	0	2

Это у нас получился вывод в "укороченном" экспоненциальном формате.

3.4.6 Переполнение ячеек памяти

После выполнения программы

VAR i:Byte;

BEGIN i:=250; WriteLn(i); i:=i+10; WriteLn(i) END.

мы увидим на экране числа 250 и 4. А почему не 250 и 260? Потому что тип Byte представляет только числа от 0 до 255. Если в процессе выполнения программы значение переменной вышло за диапазон своего типа, Паскаль не замечает ошибки, а в соответствующей ячейке оказывается ерунда. Это касается всех типов. Впрочем, ценой некоторой потери скорости Паскаль можно легко настроить на проверку выхода за диапазон (см. приложение).

3.4.7Дерево типов

Паскаль предоставляет солидные возможности для конструирования новых типов. Так, если мы пишем VAR a : array[1..10] of array [2..5] of set of Byte, то имеем в виду, что переменная a является массивом array[1..10], который сконструирован из массивов array [2..5], каждый из которых сконструирован из элементов, являющихся множествами set, каждое из которых сконструировано из элементов типа Byte.

Схема, приводимая ниже, демонстрирует, какие типы из каких можно конструировать. Например, файлы можно конструировать из строк, а записи из массивов. А вот множества из вещественных чисел конструировать нельзя.

3.4.8 Синтаксисические диаграммы Паскаля

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

Есть два самых распространенных способа записи синтаксиса. С одним из них я вас познакомил в 5.2, другой использует так называемые синтаксические диаграммы. Здесь я буду использовать второй метод плюс еще третий - обычный словесный (когда понятность будет достаточным возмещением за нестрогость).

Синтаксическую диаграмму рассмотрим на примере. Все мы знаем, что имя - это цепочка букв, цифр и знаков подчеркивания, не начинающаяся с цифры. Это обычное словесное определение. А вот это же определение в виде синтаксической диаграммы:

Пользоваться синтаксической диаграммой нужно так. Заходите в диаграмму по стрелке. Оказавшись внутри «домика», записывайте на лист бумаги в строчку то, что там указано. Предположим, в нашем случае вы зашли в «букву». Значит, записывайте любую букву, например, N. Затем продолжайте путешествие строго по стрелкам. Оказавшись на развилке, поворачивайте в любую сторону, разрешенную стрелками. Снова оказавшись в «домике», приписывайте справа в строчку то, что там указано. Пусть, например, следующий ваш домик «цифра». Вы должны приписать справа к букве любую цифру, например, 8. Получится N8. И так далее. Когда надоест, добирайтесь до выходной стрелки. Вы гарантированно получите правильное имя.

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

Также во избежание затемнения смысла подробностями диаграммы будут не везде до конца конкретны. Например, в диаграмме имени я писал “буква”, а надо было - “латинская буква”.



3.5 Другие возможности Паскаля

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

3.5.1 Работа с файлами данных

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

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

Задача: Записать слово `Азия' и число 1998 на магнитный диск c: в текстовый файл с именем fedos, располагающийся в каталоге PASCAL.

Начнем с того, что придумаем файлу fedos псевдоним, которым мы будем пользоваться в программе. Пусть это будет fepas. Затем нам нужно объяснить Паскалю, что fepas - это текстовый файл, для чего мы начнем программу со строчки

Var fepas :Text;

Раздел операторов начинаем с того, что объясняем Паскалю, какое настоящее имя соответствует псевдониму fepas:

Assign (fepas, 'c:\PASCAL\fedos');

Затем переместим магнитную головку в начало файла для записи информации в файл (откроем файл для записи):

Rewrite (fepas);

Теперь запишем в файл нужную информацию:

WriteLn (fepas, `Азия');

WriteLn(fepas, 1998);

Поскольку мы не собираемся ничего больше писать в файл, то закрываем его для записи:

Close (fepas);

Вот программа целиком:

VAR fepas :Text;

begin

Assign(fepas, 'c:\PASCAL\fedos');

Rewrite(fepas);

WriteLn(fepas, `Азия');

WriteLn(fepas, 1998);

Close(fepas);

END.

После выполнения программы вы обнаружите в файле fedos две строки:

Азия

1998

Если бы вы вместо WriteLn использовали Write, то строка была бы одна:

Азия1998

Если к моменту выполнения программы файл fedos не существовал, то процедура Rewrite создаст пустой файл с таким именем в указанном каталоге. Если существовал, то стирает его содержимое.

Если вы не хотите стирать содержимое файла, а просто хотите дописать что-нибудь в его конец, то процедура Rewrite вам не подойдет. Вам вместо нее нужно будет употребить процедуру Append. Вот ее вызов - Append(fepas).

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

Assign(fepas, 'fedos')

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

А теперь решим обратную задачу: В некоем файле fedos записаны строки. Вывести первую и третью из них на экран монитора.

VAR fepas :Text;

a,b,c :String; {Три переменные в оперативной памяти, в которые будут

записаны первые три строки из файла}

begin

Assign(fepas, 'c:\PASCAL\fedos');

Reset(fepas); {Переместим магнитную головку в начало файла для считывания

информации из файла (откроем файл для считывания) }

ReadLn (fepas, a); {Читаем первую строку из файла}

ReadLn (fepas, b); {Читаем вторую строку из файла}

ReadLn (fepas, c); {Читаем третью строку из файла}

Close(fepas);

WriteLn(a); {Печатаем первую строку из файла}

WriteLn(c); {Печатаем третью строку из файла}

END.

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

Если третья строка числовая, то можно было бы описать переменную c, как числовую, а не строковую.

А теперь напишем программу, которая в цикле записывает в файл 10 строк, а затем для проверки их считывает.

VAR f :Text;

a,b :String;

i :Byte;

begin

Assign(f,'c:\PASCAL\textik.txt'); {Обозначим файл textik.txt из каталога PASCAL именем f}

Rewrite(f); {Переместим магнитную головку в начало файла для

записи информации в файл (откроем файл)}

WriteLn('Введите с клавиатуры 10 произвольных строк');

for i:=1 to 10 do begin

ReadLn(a); {Ввести с клавиатуры в оперативную память произвольную строку текста}

WriteLn(f,a) {Записать эту строку из оперативной памяти в файл}

end;

Close(f); {Закрываем файл для записи}

WriteLn('А теперь посмотрим, что мы записали в файл:');

Reset(f); {Переместим магнитную головку в начало файла для

считывания информации из файла (откроем файл)}

for i:=1 to 10 do begin

ReadLn(f,b); {Переслать из файла в оперативную память строку текста}

WriteLn(b) {Послать эту строку из оперативн.памяти на монитор}

end;

Close(f); {Закрываем файл для чтения}

end.

Если вы хотите прочесть текстовый файл, но не знаете, сколько там строк, то вам нужно какое-то средство, чтобы компьютер определил, когда заканчивается файл. Это средство - функция EOF (сокращение от end of file - «конец файла»). Вот фрагмент, решающий дело:

while NOT EOF(fepas) do ... ReadLn(fepas, ....)

пока нет конца файла fepas делай …

Задание 126: “База данных ваших школьных оценок”. Вы завели файл, в который записываете свои школьные оценки. Каждый раз, получив оценку, вы дописываете в файл оценку и предмет, по которому оценка получена. Создайте 4 программы:

Для дозаписи в конец файла очередной оценки и предмета.

Для вывода на экран всего файла.

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

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

Оформите каждую из четырех программ, как процедуру, и создайте единую программу - “Систему управления базой данных”, которая начинает работу с вопроса: “Чем будем заниматься - дозаписывать, выводить весь файл ...?” и в зависимости от ответа запускает одну из четырех процедур.

Задание 127: Вы можете помочь адмиралу из 12.13 и организовать чтение из файла всей нужной информации о подлодках.

Задание 128: Многие компьютерные игры позволяют “сохраняться”, то есть в любой момент игры при нажатии определенной клавиши записывать в файл все данные об этом моменте, чтобы в следующий раз, когда вы сядете играть, начинать не сначала, а с того момента, в который вы записались. В игре “Торпедная атака” организуйте при нажатии на клавишу S сохранение, то есть запись в файл имени игрока, уровня игры, количества выстрелов и количества попаданий. А при запуске игра должна спрашивать, будем ли возобновлять сохраненную игру или начинать новую.

3.5.2Вставка в программу фрагментов из других программных файлов

Теперь рассмотрим совсем другие файлы - те, в которых вы храните свою программу. Предположим, вы с другом решили создать программу из 7 процедур. Вы делаете 3 процедуры и тело программы, а ваш друг - 4 процедуры. Друг записал все 4 процедуры в файл VSTAVKA.pas на вашем компьютере. Вот он:

PROCEDURE fa ; BEGIN Sound(698); Delay(300); NoSound END;

PROCEDURE sol; BEGIN Sound(784); Delay(300); NoSound END;

PROCEDURE la ; BEGIN Sound(880); Delay(300); NoSound END;

PROCEDURE si ; BEGIN Sound(988); Delay(300); NoSound END;

Конечно, файл вашего друга не является законченной программой и сам по себе не запускается.

А вот ваша программа:

USES CRT;

PROCEDURE doo; BEGIN Sound(523); Delay(300); NoSound END;

PROCEDURE re ; BEGIN Sound(587); Delay(300); NoSound END;

PROCEDURE mi ; BEGIN Sound(659); Delay(300); NoSound END;

begin

doo;re;mi;fa;sol;la;si;la;sol;fa;mi;re;doo

end.

Теперь вам нужно собрать оба куска в единую программу. Для этого вы можете скопировать текст из файла вашего друга в свой файл (как это делается, расказано в части IV). Но если вы не хотите этого делать, чтобы, скажем, не увеличивать свой файл, вы можете воспользоваться директивой компилятора $I. Директива компилятора - это специальная инструкция, вставленная в текст вашей программы на Паскале и предназначенная для управления компьютером на этапе компиляции вашей программы. Директива компиляции имеет вид {$....} и Паскаль не путает ее с обычным комментарием только из-за наличия значка доллара. Символы, стоящие после значка доллара, и являются управляющей информацией для компилятора. Директива {$I c:\PASC\F25} является приказом компилятору подставить в это место текст, находящийся в файле F25 из каталога PASC диска c. Если файл находится в текущем каталоге, то достаточно указать его имя. Вот ваша готовая к работе программа с директивой:

USES CRT;

PROCEDURE doo; BEGIN Sound(523); Delay(300); NoSound END;

PROCEDURE re ; BEGIN Sound(587); Delay(300); NoSound END;

PROCEDURE mi ; BEGIN Sound(659); Delay(300); NoSound END;

{$I VSTAVKA} {Директива компилятору на вставку текста из файла VSTAVKA}

begin

doo;re;mi;fa;sol;la;si;la;sol;fa;mi;re;doo

end.

3.5.3Модули программиста

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

FUNCTION st(a:Real; n:Word) :Real;

VAR step :Real;

i :Word;

BEGIN

step:=1;

for i:=1 to n do step:=step*a;

st:=step

end;

BEGIN

WriteLn(st(2,3)) {Это 2 в кубе, то есть 8}

END.

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

Описать st и другие часто встречающиеся процедуры и функции в другом файле и использовать директиву $I.

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

Второй способ немного сложнее, но намного лучше первого. Вот как будет выглядеть ваш модуль:

UNIT Mathemat; {Заголовок модуля с придуманным вами именем}

INTERFACE {Раздел ИНТЕРФЕЙСА}

FUNCTION st(a:Real; n:Word) :Real;

IMPLEMENTATION {Раздел РЕАЛИЗАЦИИ}

FUNCTION st;

VAR step :Real;

i :Word;

BEGIN

step:=1;

for i:=1 to n do step:=step*a;

st:=step

end;

BEGIN {Раздел ИНИЦИАЛИЗАЦИИ, у нас он пуст}

END.

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

USES Mathemat;

Begin

WriteLn(st(10,6) :20:4); {Это 10 в шестой степени}

WriteLn(st(5, 3) :20:4); {Это 5 в кубе}

End.

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

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

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

Когда вы в первый раз запустите на выполнение программу, вызывающую ваш новый модуль, этот модуль откомпилируется и сохранится на диске под именем Mathemat.tpu. В следующий раз будет использоваться именно он, а не Mathemat.pas (до тех пор, пока вы не измените текст модуля).

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

UNIT Mygraph;

INTERFACE {Раздел ИНТЕРФЕЙСА}

PROCEDURE krest(x_tsentr, y_tsentr, razmer:Word);

{Задаются координаты центра и размер креста}

PROCEDURE treug(x1, y1, x2, y2, x3, y3 :Word);

{Задаются координаты трех вершин треугольника}

IMPLEMENTATION {Раздел РЕАЛИЗАЦИИ}

USES Graph; {Без этого не будет работать процедура Line}

PROCEDURE krest; BEGIN

Line(x_tsentr-razmer, y_tsentr, x_tsentr+razmer, y_tsentr);

Line(x_tsentr, y_tsentr-razmer, x_tsentr, y_tsentr+razmer);

END;

PROCEDURE treug; BEGIN

Line(x1,y1,x2,y2);

Line(x2,y2,x3,y3);

Line(x3,y3,x1,y1);

END;

{Раздел ИНИЦИАЛИЗАЦИИ}

VAR d,m :Integer; {Переменные для инициализации графики}

BEGIN

d:=0;

InitGraph(d,m,'<путь к гр.др>');{Инициализация графики}

SetColor(Yellow); {Рисуем рамочку}

SetLineStyle(0,0,ThickWidth);

Rectangle(10,10,630,470);

SetColor(White); {Возвращаем нормальный цвет}

SetLineStyle(0,0,NormWidth) {Возвращаем нормальную толщину линии}

END.

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

Вот программа, чертящая крест, треугольник и кружок:

USES Mygraph,Graph;

BEGIN

treug(500,50,600,300,450,450);

krest(200,150,80);

Circle(100,350,40);

ReadLn;

END.

Обращение здесь к модулю Graph понадобилось только из-за желания нарисовать кружок.

Использование модулей лучше использования директивы $I хотя бы по двум причинам:

Модуль уже откомпилирован и не требует каждый раз компиляции.

Объем программы без модулей не может превышать 64К. Каждый модуль может вмещать в себя дополнительные 64К.

Задание 129: Если хотите, создайте себе модули Music, Graphica или какие-нибудь другие.

3.5.4Дополнительные процедуры и функции модуля Graph

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

Функция	Смысл
GetMaxX :Integer	Выдает максимально возможную горизонтальную координату экрана
GetMaxY :Integer	Выдает максимально возможную вертикальную координату экрана
GetPixel (x,y :Integer) :Word	Выдает номер цвета пиксела с координатами x и y.

А вот еще процедуры рисования:

Процедура	Смысл
Arc (x,y :Integer; fi1,fi2,r :Word)	Рисует дугу окружности с центром в точке x,y и радиусом r. Дуга начинается от угла fi1 градусов и кончается углом fi2 градусов.
PieSlice (x,y :Integer; fi1,fi2,r :Word)	Закрашенный сектор круга. Дуга сектора определяется так же, как в процедуре Arc. Цвет и стиль заливки определяются процедурой SetFillStyle.
FillEllipse (x,y :Integer; rx,ry :Word)	Закрашенный эллипс с центром в точке x,y и радиусами rx,ry. Цвет и стиль заливки определяются процедурой SetFillStyle.
Sector (x,y :Integer; fi1,fi2,rx,ry :Word)	Закрашенный сектор эллипса. Опирается на дугу эллипса с центром в точке x,y и радиусами rx,ry. Дуга начинается от угла fi1 градусов и кончается углом fi2 градусов.

Страница:

•  « 
•  2 
•  3 
•  4 
•  5 
•  6 
•  7 
•  8 
•  9 
•  10 
•  11 

учебное пособие "Турбо-Паскаль 7.0" скачать

Подобные документы

• Знакомство со средой Турбо Паскаль

  Развертывание системы на жестком диске, диалоговая система программирования Турбо Паскаль, запуск программы и выполнение задания. Функциональные клавиши и их назначение. Текстовый редактор, средства создания и редактирования текстов программ, курсор.
  
  реферат [18,6 K], добавлен 01.04.2010
  

• Основные понятия языка программирования Турбо Паскаль

  Основные сведения о системе программирования Турбо Паскаль. Структура программы на Паскале и ее компоненты. Особенности и элементы языка Турбо Паскаль. Порядок выполнения операций в арифметическом выражении, стандартные функции и оператор присваивания.
  
  лекция [55,7 K], добавлен 21.05.2009
  

• Компьютерная графика в среде Турбо Паскаль

  Особенности использования графического режима в среде Турбо Паскаль. Типы драйверов. Инициализация графики. Построение изображения на экране. Графические примитивы и работа с текстом. Разработка и реализация программ в среде Турбо Паскаль "Графика".
  
  курсовая работа [1,2 M], добавлен 26.09.2014
  

• Программирование на языке Паскаль в среде Турбо Паскаль

  Особенности программирования на языке Паскаль в среде Турбо Паскаль. Линейные алгоритмы, процедуры и функции. Структура данных: массивы, строки, записи. Модульное программирование, прямая и косвенная рекурсия. Бинарный поиск, организация списков.
  
  отчет по практике [913,8 K], добавлен 21.07.2012
  

• Элементы программирования на алгоритмическом языке Паскаль

  Язык программирования Турбо Паскаль. Запись алгоритма на языке программирования и отладка программы. Правила записи арифметических выражений. Стандартное расширение имени файла, созданного системным редактором. Составной оператор и вложенные условия.
  
  курсовая работа [75,0 K], добавлен 21.03.2013
  

• Графика Турбо Паскаля

  Использование графических возможностей Турбо Паскаля, подключение графического модуля Graph. Графические функции и процедуры. Общая структура графической программы. Построение фигур, определение цветов и стилей, работа с текстом, сообщения об ошибках.
  
  реферат [109,3 K], добавлен 28.04.2010
  

• Программирование на Турбо Паскале

  Правила описания множественных типов данных, приемов использования множеств и операций над множествами в Паскаль-программах. Разработка в Турбо Паскале программы вывода всех согласных букв, которые входят хотя бы в одно слово заданного предложения.
  
  контрольная работа [30,8 K], добавлен 25.12.2010
  

• Основы программирования и алгоритмические языки

  Освоение технологии структурного программирования и применения стандартных методов работы с одномерными массивами при разработке и создании программы на языке Турбо Паскаль. Разработка программы методом пошаговой детализации с помощью псевдокода.
  
  реферат [276,9 K], добавлен 27.02.2008
  

• Среда разработки Турбо Паскаль 7.0. Базы данных

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

• Расчет стержня на устойчивость в Турбо Паскаль

  Расчет на устойчивость в системе программирования Турбо Паскаль. Определение критического напряжения стержня по формуле Ясинского, предельной гибкости в зависимости от материала. Программирование алгоритма расчета. Порядок ввода исходных данных.
  
  курсовая работа [1,0 M], добавлен 27.04.2013
  

Другие документы, подобные "Турбо-Паскаль 7.0"

• главная
• рубрики
• по алфавиту
• вернуться в начало страницы
• вернуться к началу текста
• вернуться к подобным работам