Модульное программирование

Презентацию к данной работе Вы можете скачать здесь.

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

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

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

Подпрограммы

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

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

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

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

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

inc(i); writeln(a, b, c);               { вызовы процедур }
y := sin(x) + 1;                        { вызов функции }

Внутри подпрограмм можно описывать другие подпрограммы. Они доступны только из той подпрограммы, в которой описаны.

Процедуры

Структура процедуры аналогична структуре основной программы:

procedure имя [(список параметров)];         { заголовок }
    разделы описаний
begin
    раздел операторов
end;

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

Пример. Найти разность средних арифметических значений двух вещественных массивов из 10 элементов.

Как видно из условия, для двух массивов требуется найти одну и ту же величину — среднее арифметическое. Следовательно, логичным будет оформить его нахождение в виде подпрограммы, которая сможет работать с разными массивами ( пример 4.1 ).

program dif_average;
const n = 10;
type mas = array[1 .. n] of real;
var a, b : mas;
    i    : integer;
    dif, av_a, av_b : real;
procedure average(x : mas; var av : real);                       { 1 }
    var i : integer;
    begin
        av := 0;
        for i := 1 to n do av := av + x[i];
        av := av / n;
    end;                                                         { 2 }
begin
    for i := 1 to n do read(a[i]);
    for i := 1 to n do read(b[i]);
    average(a, av_a);                                            { 3 }
    average(b, av_b);                                            { 4 }
    dif := av_a – av_b;
    writeln('Разность значений ', dif:6:2);
end.

Описание процедуры average расположено в строках с {1} по {2 }. В строках {3} и {4} эта процедура вызывается сначала для обработки массива а, затем — массива b. Массивы передаются в качестве аргументов. Результат вычислений возвращается в главную программу через второй параметр процедуры.

Функции

Описание функции отличается от описания процедуры незначительно:

function имя [(список параметров)] : тип; { заголовок }
    разделы описаний
begin
    раздел операторов
    имя := выражение;
end;

Квадратные скобки в данном случае означают, что список параметров может отсутствовать. Функция вычисляет одно значение, которое передается через ее имя. Следовательно, в заголовке должен быть описан тип этого значения, а в теле функции — оператор, присваивающий вычисленное значение ее имени. Он не обязательно должен находиться в конце функции. Более того, таких операторов может быть несколько — это определяется алгоритмом. Рассмотрим пример применения функции для программы, приведенной в предыдущем разделе.

Пример. Найти разность средних арифметических значений двух вещественных массивов из 10 элементов ( пример 4.2).

program dif_average1;
const n = 10;
type mas = array[1 .. n] of real;
var a, b : mas;
    i    : integer;
    dif  : real;
function average(x : mas) : real;                                 { 1 }
    var i : integer;                                              { 2 }
       av : real;
    begin
        av := 0;
        for i := 1 to n do av := av + x[i];
        average := av / n;                                        { 3 }
    end;                                                             
begin
    for i := 1 to n do read(a[i]);
    for i := 1 to n do read(b[i]);
    dif := average(a) – average(b);                               { 4 }
    writeln('Разность значений ', dif:6:2)
end.

Оператор {1} представляет собой заголовок функции. Тип функции определен как вещественный, потому что к такому типу относится среднее арифметическое элементов вещественного массива. Оператор {3} присваивает имени функции вычисленное значение. В операторе {4} функция вызывается дважды: сначала для одного массива, затем для другого.