Вы находитесь на странице: 1из 28

Министерство образования Республики Беларусь

УО «Полоцкий государственный экономический колледж»

Система программирования
Delphi
(консольные приложения)

опорные конспекты
по дисциплине «Основы алгоритмизации и
программирования» для учащихся специальности
«Программное обеспечение информационных технологий»

С.Б. Готовская
преподаватель
информационных
технологий

2018

1
Основные понятия:
Алгоритм – четкая последовательность действий, приводящая к конечному результату.
Программа – алгоритм, записанный на языке программирования.
Алфавит языка – набор элементарных символов, используемый для составления программ.
Зарезервированные (служебные) слова – это слова, использующиеся только по своему прямому
назначению. Их нельзя использовать в качестве переменных. Примеры зарезервированных слов: AND,
GOTO, PROGRAM, ELSE, IF и другие.
Переменные (Var) – вид данных, который может изменять свое значение в ходе программы.
Константы (Const) – вид данных, который является постоянным на всем протяжении выполнения
программы.
Комментарии – некоторая запись, служащая для пояснения программы, которая записывается в
фигурных скобках.

Свойства алгоритмов:
Дискретность – алгоритм представляется как последовательность инструкций исполнителя. Каждая
инструкций выполняется только после того, как закончилось выполнение предыдущего шага.
Конечность (результативность) – алгоритм должен заканчиваться после выполнения конечного
числа инструкций.
Массовость – алгоритм решения задачи должен быть применим для некоторого класса задач,
различающихся лишь значениями входных данных.
Детерминированность (определенность) – каждый шаг алгоритма должен быть точно определен –
записан на формальном языке исполнителя. Детерминированность обеспечивает одинаковость
результата, получаемого при многократном выполнении алгоритма на одном и том же наборе входных
данных.

Типы алгоритмов:
Линейные алгоритмы – алгоритмы с последовательностью действий, следующих один за другим
Разветвляющиеся алгоритмы – выполнение действий обеспечивается в зависимости от результата
проверки условия (да или нет; истина или ложь)
Циклические алгоритмы (алгоритмы с повторением) – обеспечивается многократное выполнение
некоторой совокупности действий, которая называется телом цикла.
Способы описания алгоритмов:
Словесный – описание последовательности действий на естественном языке человеческого общения.
Формальный (структурно-стилизованный) – описание последовательности действий на формальном
языке (языке программирования)
Графический – изображение в виде блок-схемы.
Технологический цикл обработки программы
При разработке программ можно выделить несколько этапов решения задачи: 1)постановка задачи;
2)проектирование программы; 3)разработка алгоритма; 4)кодирование; 5)компиляция; 6)отладка и
тестирование.

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

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

2
3) Разработка алгоритма
На этом этапе разрабатываются детали проекта программы, перевод их на алгоритмический язык.
Детализация потребует нескольких стадий, от крупных блоков ко все более мелким, и в результате
получиться то, что называется алгоритмом решения задачи.

4) Кодирование
После того как алгоритм разработан, его записывают на языке программирования, и этот процесс
называют кодированием алгоритма. Для успешного выполнения требуется хорошее знание, как самого
языка, так и средств разработки программ: транслятора, компоновщика, программных библиотек и
многого другого.

Кодирование - создание Компиляция – Компановка – Отладка,


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

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

6) Отладка и тестирование программы


Целью данного этапа является поиск и устранение ошибок в программе. Ошибки бывают
синтаксические (нарушение грамматики алгоритмического языка) и смысловые (искажение самого
алгоритма решения задачи). Отладка — процесс выявления, локализации и устранения ошибок в
программе — осуществляется с помощью тестирования. Задача — убедиться в корректности алгоритма,
то есть получить уверенность, что программа выдает результаты, соответствующие задаче и исходным
данным. Тест — совокупность исходных данных для программы вместе с ожидаемыми результатами (с
учетом формы представления последних). Тесты разрабатываются до, а не вовремя или после
разработки программы. Готовится не один тест, а их совокупность — набор тестов.

3
Графическая запись алгоритма
Алгоритмы можно представлять как некоторые структуры, состоящие из отдельных базовых (т.е. основных)
элементов. Для их описания будем использовать язык схем алгоритмов (блок-схем).
Символы, используемые при построении блок-схемы алгоритмов
Обозначение начало или конец вычислительное ввод и вывод комментарий проверка подпрограмма заголовок
символа программы действие данных условий цикла
Функция
символа

1. Базовая структура ―следование‖.


Образуется последовательностью
действий, следующих одно за другим;
2. Базовая структура «ветвление»
Обеспечивает в зависимости от
результата проверки условия (да или
нет) выбор одного из альтернативных
путей работы алгоритма.
З. Базовая структура ―цикл‖.
Обеспечивает многократное выполнение
некоторой совокупности действий,
которая называется телом цикла.
Структура цикл имеет следующие
варианты: цикл—до; цикл—пока; цикл
с параметром.
На схемах СЕРИЯ обозначает один или
несколько любых операторов;
УСЛОВИЕ есть логическое выражение
(ЛВ) (если его значение ИСТИНА,
переход происходит по ветви ДА, иначе — по НЕТ). На схеме цикла с параметром использованы обозначения: ПЦ параметр
цикла, НЗ начальное значение параметра цикла, К3 — конечное значение параметра цикла, Ш — шаг изменения параметра.
Примеры структуры ветвление

Примеры структуры цикл


Задача: Найти сумму чисел от 1 до 10
начало
начало
начало

а=1 b=10 а=1 b=10


а=1 b=10

s=0 i=a s=0 i=a


s=0

s=s+i i<=b
i=a, b

i>b s=s+i
s=s+i s

i=i+1 i=i+1 s
s
конец

конец
конец

for repeat while


(цикл со счетчиком) (цикл с постусловием) (цикл с предусловием)

4
Пример оформления программы, использующих подпрограмму-процедуру

начало

a=0
Начало Sum(n,s)
b=3/(2*pi)
h:=(b-a)/n
e=0.00001
f=0
n=2
i=1(1)n
Sum (n,s1)

x:=a+h*i-h/2 s:=h*f n=n*2

fi:=1/(5- Sum(n,s2)
3*cos(x)) Конец Sum(n,s)
f=f+fi
abs(s1-s2) >=e

s1=s2

n=n*2

Sum (n,s2)

s2

конец

Пример функциональной схемы интерфейса программы

начало
(txt.exe)

открытие
логотипа
программы

открытие
рабочей
области

файл правка вид помощь выход

открыть отмена о программе


полноэкранный
сохранить конец
вырезать обычный
о разработчике
сохранить как панель управления
копировать
печать
вставить строка состояния
выход
найти

заменить

выделить всѐ

шрифт

5
Стандартные типы языка Паскаль
Целочисленный тип
Идентификатор Название Допустимые значения
Shortint 8 битовый, короткий целый -128 … 127
Integer 16 битовый, целый -32 768 … 32 768
Longint 32 битовый, длинный целый -2 147 483 648 … 2 147 483 647
Int64 64 битовый, длинный целый -263… 263-1
Byte 8 битовый, беззнаковый 0 … 255
Word 16 битовый, беззнаковый 0 … 65535
Символьный тип
Char Символьный Символы из расширенного набора символов
Логический тип
Boolean Логический False, True
Вещественный тип
Идентификатор Название Диапазон
Real 6-байтовый вещественный тип -1.7* 1038 … 1.7*1038,
-2.9*10-39 … 2.9*10-39
Single 4-байтовый вещественный тип с одинарной точностью -3.4* 1038 … 3.4*1038,
-1.5*10-45 … 1.5*10-45
Double 8-байтовый вещественный тип с двойной точностью -1.7* 10308 … 1.7*10308,
-5*10-324 … 5*10-324
Extended 10-байтовый вещественный тип с повышенной точностью -1.1* 104932 … 1.1*104932,
-1.9*10-4951 … 1.9*10-4951
Comp 8-байтовый сложный -263 + 1 … 263 - 1
Структурный тип
Array Массив
Set Множество
File Файл
Record Запись
Процедурный тип
Procedure Процедура
Function Функция

Строковый тип - String Ссылочный тип - Pointer Объектный тип - Object

Символьный тип (char)


Значениями данного типа является множество всех символов компьютера: русская или латинская большая или маленькая
буква, цифра, знак препинания, специальный знак (например, "+", "-", "*", "/", "", "=" и др.) или пробел " ".
Строковый тип (string)
Значением строковой величины является строка переменной длины (быть может пустая).
Логический тип (boolean)
Логический тип данных часто называют булевым по имени английского математика Д. Буля, создателя математической
логики. Bмеются две логические константы TRUE (истина) и FALSE (ложь).
Для сравнения данных предусмотрены следующие операции отношений: <, <=, =, <>, >, >=.
А также существуют специфичные для этого типа логические операции:
OR - или; AND - и; XOR – исключающее или; NOT - не.
Типы данных, определяемые программистом: Type
Интервальный тип данных
Позволяет задавать две константы, определяющие границы диапазона значений для данной переменной.
Type dni = 1 . . 31;
Перечисляемый тип данных
Задает упорядоченное множество значений путем перечисления имен, обозначающих эти значения.
Type Colour = (Red, Orange, Yellow, Green, Blue, Black);

