Операторы языка Pascal
1. Составной и пустой операторы
Составной оператор - это последовательность произвольных операторов программы, заключенная в операторные скобки.
Турбо-Паскаль допускает произвольную глубину вложенности: Begin ... Begin ... Begin ... End; End; End; Наличие ; перед End - пустой оператор.
2. Операторы ветвлений
Условный оператор
IF <условие> THEN <оператор1> [ELSE <оператор2>]
Условие – значение типа BOOLEAN или логическая операция. Если условие верно, выполняется оператор, или блок операторов, следующий за THEN, в противном случае выполняется блок операторов после ELSE, если он есть.
Условия могут быть вложенными и в таком случае, любая встретившаяся часть ELSE соответствует ближайшей к ней "сверху" части THEN.
Пример: Var A, B, C, D: Integer; begin A:=1; B:=2; C:=3; D:=4; If A > B Then If C < D Then If C < 0 Then C:=0 {обратите внимание, что перед Else} {пустой оператор ";"не ставится} Else A:=B; end. а могло быть и так: If A > B Then If C < D Then If C < 0 Then C:=0 Else Else Else A:=B
Рассмотрим программу, которая вводит произвольное целое число от 0 до 15 и выводит его в шестнадцатеричной системе:
Program Hex; Var Ch: Char; N: Integer; Begin Write ('N = '); Readln(N); If (N >= 0) And (N <= 15) Then Begin If N < 10 Then Ch:= Chr(Ord('0')+N) Else Ch:=Chr(Ord('A')+N-10); End Else Writeln('Ошибка'); End.
3. Операторы повторений
Цикл с предопределенным числом повторений.
For <переменная цикла>:=<начальное значение> To(DownTo) <конечное значение> Do <блок операторов>
Переменная должна быть целого или перечислимого типа. При исполнении цикла переменная цикла изменяется от начального до конечного значения с шагом 1. Если стоит to, то переменная увеличивается, если downto – уменьшается.
Условия выполнения цикла проверяются перед выполнением блока операторов. Если условие не выполнено, цикл For не выполняется. Следующая программа подсчитывает сумму чисел от 1 до введенного:
Program Summa; Var I, N, S: Integer; Begin Write('N = '); Readln(N); S:=0; For I:=1 To N Do S:=S + I; Writeln ('Cумма = ', S) End.
Условный цикл с проверкой условия перед исполнением блока операторов.
While <условие> Do <блок операторов>
Блок операторов будет исполняться, пока условие имеет значение true. Необходимо, чтобы значение условия имело возможность изменения при исполнении блока операторов, иначе исполнение цикла не закончится никогда (в DOS это приведет к зависанию компыютера). Если условие зарание ложно, блок операторов не исполнится ни разу.
Найдем машинное "эпсилон" для переменной типа Real: Program Epsilondetect; Var Epsilon: Real; Begin Epsilon:=1; While Epsilon + 1 > 1 Do Epsilon: = Epsilon/2; Writeln ('Эпсилон = ', Epsilon); End.
Условный цикл с проверкой после выполнения блока операторов.
Repeat <тело цикла> Until <условие>
Блок операторов независимо от значения условия будет выполнен хотябы один раз. Цикл заканчивается, если после очередного исполнения блока операторов условие имеет значение true.
Пример: программа запрашивает ввод одного символа и выводит его ASCII - код, пока не будет введен пустой символ:
Program Code; Const Cr = 13; Var Ch:Char; Begin Repeat Readln (Ch); Writeln (Ch,' = ', Ord (Ch)); Until Ord (Ch) = Cr End.
Оператор выбора одного из вариантов.
Case <ключ выбора> Of <список выбора> Else <оператор> End;
<ключ выбора> - выражение любого перечислимого типа, <список выбора> - одна или более конструкций вида <значение ключа>:<блок операторов>.
Составим программу, имитирующую калькулятор. Программа вводит две строки: первая содержит два числа, разделенные пробелом или запятой, вторая - символ арифметического действия. 2 2 * Признаком конца работы служит ввод любого символа, отличного от +, -, /, *.
Программа: Program Calc; Var Operation: Char; {Знак Операции} X, Y, Z: Real; Stop: Boolean; Begin Stop:= False; repeat Writeln; {Пустая Строка - Разделитель} Write ('X, Y = '); Readln (X,Y); Write ('Операция: '); Readln (Operation); Case Operation Of '+': Z: = X+Y; '-': Z: = X-Y; '*': Z: = X*Y; '/': Z: = X/Y; Else Stop:= True; End; If Not Stop Then Writeln('Z = ',Z); Until Stop; End.
Любому из блоков операторов списка может предшествовать не одно, а несколько значений выбора, разделенных запятыми.
Оператор безуслов ного перехода на строку с меткой.
Goto <метка>
Метка, должна быть описана в разделе описаний. Метка, описанная в процедуре (функции) локализуется в ней, поэтому передача управления извне процедуры (функции) на метку внутри нее невозможна.
Понятие двумерного массива. Описание типа массива. Формирование значений элементов массива случайным образом
Одним из основных направлений использования компьютеров является накопление и обработка данных - различных таблиц, справочников, словарей и другой информации. Для представления такой информации в программе удобно использовать массивы. Как правило, обработка таких данных осуществляется по одному и тому же закону, для чего удобно использовать циклические алгоритмы.
Мы уже рассматривали формирование и обработку одномерных массивов. Вспомним, что в массив мы объединяем конечную последовательность компонентов одного типа и даем им общее имя. Каждый отдельный компонент массива называется элементом. Количество элементов называется размером массива. Тип элементов определяет тип массива. Размер и тип массива указываются при его описании, причем размер может быть указан либо конкретным значением, либо ранее определенной константой. Номер элемента называется индексом. Индексы могут быть целыми положительными константами или целыми переменными. Чтобы обратиться к некоторому элементу массива, нужно рядом с идентификатором массива в скобках указать индекс элемента.
Но часто данные могут быть организованы в виде таблицы (матрицы), где расположение каждой переменной определяется номером строки и номером столбца. Например, место в зрительном зале задается указанием номера ряда и номером места в этом ряду. Такие данные удобно описать как двумерный массив. В отличие от одномерного массива каждому элементу двумерного массива соответствует пара индексов. Первый индекс - это номер строки, а второй - номер столбца, где расположен элемент массива.
Размер двумерного массива задается парой чисел: M*N, где M - число строк, а N - число столбцов в таблице.
Пусть задан двумерный массив Matr, имеющий размер 10*20. Этот массив на языке Паскаль может быть описан следующим образом:
Var Matr : array [1..10,1..20] of integer; |
тогда
Matr[5,7] - элемент, расположенный в 5-ой строке и в 7-ом столбце.
Любая константа, переменная, значение функции или выражения в Турбо Паскале характеризуется своим типом. Тип любого из этих объектов определяет множество допустимых значений, которые может иметь объект, а также множество допустимых операций, которые применимы к объекту. Кроме того, тип определяет и формат внутреннего представления значения объекта.
Имя, которое программист присваивает своему определяемому типу, - произвольный идентификатор. Объявление типа должно быть сделано в разделе объявлений, и ему должно предшествовать кодовое слово Type.
Отличительной особенностью массивов является то обстоятельство, что все их компоненты суть данные одного типа (возможно, структурированного); эти компоненты можно легко упорядочить и обеспечить доступ к любому из них простым указанием его порядкового номера, например:
Type Digit = array [0..9] of integer; Matrix = array [1..100, 0..9] of real; Var m : Matrix; d : Digit; i : integer; |
Описание типа массива задается следующим образом:
<имя типа> = array [<сп. инд. типов>] of <тип>;
где:
<имя типа> - правильный идентификатор, <сп. инд. типов> - список из одного или нескольких индексных типов, разделенных запятыми, <тип> - любой тип Турбо Паскаля.
Примечание. Обычно в качестве индексного типа используется тип-диапазон, в котором задаются границы изменения индексов через две точки (..). Так как <тип>, идущий за кодовым словом of, - любой тип Турбо Паскаля, он может быть, в частности, другим массивом.
Рассмотрим примеры.
Пример 1. Массив можно описать как одномерный, элементами которого в свою очередь являются одномерные массивы.
Const n=2; m=3; Type MyArray1 = array [1..m] of integer; MyArray2 = array [1..n] of MyArray1; Var V : MyArray1; A : MyArray2; |
В данном случае переменная V объявлена как одномерный массив из трех элементов целого типа, а переменная А описана как двумерный массив из двух строк, в каждую из которых включено по три элемента.
Пример 2. Описание массива можно сократить, исключив определение массива MyArray1.
Const n=2; m=3; Type MyArray2 = array [1..n] of array [1..m] of integer; Var A : MyArray2; |
Пример 3. Еще более краткое описание массива А можно получить, указывая имя массива и диапазоны изменения индексов для каждой размерности массива (чем мы уже пользовались).
Const n=2; m=3; Type MyArray2 = array [1..n, 1..m] of integer; Var A : MyArray2; |
Пример 4. Если же указанный тип используется для определения одного массива в программе, то удобно объявление массива в разделе описания переменных.
Const n=2; m=3; Var A : array [1..n, 1..m] of integer; |
Формирование значений элементов массива случайным образом и с клавиатуры и вывод их на экран
Операции работы с двумерными массивами аналогичны операциям работы с одномерными массивами, нужно только не забывать о различиях между массивами. Обычно при работе с двумерными массивами используются вложенные циклы.
Очень часто значения элементов массива вводятся с клавиатуры. Этот способ задания информации слишком трудоемок при работе с массивами больших размеров. Для отладки широкого класса алгоритмов такой ввод информации должен быть заменен формированием элементов массива случайным образом. Для этого используют встроенные средства Турбо Паскаля: процедуру Randomize и функцию Random. Вы уже сталкивались с этими средствами. Сегодня же наша задача создать процедуру ввода элементов в массив и процедуру вывода элементов на экран.
Приведем пример заполнения массива случайными числами. Эта процедура должна принять в качестве входных параметров массив, количество строк и столбцов, заданные пользователем с клавиатуры в основном разделе операторов. Так как наша процедура будет воздействовать на пустой исходный массив, то его мы должны передать по ссылке. Количество строк и столбцов достаточно передать копиями по значению.
Procedure InsertMas1(Var X : MyArray; n, m: integer); Var i, j : integer; Begin Randomize; for i := 1 to n do {пробегая последовательно строки массива} for j := 1 to m do {просмотрим каждую ее ячейку текущего столбца} X[i, j]:= Random(50); {и запишем туда случайное число, которое сформирует компьютер в диапазоне [0..49]} End; |
Теперь, чтобы воспользоваться этой процедурой, достаточно вызвать ее в основном разделе программы, передав ей параметры.
Рассмотрим процедуру вывода элементов массива на экран. Для того, чтобы вывести наш массив на экран в виде таблицы, поставим при переходе к новой строке оператор writeln и применим формат вывода элементов (:5).
Procedure PrintMas(X : MyArray; n, m: integer); Var i, j : integer; Begin for i := 1 to n do {пробегая последовательно строки и столбцы массива} begin for j := 1 to m do write(X[i, j]:5); {выведем элемент массива на экран, выделив ему 5 знакомест} writeln; {переход на новую строку} end; End; |
Задание. Наберите программу-шаблон для работы с двумерными массивами. Как вы уже знаете из предыдущей темы, она должна содержать две процедуры ввода и процедуру вывода элементов заданного массива. Основной раздел операторов должен содержать диалог с пользователем и защиту программы от ввода недопустимых значений для количества строк и столбцов. Сохраните файл в соответствующем каталоге на своей дискете.
Рассмотрите процедуру, решающую следующую задачу.
Задача. Дана таблица действительных чисел. Сосчитайте сумму всех чисел в таблице.
Procedure Summa(A : MyArray; n, m: integer; Var S: real); Var i, j : integer; Begin S:= 0; for i := 1 to n do for j := 1 to m do S := S+A[i,j]; End. |
Обратите внимание, что внутри цикла со счетчиком i организован цикл со счетчиком j. В результате суммируются в начале числа 1-й строки (i=1, при j=1, 2, ..., m), затем суммируются числа 2-й строки (i=2, при j=1, 2, ..., m) и т.д.
В данной программе в теле одного цикла содержится другой цикл. Такие циклы, как Вы уже знаете, называются вложенными. Причем цикл со счетчиком i является внешним, а цикл со счетчиком j - внутренним. Не забывайте основное правило при написании вложенных циклов: последний оператор внутреннего цикла должен либо предшествовать, либо совпадать с последним оператором внешнего цикла. Вложенные циклы напоминают матрешек, вложенных одна в другую.
Задание. Откройте файл программы-шаблона, сохраните его под другим (соответствующем задаче) именем и дополните текст программы функцией нахождения суммы элементов, правильно преобразовав в нее рассмотренную выше процедуру. Внесите в программу необходимые операторы и комментарии.
Задание. Ниже приведен фрагмент решения некоторой задачи. Внимательно рассмотрев решение, сформулируйте решаемую задачу и оформите по всем правилам, применив знания текущего занятия.
. . . for i := 1 to N do Begin M := a[i,1]; S := a[i, 1]; for j := 2 to N do begin if M>a[i, j] Then M := a[i, j]; S := S+a[i, j]; end; writeln (i:7, M:6, S:6:3); End; . . . |
Структу́рное программи́рование — методология разработки программного обеспечения, в основе которой лежит представление программы в виде иерархической структуры блоков. Предложена в 70-х годах XX века Э. Дейкстрой, разработана и дополнена Н. Виртом В соответствии с данной методологией
Любая программа представляет собой структуру, построенную из трёх типов базовых конструкций:
последовательное исполнение — однократное выполнение операций в том порядке, в котором они записаны в тексте программы;
ветвление — однократное выполнение одной из двух или более операций, в зависимости от выполнения некоторого заданного условия;
цикл — многократное исполнение одной и той же операции до тех пор, пока выполняется некоторое заданное условие (условие продолжения цикла).
В программе базовые конструкции могут быть вложены друг в друга произвольным образом, но никаких других средств управления последовательностью выполнения операций не предусматривается.
Повторяющиеся фрагменты программы (либо не повторяющиеся, но представляющие собой логически целостные вычислительные блоки) могут оформляться в виде т. н. подпрограмм (процедур или функций). В этом случае в тексте основной программы, вместо помещённого в подпрограмму фрагмента, вставляется инструкция вызова подпрограммы. При выполнении такой инструкции выполняется вызванная подпрограмма, после чего исполнение программы продолжается с инструкции, следующей за командой вызова подпрограммы.
Разработка программы ведётся пошагово, методом «сверху вниз».
Сначала пишется текст основной программы, в котором, вместо каждого связного логического фрагмента текста, вставляется вызов подпрограммы, которая будет выполнять этот фрагмент. Вместо настоящих, работающих подпрограмм, в программу вставляются «заглушки», которые ничего не делают. Полученная программа проверяется и отлаживается. После того, как программист убедится, что подпрограммы вызываются в правильной последовательности (то есть общая структура программы верна), подпрограммы-заглушки последовательно заменяются на реально работающие, причём разработка каждой подпрограммы ведётся тем же методом, что и основной программы. Разработка заканчивается тогда, когда не останется ни одной «затычки», которая не была бы удалена. Такая последовательность гарантирует, что на каждом этапе разработки программист одновременно имеет дело с обозримым и понятным ему множеством фрагментов, и может быть уверен, что общая структура всех более высоких уровней программы верна. При сопровождении и внесении изменений в программу выясняется, в какие именно процедуры нужно внести изменения, и они вносятся, не затрагивая части программы, непосредственно не связанные с ними. Это позволяет гарантировать, что при внесении изменений и исправлении ошибок не выйдет из строя какая-то часть программы, находящаяся в данный момент вне зоны внимания программиста. Теорема о структурном программировании:
Основная статья: Теорема Бома-Якопини
Любую схему алгоритма можно представить в виде композиции вложенных блоков begin и end, условных операторов if, then, else, циклов с предусловием (while) и может быть дополнительных логических переменных (флагов). Эта теорема была сформулирована итальянскими математиками К.Бомом и Дж.Якопини в 1966 году и говорит нам о том, как можно избежать использование оператора перехода goto.
[править] История
Методология структурного программирования появилась как следствие возрастания сложности решаемых на компьютерах задач, и соответственного усложнения программного обеспечения. В 70-е годы XX века объёмы и сложность программ достигли такого уровня, что «интуитивная» (неструктурированная, или «рефлекторная») разработка программ, которая была нормой в более раннее время, перестала удовлетворять потребностям практики. Программы становились слишком сложными, чтобы их можно было нормально сопровождать, поэтому потребовалась какая-то систематизация процесса разработки и структуры программ.
Наиболее сильной критике со стороны разработчиков структурного подхода к программированию подвергся оператор GOTO (оператор безусловного перехода), имевшийся тогда почти во всех языках программирования. Неправильное и необдуманное использование произвольных переходов в тексте программы приводит к получению запутанных, плохо структурированных программ (т.н. спагетти-кода), по тексту которых практически невозможно понять порядок исполнения и взаимозависимость фрагментов.
Следование принципам структурного программирования сделало тексты программ, даже довольно крупных, нормально читаемыми. Серьёзно облегчилось понимание программ, появилась возможность разработки программ в нормальном промышленном режиме, когда программу может без особых затруднений понять не только её автор, но и другие программисты. Это позволило разрабатывать достаточно крупные для того времени программные комплексы силами коллективов разработчиков, и сопровождать эти комплексы в течение многих лет, даже в условиях неизбежных изменений в составе персонала.
Методология структурной разработки программного обеспечения была признана «самой сильной формализацией 70-х годов». После этого слово «структурный» стало модным в отрасли, и его начали использовать везде, где надо и где не надо. Появились работы по «структурному проектированию», «структурному тестированию», «структурному дизайну» и так далее. В общем, произошло примерно то же самое, что происходило в 90-х годах и происходит в настоящее время с терминами «объектный», «объектно-ориентированный» и «электронный».
Перечислим некоторые достоинства структурного программирования:
Структурное программирование позволяет значительно сократить число вариантов построения программы по одной и той же спецификации, что значительно снижает сложность программы и, что ещё важнее, облегчает понимание её другими разработчиками.
В структурированных программах логически связанные операторы находятся визуально ближе, а слабо связанные — дальше, что позволяет обходиться без блок-схем и других графических форм изображения алгоритмов (по сути, сама программа является собственной блок-схемой).
Сильно упрощается процесс тестирования и отладки структурированных программ.
Метод нисходящего проектирования. Подпрограммы в языке Паскаль. Стандартные модули языка Паскаль. Модульное программирование.
В практике программирования часто встречаются такие случаи, когда по ходу выполнения программ приходится выполнять одни и те же вычисления или действия, но при различных исходных данных. Чтобы исключить повторение одинаковых записей и сделать тем самым программу проще и понятнее, можно выделить эти повторяющиеся вычисления в самостоятельную часть программы и использовать многократно по мере необходимости. Такая автономная часть программы, реализующая определенный алгоритм и допускающая обращение к ней из различных частей общей программы, называется подпрограммой.
Подпрограмма является частью другой программы и удовлетворяет требованиям, которые язык программирования предъявляет структуре программы. Разложение программы на взаимосвязанные, но замкнутые и логически завершенные компоненты, дает возможность выполнять разработку отдельных подпрограмм различными программистами более или менее независимо друг от друга. Кроме того, подпрограмма может быть рассмотрена как самостоятельный модуль со своими входными и выходными параметрами, что позволяет использовать ее в общем иерархическом подходе при конструировании алгоритма и программы по принципам нисходящего проектирования.
Метод нисходящего проектирования программ основан на идее уровней абстракции, которые становятся уровнями модулей в разрабатываемой программе. На этапе проектирования строится схема иерархии, которая изображает эти уровни и позволяется сконцентрироваться сначала на том, что надо сделать в программе, затем разрабатывать решение. При этом методе проектирования исходная задача, подлежащая решению, делится на ряд подзадач, которые подчиняются главной задаче. Это разбиение называют декомпозицией. Далее эти задачи делятся еще на более мелкие и т.д. до тех пор, пока не получатся задачи, для решения которых требуются небольшие модули 3-5 строк. Такой метод позволяет упростить решение сложных задач. Паскаль имеет различные средства для деления программы на части. На верхнем уровне деления (больших задач) – это модули, на нижнем уровне (элементарных подзадач) – это процедуры и функции.
В языке Паскаль подпрограммы реализуются в виде процедур и функций, которые вводятся в программу с помощью своего описания.
Описание процедур
Процедуры описываются в специальном разделе описательной части программы вслед за разделом описания переменных. Любая процедура аналогично программе состоит из заголовка и тела.
Заголовок процедуры:
procedure <имя> (<список формальных параметров>)
procedure – это служебное слово,
<имя процедуры> определяется в соответствии с общими правилами описания идентификатора,
<список формальных параметров> - это перечень имен для обозначения исходных данных и результатов работы процедуры с указанием их типов.
Допускается описание процедур, которые не содержат списка формальных параметров:
procedure <имя>
Содержательная часть процедуры (тело процедуры) состоит из раздела описаний и раздела операторов. В составе описательной части процедуры могут быть другие процедуры или функции. Раздел операторов начинается с begin и заканчивается end; .
Пример 1. Оформить в виде процедуры алгоритм вычисления
procedure STEP1 (n: integer; a: real; var y: real);
var i: integer;
begin y:=1; for i:=1 to n do y:=y*a; end;
В описательной части данной процедуры определена переменная i, необходимая и имеющая смысл только внутри данной процедуры. Она называется локальной переменной. Значение локальной переменной не доступно в основной программе.
Пример 2. Оформить эту же процедуру в виде процедуры без параметра.
procedure STEP2;
var i: integer;
begin y:=1; for i:=1 to n do y:=y*a; end;
В данном случае процедура STEP2 не содержит списка формальных параметров и работает с локальной переменной i. Переменные n, y, a являются глобальными по отношению к процедуре STEP2, значит, они должны быть описаны в основной программе и могут использоваться как внутри процедуры, так и в основной программе.
Обращение к процедурам
Описание процедуры или функции само по себе никакого действия не вызывает. Чтобы выполнить процедуру или функцию, необходимо обратиться к ней. Обращение к процедуре осуществляется с помощью специального оператора вызова процедуры, который имеет вид:
<имя> (<список аргументов>)
<имя> - имя процедуры, к которой происходит обращение,
<список аргументов> - это перечень конкретных значений и имен, подставляемых на место формальных параметров процедуры при ее выполнении.
При вызове процедуры формальные параметры, указанные в заголовке, заменяются аргументами в порядке их следования. Аргументы, перечисленные в операторе-процедуре, называются фактическими параметрами. Число формальных и фактических параметров должно совпадать.
Пример 3. Составить программу вычисления .
Program STEP3;
uses crt;
var m:integer; a,z:real;
procedure STEP1 (n: integer; x: real; var y: real);
var i: integer;
begin y:=1; for i:=1 to n do y:=y*x; end;
begin clrscr;
writeln (‘Введите показатель и основание степени’);
write (‘m = ’); readln (m); write (‘a = ’); readln (a);
if m = 0 then z:=1 else if m>0 then STEP1(m, a, z)
else STEP1(-m, 1/a, z);
writeln (‘z = ’, z:5:3); readkey; end.
Если осуществляется вызов процедуры без параметра, то оператор представляет собой указание только имени процедуры.
Пример 4. Составить программу как в примере 3, используя процедуру без параметра.
Program STEP4; uses crt;
var m:integer; a,z:real;
procedure STEP2;
var i:integer;
begin z:=1; for i:=1 to m do z:=z*a; end;
begin clrscr; writeln (‘Введите показатель и основание степени’);
write (‘m = ’); readln (m);
write (‘a = ’); readln (a);
if m = 0 then z:=1 else
if m>0 then STEP2 else begin m:=-m; a:=1/a; STEP2; end;
writeln (‘z = ’, z:5:3); readkey; end.
Описание функций
Описание функций состоит из заголовка и содержательной части.
Описание заголовка:
function <имя> (<список параметров>): <тип>
<список параметров> - это перечень формальных параметров с указанием их типа,
<тип> - это тип результата, т.е. значения функции.
Допускается описание функций без параметра
function <имя>: <тип>
В содержательной части подпрограммы-функции имени функции должно быть присвоено некоторое значение (значение ответа).
Пример 5. Оформить в виде функции алгоритм вычисления степени .
function STEP5 (m: integer; a: real): real;
var i: integer;
begin y:=1; for i:=1 to m do y:=y*a; STEP5:=y; end;
Обращение к функциям
При обращении к функции обязательно должен быть использован оператор присваивания результата имени функции с указание фактических параметров. Если вызывается функция без параметра, то указывается только имя этой функции.
Пример 6. Вычислить , используя функцию с параметром.
Program STEP6; uses crt;
var m:integer; a,z,r:real;
function STEP5 (n: integer; x: real): real;
var i: integer; y: real;
begin y:=1; for i:=1 to n do y:=y*x; STEP5:=y; end;
begin clrscr;
writeln (‘Введите m и a ’); write (‘m = ’); readln (m);
write (‘a = ’); readln (a);
z:=STEP5(3,a)+STEP5(-3,1/a);
if m=0 then r:=1 else if m>0 then r:=STEP5(m,a) else r:=STEP5(-m,1/a);
z: = (z/2)*r;
writeln (‘z = ’, z:5:3); readkey; end.
Стандартные модули языка Паскаль
Раздел указания используемых модулей начинается с зарезервированного слова uses. Присутствие в программе предложения uses не обязательно. Оно описывается в случаях, если в программе используются константы, типы, переменные, процедуры и функции, определенные в стандартных модулях Турбо Паскаль, кроме модуля System, или в модулях, созданных пользователем.
Предложение uses в каждой отдельной программе может быть описано только однократно и должно располагаться непосредственно после заголовка программы.
Стандартный модуль System всегда используется по умолчанию и указывать его в предложении uses не нужно. Этот модуль поддерживает такие средства, как файловый ввод-вывод, обработка строк, операции с плавающей точкой, динамическое распределение памяти.
Остальные стандартные модули (наиболее часто используются модули CRT и GRAPH) автоматически не подключаются и, в случае использования, обязательно указываются в предложении uses. Рассмотрим назначение этих модулей:
CRT – объединяет процедуры и функции для работы с экраном в текстовом режиме и клавиатурой; содержит, например, такие процедуры и функции как: readkey, clrscr, clreoln, gotoxy(x,y), wherex, wherey, keypressed, delline, insline, sound(v), nosound, delay(time), textcolor(color), textbackground(color) и др.
GRAPH - состоит из процедур и функций для работы с экраном в графическом режиме;
DOS – содержит процедуры и функции для взаимодействия с MS DOS;
OVERLAY - обеспечивает работу с оверлеями (то есть частями программы), используется для обработки программ большого объема при недостатке оперативной памяти;
PRINTER – модуль для работы с принтером.
Модульное программирование
Модуль – это автономно компилируемая программная единица, включающая в себя различные компоненты раздела описаний и возможно несколько исполняемых операторов инициирующей части.
Модуль состоит из заголовка модуля, интерфейса, исполнительской части, секции инициализации. Объявление модуля начинается с ключевого слова unit
unit <имя модуля>
Заголовок необходим для ссылки на модуль.
Интерфейсная часть модуля начинается служебным словом interface.
Интерфейс содержит объявления, включая процедуры и функции, представленные списком заголовков и доступные пользователям в основной программе.
Раздел исполнительской части или реализации начинается служебным словом implementation. Он содержит тела процедур и функций, перечисленных в интерфейсной части модуля.
Раздел «инициализация» начинается с begin и содержит операторы, необходимые для инициализации модуля, т.е. операторы начальных установок, необходимых для запуска начальных установок модуля. Как правило, операторы инициализации не требуются, поэтому begin можно опустить.
Каждый модуль компилируется отдельно; результат компиляции – файл с расширением .tpu. Чтобы откомпилировать модуль, необходимо сначала сохранить его как любую другую программу с расширением .pas. Затем в меню Compile выполнить команду Make.
Пример. Создать модуль математической функции.
Unit math; {заголовок модуля}
interface {интерфейсная часть модуля}
function power (x: real; n: integer): real; {функция возведения числа в сепень}
function factor (n: integer): integer; {функция вычисления факториала от n}
implementation {исполняемая часть модуля}
function power;
var i:integer; y:real;
begin y:=1; for i:=1 to n do y:=y*x; power:=y; end;
function factor;
var i,f:integer;
begin f:=1; for i:=1 to n do f:=f*i; factor:=f; end;
end.
Program Sum;
{Программа вычисляет приближенное значение суммы ряда S=1+x+x^2/2!+…
с точностью, заданной пользователем. Программа использует модуль Math}
uses crt,math; var x,u,eps,s:real; k: integer;
{u–слагаемое, eps–точность, s–сумма, k–число слагаемых}
begin
write (‘Введите x’); readln(x);
write (‘Введите eps’); readln (eps);
s: = 0; u: = 1; k: = 0;
while abs(u) > eps do begin
s:=s+u; k:=k+1; u:=power(x,k)/factor(k);
end;
writeln (‘Результат равен ’, s); readkey; end.
Метод в объектно-ориентированном программировании — это функция, принадлежащая какому-то классу или объекту.
Как и процедура в процедурном программировании, метод состоит из некоторого количества операторов для выполнения какого-то действия, имеет набор входных аргументов и возвращаемое значение.
Различают простые методы и статические методы (методы класса):
простые методы имеют доступ к данным объекта (конкретного экземпляра данного класса),
статические методы не имеют доступа к данным объекта и для их использования не нужно создавать экземпляры (данного класса).
Методы предоставляют интерфейс, при помощи которого осуществляется доступ к данным объекта некоторого класса, тем самым, обеспечивая инкапсуляцию данных.
В зависимости от того, какой уровень доступа предоставляет тот или иной метод, выделяют:
открытый (public) интерфейс — общий интерфейс для всех пользователей данного класса;
защищённый (protected) интерфейс — внутренний интерфейс для всех наследников данного класса;
закрытый (private) интерфейс — интерфейс, доступный только изнутри данного класса.
Такое разделение интерфейсов позволяет сохранять неизменным открытый интерфейс, но изменять внутреннюю реализацию.
В таких языках программирования как C++, C# или Pascal методы реализованы как классические процедуры (функции), которые неявно используют указатель на объект (экземпляр класса). В таком языке программирования как smalltalk принято говорить о сообщениях и о том, что объекты обрабатывают сообщения.