Подпрограмма — это поименованная или каким-либо иным образом обозначенная часть программы, которая может быть многократно вызвана из разных частей основной программы для выполнения неких “типовых” вычислений, в том числе для различных исходных данных.
Идея здесь состоит в следующем. Предположим, что некоторая часть алгоритма по своей сути повторяется в программе несколько раз. Так, в комбинаторике при вычислении количества сочетаний из п элементов по k (подмножеств из k элементов, взятых произвольно из множества n элементов и различающихся хотя бы одним элементом без учёта порядка их следования) используется формула:
В ней трижды надо вычислять факториал для трёх разных исходных значений. Тогда вычисление факториала путём выполняемых в цикле умножений можно оформить в виде подпрограммы, а затем обращаться к ней, каждый раз передавая этой подпрограмме требуемое исходное значение.
Иногда в виде подпрограмм выделяют фрагменты программного кода, выполняющие какие-либо типовые действия, — например, реализующие какие-то элементы интерфейса с пользователем. Это позволяет создавать отдельные библиотеки подпрограмм, облегчая этим работу программисту: ему уже не нужно отвлекаться на реализацию подобных “мелочей” и можно сосредоточиться непосредственно на сути решаемой вычислительной задачи, а библиотека готовых подпрограмм просто подключается к созданному листингу перед его компиляцией (или во время неё). А в современных ОС (например, в Windows) такие подпрограммы, уже откомпилированные в файлы DLL, являются основой функционирования как самой ОС, так и работающих в её среде прикладных программ и обеспечивают унификацию компонентов интерфейса.
Подпрограммы, процедуры и функции
Наконец, деление исходного сложного алгоритма на подпрограммы позволяет обеспечить его структуризацию, облегчить понимание и разработку программного продукта, разделить исходную задачу на более простые подзадачи, реализуя тем самым принцип нисходящего программирования (“от общего к частному”).
Это одна из двух возможных разновидностей подпрограмм. Её отличительная особенность состоит в том, что функция, принимая на вход любое количество исходных данных (аргументов), может возвращать только одно значение, которое передается как значение самой этой функции.
Для работы с подпрограммами-функциями в языке Паскаль (и аналогично — в большинстве других современных процедурных языков высокого уровня) требуется знание следующих особенностей.
1. Подпрограмма-функция должна быть описана в начале программы — после объявления используемых в ней глобальных констант, меток и переменных, но до собственно текста основной программы, заключенного в операторные скобки BEGIN и END (для наглядности эти слова, обрамляющие текст основной программы, записаны прописными буквами).
2. Описание подпрограммы-функции начинается со строки
Возврат нескольких значений функции через указатели. Функция возвращает несколько значений. #49
• Function — зарезервированное слово, указывающее транслятору, что далее идёт описание подпрограммы-функции;
• — идентификатор, выбираемый по тем же правилам, что и для имён переменных;
• сразу после имени функции в скобках записывается перечень передаваемых в эту функцию формальных параметров — имён переменных, которые далее будут использоваться при вычислениях, выполняемых в этой функции. При этом формальные параметры группируются через запятую в блоки одинаковых типов, а обозначения их типов записываются после списка параметров через двоеточие, как принято в Паскале при определении переменных; блоки параметров различного типа записываются через точку с запятой;
• после закрывающей скобки, также через двоеточие, записывается тип результата, который будет возвращать функция.
Function F (х : real) : real; —объявляется подпрограмма-функция с именем F, которая принимает на вход одно действительное (тип real) число х и возвращает также действительное (real, записанное после скобок) значение результата.
3. После строки определения функции записывается её программный код. Правила его записи аналогичны правилам записи основной программы:
• сначала может присутствовать раздел описания локальных констант и переменных; эти константы и переменные действуют только в пределах данной функции и могут иметь такие же имена, что и локальные переменные, объявленные в других подпрограммах (транслятор их не путает);
• далее между операторными скобками begin и end записывается текст подпрограммы.
4. В конце текста подпрограммы значение, которое функция должна возвращать в качестве результата, нужно обязательно присвоить специальной переменной, имя которой совпадает с именем самой функции (причём отдельно объявлять эту переменную не нужно).
5. В тексте основной программы вызов функции производится следующим образом:
• записывается имя функции, а после него в скобках через запятую — список фактических параметров — константы, имена переменных, выражения, а также другие вызовы функций, значения которых нужно передать в функцию для выполнения вычислений. При этом количество и типы таких фактических параметров должны соответствовать указанным в объявлении функции формальным параметрам. Каждый фактический параметр при вызове функции записывается в соответствующий ему по порядку следования в списке формальный параметр и тем самым попадает в выполняемые функцией вычисления. При этом если для формального параметра указан соответствующий составной тип, объявленный в разделе type основной программы, то в подпрограмму может быть передан, например, массив целиком;
• поскольку функция возвращает значение, её запись (вместе с фактическими параметрами в скобках) должна быть либо включена в состав выражения, либо записана после имени переменной и следующего за ней оператора присваивания, либо указана как параметр в процедуре вывода на экран, записи в файл и пр. Иначе возвращённое функцией значение будет потеряно.
Отличительная особенность подпрограммы-процедуры (или просто — процедуры) состоит в том, что она (в отличие от функции) может как принимать на вход, так и возвращать любое количество данных, причём все они записываются в качестве аргументов процедуры.
Для работы с процедурами в языке Паскаль (и в большинстве других языков высокого уровня) требуется знать следующее.
1. Процедура должна быть описана в начале программы — после объявления используемых в ней глобальных констант, меток и переменных, но до собственно текста основной программы, заключённого в операторные скобки BEGIN и END.
2. Описание подпрограммы-функции начинается со строки
• Procedure — зарезервированное слово, указывающее транслятору, что далее идёт описание подпрограммы-процедуры;
• — идентификатор, выбираемый по тем же правилам, что и для имён переменных;
• сразу после имени функции в скобках записывается перечень передаваемых в эту функцию формальных параметров — имён переменных, которые будут использоваться при вычислениях, выполняемых в процедуре, и имён переменных, в которые процедура должна записать полученные результаты. Формальные параметры (как и в функциях) группируются через запятую в блоки одинаковых типов, а обозначения их типов записываются после списка параметров через двоеточие; блоки параметров различного типа записываются через точку с запятой;
• в процедуру, кроме обычных значений (числовых или символьных), можно передавать данные составных типов (массивы, записи и пр.). Для этого надо объявить такой составной тип, как пользовательский в разделе type в начале программы, далее объявить в разделе var соответствующий экземпляр данных как переменную этого составного типа, а далее при определении процедуры указать для соответствующих формальных параметров этот составной (пользовательский) тип.
Procedure Pr1(L : integer; var R : atype ) ; — объявляется процедура с именем Prl, которая работает с целым (тип integer) числом L и массивом R, тип которого (atype) был ранее определён в разделе type:
При этом параметры процедуры могут передаваться в нее как значения или как ссылки. В чем заключается различие между этими двумя способами передачи данных, мы рассмотрим чуть позже. Пока же отметим, что составные данные (в том числе массивы) обычно передаются как ссылки, а признаком передачи ссылки в процедуру является запись служебного слова var перед именем формального параметра (как и сделано в данной программе для передачи в процедуру массива R).
3. После строки определения процедуры записывается её программный код. Правила его записи аналогичны правилам записи основной программы:
• сначала может присутствовать раздел описания локальных констант и переменных, действующих только в пределах данной процедуры;
• далее между операторными скобками begin и end записывается текст подпрограммы.
4. Результаты вычислений, которые процедура должна вернуть в основную программу, должны быть записаны в качестве значения соответствующего формального параметра.
5. В тексте основной программы вызов процедуры производится следующим образом:
• записывается имя процедуры, а после него в скобках через запятую — список фактических параметров — константы, имена переменных, выражения, а также другие вызовы процедур или функций, значения которых нужно передать в процедуру для выполнения вычислений. Переменные, в которые процедура должна вернуть результаты вычислений, также записываются как её фактические параметры (и это должны быть переменные, объявленные в основной программе!).
Количество и типы всех фактических параметров должны соответствовать указанным в объявлении процедуры формальным параметрам. При этом если параметр передаётся как значение, то это значение при вызове подпрограммы будет скопировано в соответствующий формальный параметр, так что если процедура, выполняя вычисления, изменит значение этого формального параметра, то это никак не повлияет на значение “фактической” переменной в основной программе. А вот если параметр передаётся как ссылка, то в процедуру попадёт информация о расположении в оперативной памяти компьютера самих исходных данных (скажем, массива), и тогда все изменения, которые процедура совершит с таким формальным параметром, будут отражены в самом исходном массиве. Иными словами, передавая массив (или другой экземпляр составных данных) в процедуру по ссылке, мы отдаём процедуре всю “власть” выполнять любые изменения с этим массивом. Соответственно, для возвращения результата изменений параметра, переданного как ссылка, не требуется предусматривать какой-то отдельный параметр: все эти изменения сразу производятся в исходном экземпляре данных.
Передача данных как значения
Передача данных как ссылки
• поскольку процедура возвращает результаты своей работы через свои параметры, она записывается как отдельная команда программы, а не как составная часть выражения или оператора присваивания.
Разбор типовых задач
Задача 1. Определить, какое число будет напечатано в результате работы следующей программы:
В тексте программы (если не считать подключения модуля crt в разделе uses) вначале объявлен целый ряд переменных (раздел var).
Затем следует описание подпрограммы-функции с именем F, которой должно передаваться одно исходное значение — действительное число (формальный параметр х, который затем используется в качестве переменной в тексте подпрограммы) и которая должна возвращать действительное значение. Что именно вычисляется в этой подпрограмме, пока подробно не рассматривается.
После подпрограммы записан текст основной программы (между BEGIN И END).
Чтобы решить эту задачу нужно произвести полную трассировку используемых в программе переменных. Для этого составляется таблица трассировки. Следует особо отметить, что каждый раз, когда встречается в основной программе вызов функции, нужно переходить к тексту её описания и выполнять соответствующие команды до завершающего текст подпрограммы-функции слова end. При этом заданные в вызове функции фактические параметры автоматически переписываются в таблицу в качестве значений соответствующих им формальных параметров (столбец формального параметра, равно как и команды подпрограммы-функции, в таблице выделен серым фоном ячеек). Для наглядности значения переменных, изменяемые в результате действия текущей команды, выделены жирным шрифтом.
Выполнение полной трассировки такой программы — дело сложное и долгое. Однако можно выявить следующую закономерность: пока с увеличением значения t получаемое значение F(t) также увеличивается (в результате чего это значение каждый раз оказывается больше предыдущего значения F(t), запомненного в переменной R) текущее значение t заносится в интересующую переменную М.
Если выполнить перемножение скобок в выражении, записанном в составе функции F, то получается квадратное уравнение:
Поскольку перед х 2 стоит знак минуса, ветви параболы, соответствующей этому уравнению, будут направлены вниз. Вычисления производятся по левой ветви этой параболы снизу вверх. Очевидно, что рано или поздно они “доберутся” до вершины параболы, после чего с ростом t начнётся “движение” по её второй ветви уже сверху вниз. Тогда условие F(t) > R перестанет выполняться (это произойдёт, когда будет пройдена вершина параболы и при переходе к следующему же после этого значению t), а значит, прекратится и запись текущих значений t в переменную М. Так будет до самого конца цикла изменения t.
Остаётся найти координату вершины параболы t и проследить работу программы вблизи этого значения данной переменной. Для этого можно использовать тот факт, что в вершине параболы значение производной равно нулю: -2х + 2 = 0. Тогда х = 1. Значит, искомое значение переменной t равно 1. Трассировка продолжается с него.
Итак, последнее возможное изменение значения переменной М уже произошло, и при этом М стала равна 1.
Ответ: в результате работы данной программы будет выведено число 1 (вариант № 1).
Задача 2. Определите, какое число будет напечатано в результате работы следующей программы (для вашего удобства программа представлена на четырёх языках):
Источник: compendium.school
Функция возвращает несколько значений
Я нередко слышу от новичков, что функция может возвращать только одно значение, и что процедуры в Паскале возвращать значения не могут. Заблуждения — это обычное дело в начале изучения какого-нибудь предмета. Но чем быстрее вы начнёте от них избавляться, тем лучше. И сегодня я как раз помогу вам это сделать. Итак:
- Процедуры в Паскале могут возвращать значения
- Функции и процедуры могут возвращать несколько значений
А теперь рассмотрим несколько способов.
Используем запись
Не самый удобный способ, но во многих случаях его можно и нужно использовать. Функция при этом будет возвращать одно значение, но это значение будет иметь тип записи, а запись, как вы понимаете, может содержать в себе множество переменных разных типов. Пример:
type TCoord = record X, Y : Integer; end; //******************************************************************* // Способ 1: использование записи //******************************************************************* function GetCoordRec(Point : TCoord) : TCoord; begin Point.X := 10; Point.Y := 5; Result := Point; end;
Думаю, особых пояснений здесь не требуется. Использовать эту функцию в программе можно, например, так:
var Point : TCoord; begin //Способ 1 Point := GetCoordRec(Point); WriteLn(‘X, Y : ‘, Point.X, ‘, ‘, Point.Y); end.
Используем массив
Принцип действия тот же, что и при использовании записи. Отличие в том, что в записи могут быть переменные разных типов, а в массиве только однотипные. И сначала надо будет объявить новый тип для массива, потому что функция может возвращать только данные определённого типа, а массив сам по себе типом не является. То есть вот это не прокатит:
function GetCoordMas : array[1..2] of Integer;
и компилятор выдаст ошибку. Поэтому делать надо так:
type AInteger = array[1..2] of Integer; //******************************************************************* // Способ 2: использование массива //******************************************************************* function GetCoordMas : AInteger; begin Result[1] := 15; Result[2] := 16; end;
Это будет работать, и в программе можно использовать, например, так:
var A : AInteger; begin //Способ 2 A := GetCoordMas; WriteLn(‘X, Y : ‘, A[1], ‘, ‘, A[2]); end.
Используем var
Это самый простой способ вернуть из функции или процедуры любое количество значений любых типов. И в большинстве случаев использовать надо именно этот способ:
//******************************************************************* // Способ 3: использование var //******************************************************************* function GetCoordVar(var X : Integer) : Integer; begin X := 11; Result := 6; end;
Здесь я немного поизвращался. Но это для наглядности. Если в списке параметров функции или процедуры перед именем переменной указать слово var , то это будет означать, что через эту переменную будет не только передано значение в подпрограмму, но и получено значение из подпрограммы. Подробнее об этом здесь.
Используем указатели
Для новичков это самый сложный способ. Да и я в подавляющем большинстве случаев не вижу смысла его использовать. Но знать об этом надо, потому что многие стандартные функции, особенно системные и особенно в С++, используют именно его.
Суть его в том, чтобы передавать в подпрограмму не переменную, а её адрес. Тогда изменение данных в памяти, на которые указывает этот адрес, автоматически приведёт к изменению значений всех переменных, которые ссылаются на эту область в памяти.
type PInteger = ^Integer; //*************************************************************** // Способ 4: использование указателей //*************************************************************** procedure GetCoordP(x, y : PInteger); begin x^ := 100; y^ := 200; end;
Здесь тоже придётся объявить отдельный тип, потому что вот это не прокатит:
procedure GetCoordP(x, y : ^Integer);
Компилятор выдаст ошибку.
В программе использовать такую процедуру (или функцию) можно так:
Как вы понимаете, при работе с указателями надо выделять память перед её использованием и освобождать после использования. Вот здесь вы можете найти больше сведений об указателях.
На этом останавливаюсь. Основные мысли я изложил. При желании вы можете подключить воображение и придумать что-нибудь ещё. Ну и, разумеется, описанные выше способы можно комбинировать. Также скажу, что всё это в той или иной степени справедливо и для других языков программирования.
Разумеется, с учётом их особенностей.
Подписывайтесь на новости, чтобы ничего не пропустить (ссылки под видео), а если что-то ещё не вполне понятно, то см. видео:
Источник: info-master.su
Подпрограммы. Процедуры и функции
Относительно самостоятельные фрагменты программы, оформленные определенным образом и снабженные заголовком, называются подпрограммами. С помощью подпрограмм любая программа может быть разбита на ряд формально независимых друг от друга частей.
Подпрограммы делятся на два вида: процедуры и функции. Результатом исполнения операторов, образующих тело функции, всегда является единственное значение, поэтому ее имя может быть использовано в выражениях наряду с переменными и константами.
Если в программе используются процедуры или функции, то их описание должно предшествовать основному блоку программы.
Описание состоит из заголовка и тела процедуры (функции), которое обычно следует за заголовком.
Список формальных параметров записывается в скобках и содержит перечень параметров с указанием их типов. Перед выходными параметрами, которые возвращают результат в основную программу, указывается ключевое слово VAR, например:
PROCEDURE SUMMA(A1,A2:REAL; B1,B2:INTEGER; VAR S1,S2:REAL); Допускаются также процедуры без параметров:
PROCEDURE ;
Они предполагают использование в подпрограмме только глобальных переменных, определенных в разделе описаний основной программы.
За заголовком процедуры следует раздел описаний подпрограммы (меток, констант, типов, переменных, а также описаний вложенных процедур и функций) и блок операторов.
Структура описания заголовка подпрограммы-функции имеет вид:
Формальные параметры записываются с указанием их типа, кроме того, указывается тип самой функции. За заголовком функции следует раздел описаний и блок выполняемых операторов.
Пример
FUNCTION STEP(x, y: REAL): REAL;
После описания блока процедуры или функции следует оператор END, за которым ставится точка с запятой.
Отличие функции от процедуры состоит в том, что функция может возвращать одно значение в основную программу через свое имя, а процедура возвращает несколько значений через список параметров. Поэтому в разделе операторов функции должен быть оператор, который имени функции присваивает значение вида
Вызов подпрограмм производится указанием имени или имени со списком фактических параметров. Фактические параметры не указываются, если в подпрограмме используются только глобальные переменные и в заголовке программы отсутствует список формальных параметров. Если заголовок подпрограммы содержит формальные параметры, то при обращении к подпрограмме должен обязательно присутствовать список фактических параметров, которые записываются через запятую.
Количество, тип и порядок перечисления фактических параметров должен обязательно соответствовать количеству, типу и порядку перечисления формальных параметров в описании подпрограммы.
Структура подпрограммы-функции
Описание блока подпрограммы-функции в общем виде имеет следующую структуру:
BEGIN
END;
Функция передает в вызывающую программу единственное значение, которое хранится под ее именем. В качестве переменных могут использоваться параметры-переменные и параметры-значения. < Тип > функции должен соответствовать значению, которое вычисляется в данной подпрограмме (типу результата). В вызывающую подпрограмму передается значение функции данного типа.
Вызов функции в программе производится не обособленно, как в процедуре, а в выражении указывается имя функции со списком параметров.
Примеры и задания с подпрограммой-функцией
Пример 1. Вычислить вторую и N-ю степени числа Х.
PROGRAM FUNC;
VAR X: REAL; N: INTEGER;
FUNCTION STEPEN(M: INTEGER; A: REAL): REAL;
BEGIN
FOR I:=1 TO M DO P:= P*A;
END;
WRITELN(‘ X=’, X, ‘ квадрат’, STEPEN(2,X));
WRITELN(‘ X=’, X, ‘ степень’, STEPEN(N,X));
Пример 2. Даны три массива A (5), B (5), C (5). Найти среднее арифметическое значение наименьших элементов массивов.
До написания программы разрабатывается СА главной программы (рис. 14, а) и СА для подпрограммы нахождения наименьшего элемента в любом массиве (рис. 14, б).
Отлаженная программа решения задачи имеет следующий вид:
Program lr8;
mass = array[1..5] of integer;
const a: mass = (5,2,7,1,8);
FUNCTION minim(d:mass): integer;
var i, min: integer;
begin
writeln(‘минимальный элемент равен ‘,min);
end;
BEGIN
sr: = (minim(a) + minim(b) + minim(c)) /3;
writeln(‘ sr = ‘, sr:5:2);
END.
Задания для самостоятельного выполнения
Задание 1
Написать и отладить программы для задач из пп. 3.7 и 6.4 с применением подпрограммы-функции с параметрами. Вычисление функции (или обработку массива) выполнить в подпрограмме, а ввод исходных данных и вывод результатов — в основной программе. Предусмотреть, по крайней мере, два обращения к функции с различными фактическими параметрами.
Для отладки программ использовать средства системы Pascal ABC: пошаговое исполнение программы (трассировку) с контролем значений переменных в окне отладчика.
Задание 2
1. По заданным вещественным массивам A [1..6], B [1..6] и C [1..6] вычислить
(max B)/max A + (max C)/max(B+C) при min A < max B,
max(B+C) + max C в противном случае.
2. Даны два двумерных массива целых чисел А [1…5], B [1…5]. Напечатать квадрат того из них, в котором наименьший след (сумма диагональных элементов), считая, что такой массив один.
3. Определить координаты центра тяжести трех материальных точек с массами m1, m2, m3 и координатами (x1,y1), (x2,y2), (x3,y3) по формулам
Вычисление координаты оформить функцией с параметрами.
4. Вычислить все медианы для каждого из трех треугольников по заданным в массивах A, B, C сторонам: ma = 0.5 , mb = 0.5 , mc = 0.5 . Вычисление медианы оформить функцией.
5. Даны три одномерных массива вещественных чисел A [1..6], B [1..8] и С [1..7]. Найти общую сумму положительных элементов в массивах. Нахождение суммы элементов в массиве оформить функцией.
6. Даны два двумерных массива целых чисел с размерами (4х5) элементов. Подсчитать количество отрицательных элементов в каждом из них.
7. Даны два одномерных массива целых чисел A [1..8] и B [1..8]. Найти сумму их максимальных элементов. Для нахождения максимального элемента в массиве использовать функцию.
8. Даны два двумерных массива целых чисел по (5х5) элементов каждый. Подсчитать произведение элементов главных диагоналей в каждом из них.
9. Даны три одномерных массива вещественных чисел A [1..6], B [1..8] и С [1..7]. Найти среднее геометрическое значение положительных элементов для каждого.
10. Даны две матрицы целых чисел M [1..3,0..1], К [1..3,0..2]. Найти среднее арифметическое значение для каждой из них.
11. Даны три одномерных массива целых чисел A [1..6], B [1..8] и С [1..7]. Подсчитать количество неотрицательных элементов в каждом.
12. Даны две матрицы целых чисел S [1..3,0..2], К [1..3,0..2], в каждой из которых имеется по два одинаковых числа. Распечатать их значения.
13. Даны два одномерных массива целых чисел A [1..6] и B [1..8]. Вычислить значение Z = (min A[i] + min B[j]) / min (A[i]+B[j]).
14. По заданным целым массивам X[0..7] и Y[8..15] вычислить
yi 2 в противном случае.
15. Дана матрица целых чисел D [1..6,1..5]. Найти наименьшую из сумм неотрицательных элементов строк матрицы. Для вычисления суммы использовать подпрограмму (функцию).
16. Дана матрица целых чисел E [1..3,1..5]. Используя функцию, найти среднее геометрическое значение для каждого столбца матрицы.
17. Дана матрица целых чисел F [1..4,1..5]. Найти наименьшие значения элементов в каждой из строк матрицы с помощью функции.
18. Даны две квадратные вещественные матрицы шестого порядка. Напечатать квадрат той из них, в которой наименьший след (сумма диагональных элементов), считая, что такая матрица одна.
19. Сформировать двумерный массив: 1 2 3 4 5
Найти правило и оформить функцией вычисление любой строки.
20. Даны две матрицы целых чисел V [1..2,1..3], W [1..3,1..2]. Найти суммы элементов строк и столбцов в этих матрицах.
Источник: poisk-ru.ru