Операции над целыми числами


Над целыми типами определены такие операции: "+" - сложение; " * " - умножение; " - " вычитание;
div - целочисленное деление; mod - получение остатка от целочисленного деления

7 3 6 2 46 10
6 2 div 6 3 div
40 4 div
1 0 6
mod mod mod
7 div 3 = 2 7 mod 3 = 1 6 div 2 = 3 6 mod 2 = 0 46 div 10 = 4 46 mod 10 = 6

6
Вещественные типы представляются с некоторой точностью.
В языке Паскаль числа могут быть представлены в двух видах: с фиксированной точкой и плавающей запятой.
Числа с фиксированной точкой изображаются десятичным числом с дробной частью, которая может быть и нулевой.
Например, 27.9, 5.00
Такие большие числа как 137.000.000 можно записать в виде чисел с
Математическая запись: Запись на Паскале: десятичным порядком. Такие числа имеют вид mEp. Здесь m - мантисса;
0,0004 4E -4 E - признак записи числа с десятичным порядком; p - степень числа 10.
6200 6,2E+3 Получится 1.37Е+8. Такие числа, представленные с десятичным
-25 -2,5E+1 порядком и называются числами с плавающей точкой. Компьютер, по
умолчанию, представляет действительные числа в виде чисел с плавающей запятой.

Мы можем ―заставлять‖ компьютер выдавать действительные числа с фиксированной точкой:


R:m:n, где R – действительное число, m – количество позиций, отводимых для целой части, n – количество позиций,
отводимых для дробной части.
Например, число Ch с фиксированной точкой, для вывода целой части этого числа достаточно 7 мест, а вывод дробной части
ограничим 2 (сотыми), то мы запишем вывод так: Write (Ch:7:2)
Структура программы
Среда Delphi Среда Pascal ABC
program Prg; Program имя;
Uses список_используемых_модулей;
{$APPTYPE CONSOLE}
Label - раздел меток
begin Const - раздел констант
Type - раздел типов
end.
Var - раздел переменных
{$APPTYPE CONSOLE} Procedure – раздел процедур
Директива для компилятора (компилятор генерирует Function - раздел функций
исполняемую программу как консольное приложение) Begin
Консоль — это монитор и клавиатура,
рассматриваемые как единое устройство.
End.
Консольное приложение — программа, предназначенная для работы в операционной системе MS-DOS (или в
окне DOS), для которой устройством ввода является клавиатура, а устройством вывода — монитор, работающий
в режиме отображения символьной информации (буквы, цифры и специальные знаки).
Создание консольного приложения: выбор из меню File команду New | Other, затем на
вкладке New появившегося диалогового окна NewItems - тип создаваемого приложения — Console Application.
Компиляция консольного приложения: выбор из меню Project команды Compile.
Выполнение: выбор из меню Run команды Run (или или нажав клавишу F9).
Сохранение проекта консольного приложения: выбор из меню File команды Save на экране появляется
диалоговое окно Save Project, в котором нужно ввести имя проекта.
Задача: Найти среднее арифметическое двух целых чисел
Program Prg;
Var a,b: integer; //тип целый
c: real; //тип вещественный
Begin
writeln (‗Введите числа‘); //оператор вывода
readln (a,b); //оператор ввода
c:=(a+b)/2;
writeln (‗c=‘,c); //оператор вывода
writeln (c:5:2); //оператор вывода целой части 3 места,
дробной части 2 места)
readln;
End.

7
Функции языка Паскаль
Название функции Действие Тип аргумента Тип результата
возвращает значение числа П с 19 без аргумента real
Pi знаками после запятой
вычисляет синус числа х real real
sin(х)
вычисляет косинус числа х real real
cos(x)
вычисляет арктангенс числа х. real real
arctan(x)
вычисляет экспоненту числа х. (ex) real real
exp(x)
вычисляет логарифм числа х real real
ln(x)
возводит 'а' в степень 'b' real real
power(a,b)
вычисляет модуль числа х. любой соответствует
abs(x) аргументу
вычисляет квадрат числа х любой соответствует
sqr(x) аргументу
вычисляет квадратный корень из х любой real
sqrt(x)
проверяет число х. на нечѐтность longint Boolean
odd(x)
возвращает случайное число из word word
random(x) интервала от 0 до х
выделяет целую часть от деления 'а' integer integer
a div b на 'b'
выделяет дробную часть от деления integer integer
a mod b 'а' на 'b'
получает целую часть числа х real longint
trunc(x) real
int(x)
округляет число х real longint
round(x)
вычисляет дробную часть числа х real real
frac(x)
находит следующие целое число integer integer
pred(x) после х
находит предыдущее целое число integer integer
succ (x) до х

Процедуры языка Паскаль


название процедуры действие тип аргумента (ов)
уменьшает переменную i на n i,n – longint
dec(i,n)
увеличивает переменную i на n i,n – longint
inc(i,n)
осуществляет немедленный выход из текущего блока без параметров
Exit
останавливает выполнение программы без параметров
Halt
инициализирует датчик случайных чисел без параметров
Randomize
преобразует число 'x' в строковое представление 's' x – число
str(x,s) s – string
преобразует строку 's' в число 'x' и возвращает x – число
val(s,x,c) позицию ошибки 'с' (если с=0, преобразование выпол.) s – string
c - integer

8
Условный оператор
Полная развилка Пример: является ли данное число четным?
if (условие) Program chet;
then (оператор) var a: integer;
Begin
else (оператор);
readln(a);
Неполная развилка
if (a mod 2)=0
if (условие) then writeln (‗chet‘)
then (оператор); else writeln (‗ne chet‘);
Использование нескольких операторов End.
if (условие) Пример: -10 < x < 10
then Program chet;
begin var x: integer;
(оператор1); Begin
(оператор2); readln(x);
(оператор3); if (x>-10) and (x<10)
then writeln (‗принадлежит промежутку‘)
end else writeln (‗не принадлежит‘);
else (оператор); End.
Оператор выбора
case (выражение) of Пример: составить программу перевода из
(список значений) : (оператор1); десятибалльной системы оценивания знаний в
пятибальную.
(список значений) : (оператор2);
Program perevod;
(список значений) : (оператор3); var a: integer;
……………………………….. Begin
еlse (оператор n); readln(a);
end; case а of
0,1,2,3: writeln (2);
4: writeln (3);
5,6,7: writeln (4);
8,9,10: writeln (5);
end;
End.
Процедура Break
Процедура Break позволяет выйти из операторов цикла For, While, Repeat без проверки условия.
Вызов процедуры Break приводит к немедленному выходу из самого внутреннего охватывающего его
цикла. Пример вычисления значения функции y=2*x+z
var x,y,z: Integer;
BEGIN
x := 1;
WriteLn ('Введите значение z: '); ReadLn (z);
While x<100 do
begin
y := 2*x+z; x:=x+1;
If y=50
then begin WriteLn ('y = 50'); Break end;
end;
If y=50 then WriteLn ('Цикл закончен!')
else WriteLn ('Цикл закончен! Но y<>50.');
END.
Процедура Continue
Процедура Continue вызывает преждевременное завершение выполнения тела цикла и переход к
следующему шагу цикла. Вызов процедуры Continue действует только на самый внутренний цикл.
Пример.
var x,y,z: Integer;
BEGIN
WriteLn('Будем вычислять значение функции y=2*x+z');
WriteLn ('в промежутках [1,6] и [13,18).');
9
Write ('Введите значение z=');
ReadLn(z);
For x:=1 to 17 do
begin
If (x>6) AND (x<13) then Continue;
y := 2*x+z;
WriteLn ('x=',x,' y=',y)
end
END.
Оператор GoTo
В практике программирования возникает необходимость нарушения последовательности выполнения
операторов (например, необходимо "обойти" участок программы, а вернуться к нему позже). Для этого
предназначен оператор перехода GoTo. Данный оператор служит для передачи управления из одной
точки программы в другую.
GoTo < Метка >
где: GoTo ("идти к") - служебное слово; Метка - целое число без знака в диапазоне [1,9999].
Объявление меток имеет вид:
label Метка;
Например: label 2;
В программе: GoTo 2; 2: y:=x/z
Здесь после оператора GoTo 2 выполняется оператор с меткой 2.

Оператор Exit
Выход из программы
Цикл со счетчиком
В циклах со счетчиком выполнение тела цикла должно повторяться заранее определенное число раз.
ПРИМЕР: Найти s=1+2+3+4+5+6+7+8+9+10

Шаг = 1 Шаг = -1
Var i,s: integer; Var i,s: integer;
Begin Begin
s:=0; s:=0;
for i:=1 to 10 do for i:=10 downto 1 do
s:=s+i; s:=s+i;
writeln(s); writeln(s);
end. end.

ПРИМЕР: Найти s=1*2*3*4*5*6*7*8*9*10

Var i,s: longint;


Begin
s:=1;
for i:=1 to 10 do
s:=s*i;
writeln(s);
end.

ПРИМЕР: Найти s=1+2+3+4+5+6+7+8+9+10


Цикл с предусловием Цикл с постусловием
Var i,s: integer; Var i,s: integer;
Begin Begin
s:=0; i:=1; s:=0; i:=1;
while i<=10 do repeat
begin s:=s+i;
s:=s+i; i:=i+1;
i:=i+1; until i>10;
end; writeln(s);
writeln(s); end.
end.

10
Массивы
Массив – таблица, содержащая конечное число элементов одного и того же типа, в которой каждый элемент имеет
номер, а все элементы общее имя. Номер элемента массива называется индексом.
Виды массивов: Одномерный массив (каждый элемент имеет идекс - одно число); Двумерный массив (матрица)
Матрицей размера n×m называется прямоугольная таблица специального вида, состоящая из n строк и m столбцов,
заполненная числами.
Пример одномерного массива:
а 7 3 9 1 14 3 8

i 1 2 3 4 5 6 7
a – имя всего массива; i – номер (индекс) элемента массива; a[i] – элемент массива
a[1]:=7 a[2]:=3 a[3]:=9 a[4]:=1 a[5]:=14 a[6]:=3 a[7]:=8
Описание типа линейного массива выглядит так:
1) Type <Имя типа>=Array [<Диапазон индексов>] Of <Тип элементов>
2) Var <Переменная-массив> : Array [<Диапазон индексов>] Of <Тип элементов>;
Var a : Array [1..7] Of integer; b, c : Array [1..10] Of Real; k : Array [2..10] Of Integer
Способы заполнения массива и вывода их содержимого на экран

1 способ 2 способ Программа ввода с 3 способ Программа заполнения массива


Program M1; клавиатуры 20 целых чисел и вывода их. значениям квадратов индексов элементов:
Var Program M2; Program M3;
A : Array [1..20] Of Integer; Var A : Array [1..20] Of Integer; Const N=50;
Begin i : Integer; Var A : Array [1..N] Of Integer;
A[1]:=7; A[2]:=32; Begin I : Integer;
A[3]:=-70; For i:=1 to 20 do Begin
.............. Readln(A[i]); For I:=1 to N do
A[20]:=56; For i:=1 to 20 do A[I]:=I*I;
Writeln(A[1],A[2],…,A[20]) Write(A[i]:3); For I:=1 to N do
End. End. Write(A[I]:3)
End.
4 способ Программа заполнения массива с помощью генератора случайных
чисел. Функция формирования случайных чисел Random. Выражение, дающее
целое случайное число в диапазоне [5,10]: Random(6)+5 Пример 1 Поменять местами два
Program M4; элемента массива с номерами k1 и k2
Const N=10; Begin
Var A : Array [1..N] Of Integer; I : Integer; x:=a[k1];
Begin a[k1] := a[k2];
randomize; a[k2] :=x;
For I:=1 to N do
Begin {Продолжение программы}
A[I]:= random(6)+5; Write(A[I]:3); End;
End;
End.

Пример 2 Найдем сумму элементов массива, элементы


Пример 3 Найти количество положительных элементов в
которого заданы случайно (от 0 до 20)
массиве. Числа в диапазоне [-10,10]
Const N=10;
Const N=10;
Var A : Array [1..N] Of Integer; S, I : Integer;
Var A : Array [1..N] Of Integer; I, S : Integer;
Begin
Begin
{заполнение массива элементами, заданными случайно}
randomize;
randomize;
For I:=1 To N Do
For I:=1 to N do
Begin
Begin
A[I]:= random(21)-10; Write(A[I]:3);
A[I]:= random(21); Write(A[I]:3);
End;
End;
Writeln;
Writeln;
For I:=1 to N do
{нахождение суммы элементов массива}
For I:=1 to N do if А[i]>0 then S:=S+1; { inc(S) }
S:=S+A[I]; Writeln(‗S=‘,S);
Writeln(‗S=‘,S); End.
End.
Пример 5 Получить массив B из четных элементов массива А.
Пример 4 Получить третий массив как сумму For i:=1 To n Do
соответствующих элементов двух заданных if a[i] mod 2 =0 then
For i:=1 To n Do Begin p:=p+1; B[p]:=A[i]; End;
С[i]:=A[i]+B[i]; For t:=1 to p do
Writeln(В[t]);

11
Пример 6 Найти максимальный элемент массива и его индекс
Найдем максимальный элемент двумерного массива.
Const N=10;
Var
A : Array [1..N] Of Integer;
i, max, x : Integer;
Begin
{ВВОД МАССИВА}
max := a[1]; {Предположим, что максимумом является первый элемент}
x := 1; {запомним номер этого максимального элемента}
for i := 1 to n do
if a[i] > max {если среди элементов массива нашелся больший элемент, то}
then
begin
max := a[i]; {внесем новое найденное значение в переменную Мах}
x:= i; {и запомним его номер}
end;
writeln (max,‘ ‗,x);
End.
Пример двумерного массива (матрицы):
Пример: а j 1 2 3 4 побочная диагональ:
i 1 7 3 9 1
2 5 -3 6 4
3 0 8 4 2
4 1 2 5 0

главная диагональ:
a – имя матрицы
i – номер (индекс) СТРОКИ элемента матрицы
j – номер (индекс) СТОЛБЦА элемента матрицы
a[i,j] – элемент массива
a[1,1]:=7 a[1,2]:=3 a[1,3]:=9 a[1,4]:=1
a[2,1]:=5 a[2,2]:=-3 a[2,3]:=6 a[2,4]:=4
a[3,1]:=0 a[3,2]:=8 a[3,3]:=4 a[3,4]:=2
a[4,1]:=1 a[4,2]:=2 a[4,3]:=5 a[4,4]:=0

Следом матрицы называется сумма диагональных элементов матрицы.


Описание матрицы:
Примеры описания:
Var a : Array [1..7,1..6] Of real;
b, c : Array [1..10,1..10] Of integer;

Пример 7 Пример 8
Найти сумму элементов матрицы. Дана матрица, элементы которой заданы случайно от -10 до 10. Найти
Program M7; количество отрицательных элементов.
Const N=10; M=10; Program M8;
Var A : Array [1..N,1..M] Of Const N=10; M=10;
Integer; Var A : Array [1..N,1..M] Of Integer;
i, j,S: integer; i, j,S: integer;
Begin Begin
For i:=1 to N do randomize;
For j:=1 to M do For i:=1 to N do
Readln(A[i,j]); For j:=1 to M do
For i:=1 to N do A[i,j]:= random(21)-10;
For j:=1 to M do For i:=1 to N do
S:=S+A[i,j]; begin
Writeln('S=',S); For j:=1 to M do
End. Write (A[i,j]);
Writeln;
end;
For i:=1 to N do
For j:=1 to M do
if А[i,j]<0 then S:=S+1;
Writeln('S=',S);
End.

12
Случайные числа
Процедура Randomize –
инициализирует генератор чисел. Если не написать, то будут генерироваться одни и те же числа.
Функция Random (N) –
выдает целочисленные значения в диапазоне от 0 до N-1
randomize;
формула диапазона [a,b] x:=random(b-a+1)+a;
X := random (b-a+1) + a;
Пример:
– вывести случайные числа в диапазоне: от 0 до 10 или [0,10] X := random (11);
– вывести случайные числа в диапазоне: от 5 до 10 или [5,10] X := random (6)+5; //Pascal ABC
Сдвиг элементов массива X:= random (5,10); // ABC Net
То есть на место текущего элемента записывается следующий
(или предыдущий) за ним элемент. В последнюю (или первую) ячейку массива записывается число 0.
Сдвиг массива на один шаг влево - это цикл от первого элемента до предпоследнего включительно
(a[i] := a[i+1]). В предпоследнюю ячейку записывается последний элемент. После цикла
присваивается 0 в последнюю ячейку массива.
Если массив сдвигается на один шаг вправо, то его следует "перебирать" с конца. На место элемента i
присваивается стоящий перед ним (i-1). В освободившуюся первую ячейку записывается ноль.
Сдвиг массива на один шаг вправо - это цикл от последнего элемента до второго включительно
(a[i] := a[i-1]). После цикла в первую ячейку массива записывается ноль. Количество шагов сдвига
определяется внешним циклом.
Преобразования матрицы
1) Сложение матриц (сумма матриц) A + B есть операция вычисления матрицы C, все элементы
которой равны попарной сумме всех соответствующих элементов матриц A и B, то есть каждый
элемент матрицы C равен: с[i,j] = a[i,j] + b[i,j]
2) Вычитание матриц (разность матриц) A - B есть операция вычисления матрицы C, все элементы
которой равны попарной разности всех соответствующих элементов матриц A и B, то есть каждый
элемент матрицы C равен: с[i,j] = a[i,j] - b[i,j]
3) Результатом умножения матриц Am×n и Bn×k будет матрица Cm×k такая, что элемент матрицы C,
стоящий в i-той строке и j-том столбце (cij), равен сумме произведений элементов i-той строки матрицы
A на соответствующие элементы j-того столбца матрицы B:
c[i,j] := 0;
for k := 1 to 4 do
c[i,j] := c[i,j] + a[i,k] * b[k,j];
4) Транспонирование матрицы - это операция над матрицей, при которой ее строки и столбцы
меняются местами: aTij = aji
Если матрица A имеет размер n×m, то транспонированная матрица AT имеет размер m×n
Так для матрицы А Транспонированная матрица будет выглядеть так AT
1 5 6 10
1 11 18 13
11 12 7 14
5 12 9 26 AT=
A= 18 9 19 13
6 7 19 21
13 26 21 2
10 14 13 2
5) Элементарные преобразования матрицы — это такие преобразования матрицы, в результате
которых сохраняется эквивалентность матриц, то есть, элементарные преобразования не изменяют
множество решений системы линейных алгебраических уравнений, которую представляет эта матрица.
Элементарными преобразованиями строк называют:
- перестановку местами любых двух строк матрицы;
- умножение на ненулевую константу любой строки матрицы;
- прибавление к любой строке матрицы другой строки, умноженной на ненулевое число.
Матрицы A и B называют эквивалентными матрицами если от матрицы A к матрице B перешли с
помощью элементарных преобразований над строками и обозначают A ~ B.
6) Обратная матрица A−1 — матрица, произведение которой на исходную матрицу A равно единичной
матрице E: A·A-1 = A-1·A = E
Единичной матрицей называется диагональная матрица, диагональные элементы которой равны 1.
7) Произведением матрицы A на число k называется матрица B = k · A того же размера, полученная из
исходной умножением на заданное число всех ее элементов: b[i,j] = k · a[i,j]

13
Процедуры и функции обработки символьной и строковой информации

1. Символьный тип данных описывают служебным словом Char:


Var b: Char;
Пример: b:=‘A‘; b:=‘5‘; b:=‘?‘;
Символьные константы заключаются в апострофы. Всего 256 различных символов.
Всѐ множество символов образует «таблицу символов». Символы в таблице пронумерованы целыми
числами от 0 до 255. Номер символа в таблице называют его кодом.
К символьным данным применимы операции сравнения: из двух символов меньше тот, который
встречается в таблице ASCII раньше.
Функции обработки символьной информации:
Функция Chr(x) предназначена для определения символа языка по коду;
Функция Ord(x) возвращает код символа.

2. Строковой называется последовательность символов определѐнной длины:


Var
k: String[15];
k: String;
В квадратных скобках указывается максимальная длина строки. Если максимальный размер не указан,
то он автоматически принимается равным 255.

Под склеиванием строк понимается последовательное объединение нескольких строк.


Например: а:=‘Я учу‘;
в:=‘паскаль!‘;
с:=а+‘ ‗+в; Получится: Я учу паскаль!
Операция сравнения двух строк происходит посимвольно направо: сравниваются коды
соответствующих символов до тех пор, пока не нарушится равенство. Две строки считаются равными,
если они равны по длине и совпадают посимвольно.

Функции и процедуры обработки строковой информации:


Название Назначение Пример
Copy(s,n,m) Копирует m символов строки s, начиная с n s:=‘алгоритм‘
символа s1:= copy (s,5,4) - ‗ритм‘
Delete(s,n,m) Удаляет m символов из строки s, начиная с n s:=‘алгоритм‘
символа delete (s,1,4) - ‗ритм‘
Insert(s1,s2,n) Вставляет строку s1 в строку s2, начиная с n s2:=‘алм‘
символа s1:=‘горит‘
insert (s1,s2,3) - ‗алгоритм‘
Length(s) Определяет количество символов в строке s s:=‘алгоритм‘
x:=length (s) -8
Pos(s1,s2) Определяет позицию строки s1 в строке s2 s2:=‘алгоритм‘
s1:=‘ритм‘
x:=pos (s1,s2) - 5 (x-целая)
Concat(s1,s2,s3) Объединяет строковые величины s1:=‘алго‘
s2:=‘ри‘
s3:=‘тм‘
s:=concat(s1,s2,s3) – ‗алгоритм‘
Str(n,s) Переводит числовое значение n в строковое s
Val(s,n,k) Переводит строку s в числовое значение n. Если
преобразование произошло успешно, то
переменной k присваивается значение 0, в
противном случае k содержит номер позиции
первого ошибочного элемента.

14
Так как char – порядковый тип, то к его значениям применимы следующие функции.
Succ – возвращает следующий символ литерного множества;
Pred – возвращает предыдущий символ литерного множества;
Ord – возвращает значение кода литеры;
Chr – возвращает значение литеры, является обратной по отношению к функции Ord.
Например,
Succ('0')='1' – символ, следующий за символом 0, равен символу 1.
Pred('3')='2' – символ, предшествующий символу 3, равен 2;
Chr(65)='A' – символ, соответствующий коду 65, равен А;
Ord('A')=65 – код символа А равен 65

Задача 1: Вывести символ по коду Таблицы кодировки символов.


Var
S : char;
Begin
S:=chr(192);
Writeln(S);
End.

Задача 2. Подсчитать количество букв О в слове MOLOKO.


Var
S : String;
I, N : integer;
Begin
Writeln('Введите строку');
Readln(S);
For I:=1 to Length(S) do {организуем цикл, начиная с первого символа}
if S[I]=‘O‘ then inc (N); { N:=N+1}
Writeln(N);
End.

Задача 3. Написать программу, проверяющую, является ли данное слово S перевертышем.


Var
S,B : String;
I : Byte;
Begin
Readln(S);
B:=''; {Переменной B присваиваем значение "пустая строка"}
For I:=1 to Length(S) do
B:=S[I]+B; {Символы строки S присоединяются к переменной B слева. Самым
левым окажется последний.}
If B=S
Then Writeln('Перевертыш') Else Writeln('Не перевертыш')
End.

Задача 4: Примеры использования функций readkey и keypressed


uses crt;
var key:char; uses crt;
begin
var i:integer;
repeat
key:=readkey; begin
if key=#49 then repeat
begin TextColor(i);
TextColor(1); writeln('ПАСКАЛЬ'); writeln('ПАСКАЛЬ');
end;
sleep(200);
if key=#50 then
begin i:=i+1;
TextColor(2); writeln('ПАСКАЛЬ'); until keypressed;
end; end.
if key=#51 then
begin
TextColor(3); writeln('ПАСКАЛЬ');
end;
until key=#13;
end.

15
Подпрограмма – это отдельная функционально независимая часть программы, написанная и оформленная так, что ее можно
многократно выполнять с различными входными данными в различных местах общей программы.
Любая подпрограмма обладает той же структурой, которой обладает и вся программа.
Досрочный выход из подпрограммы – процедура exit, из программы - halt.
Все переменные, которые использует подпрограмма, могут быть либо глобальные либо локальные.
Глобальными называются переменные, объявленные в основной программе и доступные как программе, так и всем ее
подпрограммам.
Локальными называются переменные, объявленные внутри подпрограммы и доступные только ей самой.
Обмен информацией между основной программой и подпрограммой может осуществляться только с помощью глобальных
переменных.
Процедура: с помощью параметров в процедуру при вызове передаются данные, а обратно в вызывающую программу
передаются значения, полученные в результате выполнения подпрограммы.
Функция: отличается от процедуры тем, что результат возвращается в виде значения этой функции.
ПРОЦЕДУРЫ
Procedure <имя процедуры>(формальные параметры : их тип);
Var
(локальные переменные)
begin
. . .
end ;
Простейший пример использования процедуры.
Найти максимальное из шести введенных чисел.
Program Pr;
Var
a, b, c, d, e, k, n, m, p, t, s :integer; {глобальные переменные}
Procedure Max(x, y: integer; var z: integer); { x,y – значения, z – результат }
Begin
If x>y Then z:=x
Else z:=y; формальные параметры: x, y, z
End; фактические параметры: a, b, n
Begin количество формальных параметров =
Writeln('Введите шесть чисел'); количество фактических параметров
Readln(a, b, c, d, e, k);
Max(a,b,n); или n:= Max(a,b); //для ABC Net
Max(c,d,m);
Max(e,k,p);
Max(n,m,t);
Max(p,t,s);
Writeln('Максимальным из всех является ',s); End.
ФУНКЦИИ
Function <имя функции>(формальные параметры: их тип): тип функции;
Var
(локальные переменные)
begin
. . .
end ;
Простейший пример использования функции.
Найти максимальное из шести введенных чисел.
Program Fn;
Var
a, b, c, d, e, k, n, m, p, t, s :integer; {глобальные переменные}
Function Max(x, y: integer): integer; { x,y – значения, Max – результат }
Begin
If x>y Then Max:=x
Else Max:=y;
формальные параметры: x, y
End;
фактические параметры: a, b
Begin
Writeln('Введите шесть чисел'); количество формальных параметров =
Readln(a, b, c, d, e, k); количество фактических параметров
n:=Max(a,b);
m:=Max(c,d);
p:=Max(e,k);
t:=Max(n,m);
s:=Max(p,t);
Writeln('Максимальным из всех является ',s); End.

16
РЕКУРСИЯ
Рекурсия (от латинского recursio - возвращение) – это такой способ организации вычислительного процесса, при котором
процедура или функция в ходе выполнения составляющих ее операторов обращается сама к себе.
Пример использования: Найти факториал числа.
1 способ
Program Rekurs;
Var
K : integer;
F : Longint;
Function Fact(N:integer) : LongInt;
Begin
if N <= 1 then Fact := 1
else Fact := N*Fact(N-1);
End;
Begin
read(K);
F := Fact(K);
writeln('Для числа ',K,' значение факториала равно ',F);
End.
2 способ
Program Rekurs;
Var
K : integer;
F : Longint;
Function Fact(N:integer) : LongInt;
Var i: integer;
Begin
Fact := 1;
result:=1;
For i:=1 to N do For i:=1 to N do
Fact := i*Fact(i-1); result:=i* result;
End;
Begin
read(K);
F := Fact(K);
writeln('Для числа ',K,' значение факториала равно ',F);
End.
ПРИМЕРЫ РЕКУРСИЙ
1. Печать двоичного представления натурального числа.
в обратном порядке в прямом порядке
var k:integer;
function rec(n:integer):integer;
begin
write(n mod 2); if n>1 then rec(n div 2);
if n>1 then n:=rec(n div 2); write(n mod 2);
end;
begin
readln(k); k:=rec(k);
end.
2. Для вычисления наибольшего общего делителя двух чисел также можно использовать рекурсивную функцию.
Function Nod(a,b:Integer):Integer;
Begin
If (a=0) or (b=0) Then Nod:=a+b Else
If a>b Then Nod:=Nod(a-b,b) Else Nod:=Nod(a,b-a)
End;
3. Каждое число Фибоначчи начиная с третьего равно сумме двух предыдущих чисел, а первые два равны 1 (1, 1, 2, 3, 5, 8,
13, 21, ...). В общем виде n-е число Фибоначчи можно определить так:
Ф(n)= 1, если n = 1 или n = 2
Ф(n-1) + Ф(n-2), если n > 2

Function Fib(n:Integer):Integer;
Begin
If n<=2 Then Fib:=1
Else Fib:=Fib(n-1)+Fib(n-2)
End;

17
«Организация библиотек. Стандартные библиотечные модули и модули пользователя. Структура
Unit-a»
Структурное программирование (СП) - способ программирования, при котором широко используются программные
блоки. Подпрограмма – объект программы, оформленный в виде, допускающем многократное обращение к нему из разных
точек программы. Можно применять как готовые к работе (стандартные) процедуры и функции, так и создаваемые самим
пользователем. Можно процедуры и функции объединить в библиотеку.
Стандартная (встроенная) процедура/функция не нуждается в предварительном описании, она доступна любой
программе, в которой содержится обращение к ней.
Модуль (Unit) – это библиотека, содержащая константы, описания типов данных, переменные, группы процедур и
функций, собранных вместе по определенному признаку (назначению).
В Turbo Pascal есть библиотеки (библиотечные модули): математических функций, функций и процедур управления
экраном, ввода с клавиатуры, графических средств и др. ТП включает 10 предопределенных модулей для реального режима
DOS. Наиболее часто используемые модули (System, Overlay, Dos, Crt и Printer) содержатся в файле TURBO.TPL, остальные
модули (Graph, Strings, WinDos, Turbo3 и Graph3) содержатся в файлах с расширением .TPU.
В АВС Паскаль:

Модуль растровой графики GraphABC по возможности практически совпадают с графическими


возможностями Borland Delphi.
Модуль Events позволяет создавать простейшие событийные программы без использования
объектов (события представляют собой обычные процедурные переменные).
Модули Timers и Sounds позволяют создавать таймеры и звуки, которые также реализованы в
процедурном стиле. Эти модули можно использовать даже в консольных программах.
Модуль контейнерных классов Containers позволяет работать с основными структурами данных
(динамические массивы, стеки, очереди, множества), реализованными в виде классов.
Модуль векторной графики ABCObjects предназначен для быстрого изучения основ объектно-
ориентированного программирования.
Модуль визуальных компонентов VCL позволяет создавать событийные приложения с главной
формой в стиле Delphi. Классы VCL немного упрощены по сравнению с аналогичными классами
Delphi. Имеется редактор форм и инспектор объектов.
Модуль Crt (Cathod ray tube) содержит подпрограммы управления экраном, клавиатурой,
генерации звука и др
―Подключить‖ библиотеки к программе можно, написав в самом начале программы оператор uses с перечислением имен
библиотек:
uses Библиотека1, Библиотека2, … БиблиотекаN;
Модуль System с большинством наиболее часто используемых функций и процедур (точнее, раздел System объектной
библиотеки) подключается к программе по умолчанию.
Для использования библиотечной процедуры /функции нужно знать ее имя, количество и тип аргументов, и имя
библиотеки, в которой она находится.
Функции и процедуры из библиотеки System
Математические: Abs(x), Sqr(x), Sqrt(x), Sin(x), Cos(x), Arctan(x), Exp(x), Ln(x), Int(x), Frac(x),
PI - стандартная функция (=3.14159265),power (a,b), стандартные константы:MaxInt = 32767 (Integer) и
MaxLongInt = 2 147 483 647 (LongInt).
Прочие функции и процедуры: Random (N), Randomize, Odd (N), Pred (Х), Succ (Х), Dec (X, Y), Inc (X, Y).
---------------------------------------------------------------------------------------------------------------------------------
Создание библиотек подпрограмм в виде модулей
Структура модуля
Unit <имя модуля>; {заголовок модуля}
interface
{интерфейсная часть: объявляются все ресурсы, которые будут доступны при подключении
модуля}
implementation
{раздел реализации: реализуются все подпрограммы, которые были ранее объявлены}
Begin
{раздел инициализации модуля: (часто отсутствует), содержит операторы, которые должны быть
выполнены после запуска программы, использующей модуль}
End.

18
Пример создания библиотек подпрограмм возведения в степень
tr – третья; ch – четвертая; pt – пятая; sh – шестая; sem – седьмая.

Unit step; {для проверки работы программы: ОТКЛЮЧИТЬ}


Interface {для проверки работы программы: ОТКЛЮЧИТЬ}

function tr(x: longint): longint; {для проверки работы программы: ОТКЛЮЧИТЬ}


function ch(x: longint): longint; {для проверки работы программы: ОТКЛЮЧИТЬ}
function pt(x: longint): longint; {для проверки работы программы: ОТКЛЮЧИТЬ}
function sh(x: longint): longint; {для проверки работы программы: ОТКЛЮЧИТЬ}
function sem(x: longint): longint; {для проверки работы программы: ОТКЛЮЧИТЬ}
var a: longint;
t: longint;
implementation {для проверки работы программы: ОТКЛЮЧИТЬ}
function tr(x: longint): longint;
var i:integer;
begin
t:=1;
for i:=1 to 3 do
t:=t*x; tr:=t; end;
function ch(x: longint): longint;
var i:integer;
begin
t:=1;
for i:=1 to 4 do
t:=t*x; ch:=t; end;
function pt(x: longint): longint;
var i:integer;
begin
t:=1;
for i:=1 to 5 do
t:=t*x; pt:=t; end;
function sh(x: longint): longint;
var i:integer;
begin
t:=1;
for i:=1 to 6 do
t:=t*x; sh:=t; end;
function sem(x: longint): longint;
var i:integer;
begin
t:=1;
for i:=1 to 7 do
t:=t*x; sem:=t; end;
begin
{readln(a); {для проверки работы программы: ВКЛЮЧИТЬ}
writeln(tr(a));}
end.
Рекомендации по разработке модулей:
1. Спроектировать модуль, т.е. выделить основные и вспомогательные подпрограммы или другие ресурсы.
2. Каждую подпрограмму целесообразно отладить отдельно, после чего «вклеить» в текст модуля.
3. Сохранить текст разработанной программы в файле (желательно имя файла должно совпадать с именем
программы-модуля: step.pas). Для надежности можно сделать копию данного файла.
4. Для Turbo Pascal: откомпилируем наш модуль. В среде программирования выбрать в пункте меню Compile
подпункты Make или Build (при этом должна быть включена компиляция на диск). Если в тексте нет
синтаксических ошибок, получится файл step.tpu.
 Для АВС Паскаль: сохранить с именем step.pas, step.tpu
5. Теперь можно включить модуль к программе, где планируется его использование.
uses step;
var a,s: longint;
begin
readln(a);
s:=ch(a);
writeln('Ответ= ',s);
end.

19
Файлы
Файл – это область памяти на внешнем носителе, в которой хранится некоторая информация. Файл в программе на языке Паскаль, - это именованная
структура данных, представляющая собой последовательность данных одного типа. Файлы классифицируются по методу доступа к их элементам:
1)файлы с последовательным доступом; 2)файлы с прямым доступом; 3)файлы с доступом по ключу.
Объявление файла
1) ИмяФайла = file of ТипЭлементов; {типизированные файлы}
2) ИмяФайла = Text; {текстовые файлы}
3) ИмяФайла = file; {нетипизированные файлы}.
Программе доступны два предварительно объявленных файла:1)предназначенный для чтения файл со стандартной файловой переменной INPUT, по
умолчанию связанной с клавиатурой; и 2)предназнач-ый для вывода на экран файл со стандарт. файловой переменной OUTPUT, по умолч. связанной с
экраном.
Стандартные процедуры и функции для работы с файлами любого типа
Обращение Действие
Связывает файловую переменную F с внешним (физическим) файлом; если второй параметр - ‗prn‘, то файл выводится на печать,
Assign (F, ИмяФайла)
если - ‗ ‘, то файл выводится на экран
Reset (F) Открывает существующий файл для чтения
Rewrite (F) Создает и открывает новый файл; при этом уничтожается существующий файл с таким же именем
Close (F) Закрывает открытый ранее файл
Read(F,R) Чтение элемента файла F в переменную R
Write(F,R) Запись элемента файла А из переменной R
EOF (F) Проверяет, достигнут ли конец файла (TRUE) или нет (FALSE)
IOResult Возвращает результат последней операции ввода-вывода (0 - успех, < > 0 – неудача)
Rename (Имя1,Имя2) Переименовывает существующий внешний (закрытый) файл, где Имя1- СтароеИмя, Имя2- Новое Имя
Erase (F) Удаляет внешний (закрытый) файл
ChDir (S) Устанавливает текущий каталог
MkDir (S) Создает подкаталог
RmDir (S) Удаляет пустой каталог
Имя переменной файлового типа принято называть логическим именем файла (F). Именно это имя используется в программе при обращении к его
элементам. Кроме того, у файла есть имя, под которым он фигурирует в операционной системе (ОС) - физическое имя (ИмяФайла). Установление
связи "логическое имя - физическое имя" выполняется специальной процедурой (Assign).
F – файловая переменная, S - переменная или константа строкового типа.
Для внешних файлов (файлов на диске) ИмяФайла – это имя типа файла; оно может быть переменной или константой строкового типа длиной менее
80 символов; ИмяФайла должно быть полным именем файла (т.е. написано по правилам MS-DOS).
Текстовые файлы
Файлы символьных данных называются текстовыми файлами. Текстовые файлы имеют тип text. Элементы текстовых файлов имеют тип Char. Включение
управляющих символов CR ("перевод каретки") и LF ("перевод строки") создаѐт в файле строковую структуру. Структура текстовых файлов отличается от
структуры обычных файлов тем, что содержимое текстового файла рассматривается как последовательность строк переменной длины, разделѐнных
специальной комбинацией, называемой "конец строки". Как правило, эта комбинация строится из управляющего кода "перевода каретки" (CR, Carriage
Return, символ #13), за которым, возможно, следует управляющий код "перевод строки" (LF, Line Feed, символ #10). Признаком конца строки считается
нажатие клавиши ввода. Текстовый файл завершается специальным кодом "конец файла" (символ #26).
Таким образом, текстовый файл структурно несколько похож на "файл из байтов" (file of byte) с той разницей, что в нем, помимо содержательной
информации, встречаются символы специального назначения.
Его можно схематически представить в следующем виде:
. . . . . . . . . . . . . .#13#10
. . . . . . . . . . . . . . . . . . . .#13#10
#26
Обращение Действие
Append (F) Открывает файл для добавления в конец существующего файла (только для текстового файла)
Read (F, СписокПеременных) Считывает из файла одно или более значений в одну или более переменных
ReadLn (F, СписокПеременных) To же с переходом к следующей строке файла
Write (F, СписокВывода) Записывает одно/несколько значений в файл, заранее открытый для вывода
WriteLn (F, СписокВывода) То же с выводом признака конца строки
Eoln (F) Возвращает признак конца строки

ПРИМЕР2: Проиллюстрировать работу процедуры append. (Самостоятельно


ПРИМЕР1: Написать программу, выполняющую чтение программой создается текстовый файл и в него записывается, а потом
из текстового файла целых чисел и вывод только четных дописывается информация. Дописанная информация видна, если файл закрыт, а
чисел. (Должен быть создан файл t1.txt с введенными данным – потом при открытии видно добавление в файл)
числами. Данные вводятся через Enter)
Program TextFile6;
Program TextFile2;
Var Var
f : text; f: text;
Put : string; Begin
a : integer; assign(f, 'text.txt'); {создаем текстовый файл}
Begin rewrite(f); {Открыть файл c файловой пер. t на создание и запись }
assign(f, ‗t1.txt‘); {Связываем файл с переменной f} writeln(f, 'Исходный текст'); {Записывать в него cтроку}
reset(f); {Открываем файл на чтение.} close(f); {Закрываем сформированный файл}
while not Eof(f) do{Пока нет конца файла делай...}
append(f); {Вновь открываем этот же файл для добавления}
begin
readln(f, a);{Считываем число в переменную а} writeln(f, 'Добавляемый текст'); {Пишем в конец файла cтроку}
if not odd(a) {Если число не нечетное} close(f); {Закрываем файл}
then End.
writeln(a);{То выводим его на экран}
end;
close(f);
readln
End.

20
Типизированные файлы
Типированные файлы (называемые бинарными) – файл, содержащий однотипные данные. Это файл имеющий возможность прямого доступа к записям.
При открытии типизированного файла текущая позиция установлена на начало первой записи, которая имеет номер 0 (номер физической записи на единицу
меньше номера логической записи).
Процедуры по работе с типизированными файлами:
Обращение Действие
Seek (ИмяФайла, N) Устанавливает текущую позицию файла на компонент с номером N в файле (режим прямого доступа)
Truncate (F) Усекает размер файла до текущей позиции в файле
SeekEoln (F) Возвращает признак конца строки, в отличие от Eoln предварительно пропускает все пробелы и символы табуляции
SeekEof (F) Возвращает признак конца файла, предварительно пропускает все пробелы и символы табуляции и признаки конца строки
FilePos (F) Возвращает текущую позицию в файле
FileSize (F) Возвращает текущий размер файла
Описание файлового типа имеет синтаксис: file of < тип элементов>;

Задача. Создать типизированный файл,


содержащий информацию о работниках.
Program TipRecord; //процедура записи в файл
Uses Crt; Procedure FileVvod;
Type Var
Dann=record i, n : Integer;
stag : byte; Begin
Surname, WorkName : string; write('Введите имя файла данных:');
Oklad, Year : integer; readln(Name);
End; assign(Spisok ,Name); rewrite(Spisok );
Var write('Введите количество работников:');
Spisok : file of Dann; readln(n);
Man : Dann; for i:=1 to count do
Name : string[12]; with Man do
begin
writeln('Введите данные ',Nomer,'-го работника');
write('Фамилия: '); readln(Surname);
//основной код программы write('Год рождения:'); readln(Year);
Begin write('Стаж работы:'); readln(stag);
ClrScr; writeln('Должность:'); readln(WorkName);
FileVvod; write('Оклад'); readln(oklad);
reset (Spisok); write(Spisok ,Man); {записать в файл}
While Not(Eof(Spisok)) Do end;
Begin close(Spisok ); {закрываем файл}
Read(spisok,Man); End;
Writeln(Man.Surname,' - ',Man.stag)
End;
Close(Spisok);
End.

Нетипизированные файлы
Нетипизированные файлы – файл без типа, представляется как последовательность элементов произвольного типа. Это файл имеющий возможность
прямого доступа к записям
Обращение Действие
BlockRead (F, Буфер, N [, Result] ) Считывает в переменную Буфер N-записей из файла; Result – кол-во считанных записей
BlockWrite (F, Буфер, N [, Result] ) Передает N-записей из переменной Буфер в файл; Result – число переданных записей
Задача. Составить программу, которая создает нетипизированный файл из 100 чисел и выводит на экран k-ый элемент.
Program Netipiz1;
Uses Crt; reset(F,1);
Type FileType = file; for k := 1 to 100 do
Var begin
f : FileType; P, B, k : byte; blockread(F, P, 1); write(p,' ');
Begin end;
ClrScr; write('Введите номер нужного элемента ');
assign(F, 'MyFile'); rewrite(F,1); Randomize; readln(k);
for k := 1 to 100 do Seek(F, k-1); blockread(F, P, 1);
begin writeln(k,'-ий элемент файла равен ', P);
P := Random(100); close(F);
blockwrite(F, P, 1); end; End.
close(F);
Порядок работы с файлами любого типа:
- Активное окно 1. Вводим данные. Сохраняем.
- Активное окно 2. Выполняем программу.
- Окно 3 – открываем файл Out.txt.

2 Var a,b,c,d: integer; g,w: text;


Begin 1 In.txt
writeln;
Assign(g,‘in.txt‘); reset(g);
Assign(w,‘out.txt‘); rewrite(w);
Read(g,a,b,c);
d:=a+b+c; 3 Out.txt
write(w,d);
close(g);
close(w);
End. 21
Комбинированный тип данных (Записи)
Запись – это структурированный тип, содержащий набор объектов разных типов.
Составляющие запись объекты называются еѐ полями. В записи каждое поле имеет свое собст. имя.
Номер Фамилия Имя ОАиП ППО Матем Ср балл
1 Иванов Сергей 7 8 6
2 Сидоров Илья 6 9 4 Записи
3 Петрова Мария 9 10 9

Поля
способ 1: способ 2:
Чтобы описать запись, Туре Var
необходимо указать: <имя записи> =record <имя записи> =record
- имя записи <имя поля 1>:<тип поля 1>; <имя поля 1>:<тип поля 1>;
- имя поля, составляющего запись … …
- тип пол <имя поля N> : <тип поля N> <имя поля N> : <тип поля N>
Типы полей в записи: строки, end; end;
скалярные переменные, массивы, Var <имя>:<имя типа>;
множества.
Туре
pupil = record
Поля (семь) Fam: string[15]; {фамилия }
Im: string[10]; {имя}
b1, b2, b3: integer; {баллы по дисциплинам}
sb: real; {средний балл}
N: integer {номер записи}
end;
Записи (три) Var
klass: array[1..3] of pupil;
Доступ к полям и записям
1 способ: указать имя записи и имя поля 2 способ: используя оператор присоединения with
for i:=1 to 3 do for i:=1 to 3 do
begin begin
readln (klass[i].fam); with klass[i] do
readln (klass[i].im); begin
readln (klass[i].b1); readln (fam);
readln (klass[i].b2); readln (im);
readln (klass[i].b3); readln (b1,b2,b3);
end end;
end

Пример Begin
writeln(‘Заполнение’);
Writeln(‗кол-во записей‘);
program zapis;
Readln(n);
Const m=255; for i:=1 to n do
with klass [i] do
Type begin
pupil=record readln(fam);
readln(im);
fam:string[15];
readln(b1,b2,b3);
im:string[5]; end;
b1,b2,b3:integer;
end; writeln(‘ПОИСК’);
for i:=1 to n do
with klass [i] do
var
sb:=(b1+b2+b3)/3;
klass:array[1..m] of pupil; writeln(‗Фамилия, средний балл больше 7‘);
n, i:integer; for i:=1 to n do
k:string; if klass [i].sb>7 then writeln (klass [i].fam:15, klass [i].sb:5);

end.

22
//тектовый файл //типизированный файл
Const m=255; Const m=255;
Type Type
pupil=record pupil=record
fam:string[15]; fam:string[15];
im:string[5]; im:string[5];
b1,b2,b3:integer; b1,b2,b3:integer;
end; end;
var klass:array[1..m] of pupil; var klass:array[1..m] of pupil;
n, i:integer; n, i:integer;
K,y:string; K,y:string;
f: text; f: file of pupil;
Begin Begin
writeln(‘Сохранение в файл’);
writeln(‘Сохранение в файл’); readln(y);
readln(y); assign(f,y); rewrite(f);
assign(f,y); rewrite(f); Writeln(‗Количество‘);
Writeln(‗Количество‘); Readln(n);
Readln(n); For i:=1 to n do
For i:=1 to n do begin
begin readln(klass[i].fam); readln(klass[i].im);
readln(klass[i].fam); writeln(f,klass[i].fam); readln(klass[i].b1); readln(klass[i].b2);
readln(klass[i].im); writeln(f,klass[i].im); readln(klass[i].b3);
readln(klass[i].b1); writeln(f,klass[i].b1); write(f,klass[i]);
readln(klass[i].b2); writeln(f,klass[i].b2); end;
readln(klass[i].b3); writeln(f,klass[i].b3); close(f);
end; writeln(‘Чтение из файла’);
close(f); writeln (‗Введите все имя файла‘); readln(y);
assign(f,y);
writeln(‘Чтение из файла’); Reset(f);
writhen(‗Введите все имя файла‘); readln(y); n:=1;
assign(f,y); Reset(f); while not eof(f) do
n:=1; with klass [n] do
while not eof(f) do begin
with klass [n] do read(f, klass[n]);
begin n:=n+1;
readln(f,fam); end;
readln(f,im); close(f);
readln(f,b1,b2,b3); writeln(‘Вывод’);
n:=n+1; Reset(f);
end; for i:=1 to n-1 do
begin
writeln(‘Вывод’); read(f, klass[i]);
for i:=1 to n-1 do with klass [i] do
with klass [i] do writeln(fam:15,im:5,b1:3,b2:3,b3:3); end;
writeln(fam:15,im:5,b1:3,b2:3,b3:3); close(f);
writeln(‘ПОИСК’);
writeln(‘ПОИСК’); Reset(f);
Readln(k); Readln(k);
for i:=1 to n-1 do for i:=1 to n-1 do begin
with klass [i] do read(f, klass[i]);
if k=im then writeln (fam:15,b1:3,b2:3,b3:3); with klass [i] do
close(f); if k=im then writeln (fam:15,b1:3,b2:3,b3:3);
end;
End. close(f);
End.

23
Организация памяти (для Паскаль АВС)
Статическая память: Статическая память выделяется переменным на всѐ время выполнения программы. Адреса
переменных в этом случае могут быть определены ещѐ на этапе компиляции программы.
Динамическая память - это оперативная память ПК, предоставляемая программе при ее работе, за вычетом
сегмента данных (64 Кбайт), стека (обычно 16 Кбайт) и собственно тела программы.
Размер по умолчанию - этот размер определяется всей доступной памятью ПК и, как правило, составляет не
менее 200...300 Кбайт.
Динамическая переменная - переменная, которая создается и уничтожается по ходу выполнения программы.
Такие переменные не описываются заранее в разделе объявлений и не имеют своего собственного имени, а
память под них захватывается (выделяется) в соответствиями с инструкциями программы.
У динамической переменной нет имени, - к ней можно обратиться только при помощи специальной переменной,
- переменной-указателя.
Указатель – переменная целого типа, которая в качестве своего значения содержит адрес первого байта памяти,
начиная с которой размещается значение переменной. Назначение указателя – получение значения переменной
по адресу. Чтобы обратиться к содержимому ячейки, требуется после его идентификатора поставить символ ^
(каре). Эта операция называется разыменованием (p^). На каждый указатель резервируется 4 байта.
Типизированный указатель – это указатель на переменную определенного типа (integer, real, тип массив и др).
Нетипизированный указатель – это адрес первого байта области памяти, в которой может размещаться любая
информация вне зависимости от ее типа (используется зарезервированное слово pointer).
Примеры:
Var p1:^integer; типизированный указатель
p2:^string; типизированный указатель
p3:^pointer; нетипизированный указатель
ssMas: ^Mas; Указатель на массив данных
ssint: ^Integer; Указатель на переменную типа Integer
Type Tmas = Array[1..10] of integer;
var sm: ^Tmas; {указатель на массив из 10 целых чисел}
Стандартные процедуры и функции для работы с динамическими переменными
New(P); Р - указатель. Эта процедура создает новую динамическую переменную Р^, отводит место для еѐ
хранения в ОП и присваивает еѐ адрес ссылочной переменной Р. При этом динамической переменной отводится
блок памяти, соответствующий размеру типа, с которым объявлен указатель Р.
Dispose(P); Эта процедура уничтожает связь между ссылочной переменной Р и значением, на которое она
ссылается, тем самым, освобождая память, занятую динамической переменной.
GetMem(P,Size); -используется как и New(P) для размещения динамических переменных. Эта процедура
создаѐт новую динамическую переменную, отводит для неѐ в динамической области участок, размером в Size (не
должно превышать 65521 байт и иметь тип Word) байт и присваивает адрес начала участка указателю Р.
FreeMem(P,Size) или FreeMem(P);-процедура, которая уничтожает динамическую переменную, освобождая в
ОП участок размером Size байт (в ВР);
Функция Addr(X) -определяет адрес (указатель) объекта Х. Х - любая переменная, процедура или функция.
Переменной-указателю можно присвоить значение с помощью процедуры new, операции @ или функции Ptr.
Процедура new отводит блок памяти в области для динамических переменных и сохраняет адрес этого блока в
указателе. Операция @ ориентирует переменную-указатель на область памяти, содержащую уже существующую
переменную. Функция Ptr ориетирует переменную-указатель на определенный адрес в памяти. Тип результата –
указатель того же типа, что и Nil, т.е. он может быть назначен любой переменной-указателю.
ПРИМЕР 1: Разработать алгоритм и программу решения задачи, в которой необходимо подсчитать количество нулевых
элементов в динамическом одномерном массиве B.
Type
Type mas=array[1..20] of real;
mas=array[1..20] of real; Var
Var b:^mas;
b:^mas; n,i,k:integer; n,i,k:integer;
Begin Begin
new(b); write(‗Введите размерность массива N‘);
write(‗Введите размерность массива N‘); readln(n);
readln(n); Getmem(b,n*sizeof(real));
for i:=1 to n do for i:=1 to n do
begin begin
write(‗Введите элемент массива b[‘,i,‘]‘); write(‗Введите элемент массива b[‘,i,‘]‘);
readln(b^[i]); readln(b^[i]);
end; end;
k:=0; k:=0;
for i:=1 to n do if b^[i]=0 then k:=k+1; for i:=1 to n do if b^[i]=0 then k:=k+1;
dispose(b); writeln(‘ k=‘,k);
writeln(‘ k=‘,k); Freemem(b);
End. End.

24
Динамические структуры данных
Это структура, состоящая из отдельных связанных в определенном порядке элементов, которая описывается и
обрабатывается программно. Примерами динамических структур данных являются: стек, очередь, линейный список,
дерево, куча, двоичное дерево и др. Списком называется структура данных, каждый элемент которой содержит ссылку
(указатель), связывающую его со следующим элементом этого списка.
Очередь - это упорядоченный набор связанных элементов, которые добавляются к нему с одного конца, а удаляются
(выбираются) с другого конца. Принцип обработки записей в очереди называется принципом FIFO (First Input - First
Output) - “Первым пришѐл -первым ушѐл”. Пример: организация событий в Windows (пользователь оказывает какое-то
действие на приложение; приложению посылается сообщение о запросе на выполнение соответствующей процедуры; в
приложении не вызывается соответствующая процедура, т.к. в этот момент приложение совершает другие действия;
сообщение ставится в очередь; когда будут обработаны сообщения, пришедшие ранее, приложение выполнит необходимое
действие).
Стек - упорядоченный набор связанных элементов, которые добавляются к нему и удаляются из него только с одного
конца (вершины стека). Принцип обработки записей стека называется принципом LIFO (Last Input - First Output) -
“Последним пришѐл -первым ушѐл”. Стек широко используется в программировании на низком уровне и является
неотъемлемой частью архитектуры современных процессоров. Компиляторы языков программирования высокого уровня
используют стек для передачи параметров при вызове подпрограмм, процессоры — для хранения адреса возврата из
подпрограмм. Принцип работы стека сравнивают со стопкой тарелок: чтобы взять вторую сверху, нужно взять верхнюю.
Линейный список - наиболее универсальная структура данных спискового типа, в нем доступна для чтения и удаления
любая запись, кроме того, новая запись может быть включена в любое место такого списка.

Программирование численных методов


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

, где
– квадратурная формула,

xi – некоторые точки отрезка [a,b],


n – число отрезков на [a,b],
f(xi) – значения подынтегральной функции в точках xi,
qi – весовые коэффициенты,
Rn – остаточный член.
Методы
метод правых прямоугольников
метод левых прямоугольников
метод формулы прямоугольников
метод формулы трапеций
метод формулы Симпсона
метод формулы трѐх восьмых

25
Объектно-ориентированное программирование
Абстрактный тип данных — это совокупность данных вместе с множеством операций, которые можно
выполнять над этими данными .
Понятие объектно-ориентированного программирования
ООП – это метод программирования, которая основана на представлении программы в виде совокупности
объектов, каждый из которых является реализацией определенного класса, а классы образуют иерархию на
принципах наследуемости».
Объекты и классы. Базовыми блоками объектно-ориентированной программы являются объекты и классы.
Класс (объект)— описание (абстракция), которое показывает, как построить существующую во времени и
пространстве переменную
Базовые принципы ООП
К базовым принципам объектно-ориентированного стиля программирования относятся: пакетирование или
ИНКАПСУЛЯЦИЯ ; НАСЛЕДОВАНИЕ ; ПОЛИМОРФИЗМ ; передача сообщений.
Инкапсуляция - предполагает объединение в одном объекте полей и методов, которые манипулируют этими
полями.
Объект характеризуется как совокупностью всех своих свойств (например, для животных – это наличие головы,
ушей, глаз и т.д.) и их текущих значений (голова – большая, уши – длинные, глаза – желтые и т.д.), так и
совокупностью допустимых для этого объекта действий (умение принимать пищу, сидеть, стоять, бежать и т.д.).
Указанное объединение в едином объекте как «материальных» составных частей (голова, уши, хвост, лапы), так и
действий, манипулирующих этими частями (действие «бежать» быстро перемещает лапы) называется
инкапсуляцией.

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

Описание объектного типа


Класс или объект – это структура данных, которая содержит поля и методы. Как всякая структура данных она
начинается зарезервированным словом и закрывается оператором end . Формальный синтаксис не сложен:
описание объектного типа получается, если в описании записи заменить слово record на слово object или class и
добавить объявление функций и процедур над полями.

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

Иерархия типов (наследование)


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

26
Если введен объектный тип (предок, родительский), а его надо дополнить полями или методами, то вводится
новый тип, объявляется наследником (потомком, дочерним типом) первого и описываются только новые поля и
методы. Потомок содержит все поля типа предка. Заметим, что поля и методы предка доступны потомку без
специальных указаний. Если в описании потомка повторяются имена полей или методов предка, то новые
описания переопределяют поля и методы предка.
Если потомок tSon из метода Му Name вызывает одноименный метод непосредственного предка типа tPredoc .
Такой вызов обеспечивается директивой inherited , после которой указан вызываемый метод непосредственного
предка. Если возникает необходимость вызвать метод отдаленного предка в каком-нибудь дочернем типе на
любом уровне иерархии, то это можно сделать с помощью уточненного идентификатора, т.е. указать явно имя
типа родительского объекта и через точку – имя его метода:
Статические методы
включаются в код программы при компиляции. Это означает, что до использования программы определено,
какая процедура будет вызвана в данной точке. Компилятор определяет, какого типа объект используется при
данном вызове, и подставляет метод этого объекта.
Объекты разных типов могут иметь одноименные статические методы. В этом случае нужный метод
определяется по типу экземпляра объекта.
Виртуальные методы
в отличие от статических, подключаются к основному коду на этапе выполнения программы. Виртуальные
методы дают возможность определить тип и конкретизировать экземпляр объекта в процессе исполнения, а затем
вызвать методы этого объекта.
Этот принципиально новый механизм, называемый поздним связыванием, обеспечивает полиморфизм, т.е.
разный способ поведения для разных, но однородных (в смысле наследования) объектов.
Описание виртуального метода отличается от описания обычного метода добавлением после заголовка метода
служебного слова virtual .
procedure Method ( список параметров ); virtual;
Использование виртуальных методов в иерархии типов объектов имеет определенные ограничения: если метод
объявлен как виртуальный, то в типе потомка его нельзя перекрыть статическим методом; объекты, имеющие
виртуальные методы, инициализируются специальными процедурами, которые, в сущности, также являются
виртуальными и носят название constructor ; списки переменных, типы функций в заголовках перекрывающих
друг друга виртуальных процедур и функций должны совпадать полностью;
Обычно на конструктор возлагается работа по инициализации экземпляра объекта: присвоение полям исходных
значений, первоначальный вывод на экран
Конструктор – это специальный метод, который инициализирует объект, содержащий виртуальные методы.
Заголовок конструктора выглядит так:
constructor Method (список параметров);
Зарезервированное слово constructor заменяет слова procedure и virtual .
Основное и особенное назначение конструктора – установление связей с таблицей виртуальных методов ( VMT )
– структурой, содержащей ссылки на виртуальные методы. Таким образом, конструктор инициализирует объект
установкой связи между объектом и VMT с адресами кодов виртуальных методов. При инициализации и
происходит позднее связывание.
Упомянув о конструкторе, следует сказать и о деструкторе. Его роль противоположна: выполнить действия,
завершающие работу с объектом, закрыть все файлы, очистить динамическую память, очистить экран и т.д.
Методы Методы объектов обладают единственным отличием от обычных процедур/функций: они, собственно,
принадлежат объектам. Следовательно, они обладают доступом к полям именно "своему" объекту. Так как
объектов в программе может быть множество, то, во избежание дублирования кода, каждый метод получает в
качестве неявного параметра указатель на объект, для которого он вызван.
Procedure Class1.Nothing(Var K: Byte);
Конструкторы и деструкторы
Среди всех методов класса выделяют две особых группы, имеющих особое значение при создании и удалении
объектов этого класса: конструкторы; деструкторы.
Конструкторы предназначены для инициализации полей объектов в момент их создания. Объявляются они
следующим образом:
Type
Class4 = Object Constructor Class3.Init(CB: Byte); Destructor Class3.Done;
B: Byte; Begin Begin
Constructor Init(CB: Byte); B:= VB; End;
Destructor Done; Virtual; End;
End;

27
28

Вам также может понравиться