Методология структурного программирования основывается на использовании подпрограмм и независимых структур данных.
Подпрограмма (англ. subprogram) — поименованная или иным образом идентифицированная часть компьютерной программы, содержащая описание определённого набора действий. Подпрограмма может быть многократно вызвана из разных частей программы.
Назначение подпрограмм. Подпрограммы изначально появились как средство оптимизации программ по объёму занимаемой памяти — они позволили не повторять в программе идентичные блоки кода, а описывать их однократно и вызывать по мере необходимости. К настоящему времени данная функция подпрограмм стала вспомогательной, главное их назначение — структуризация программы с целью удобства её понимания и сопровождения
Выделение набора действий в подпрограмму и вызов её по мере необходимости позволяет логически выделить целостную подзадачу, имеющую типовое решение. Такое действие имеет ещё одно (помимо экономии памяти) преимущество перед повторением однотипных действий: любое изменение (исправление ошибки, оптимизация, расширение функциональности), сделанное в подпрограмме, автоматически отражается на всех её вызовах, в то время как при дублировании каждое изменение необходимо вносить в каждое вхождение изменяемого кода.
Основы программирования на Python. Часть 8. Подпрограммы: процедуры и функции
Даже в тех случаях, когда в подпрограмму выделяется однократно производимый набор действий, это оправдано, так как позволяет сократить размеры целостных блоков кода, составляющих программу, то есть сделать программу более понятной и обозримой.
Вызов подпрограммы выполняется с помощью команды вызова, включающей в себя имя подпрограммы. В большинстве современных языков программирования команда вызова представляет собой просто имя вызываемой подпрограммы, за которым могут следовать фактические параметры.
Формальные и фактические параметры. Чтобы отличать параметры подпрограммы, описанные в её заголовке и теле, от параметров, указываемых при вызове подпрограммы, первые принято называть формальными параметрами, вторые — фактическими параметрами.
Подпрограмма – это блок кода между операторами Sub и End Sub или Function и end Function.
Виды подпрограмм. В языках программирования высокого уровня используется два типа подпрограмм: процедуры и функции.
Подпрограмма-процедура – это блок кода, заключенный между операторами Sub и End Sub. Обычно подпрограмму-процедуру принято называть процедурой.
При написании программы нужно учесть одно правило: «Внутри одной процедуры не может быть описана другая процедура».
Процедура — это любая подпрограмма, которая не является функцией.
Подпрограмма-функция – это блок кода, заключенный между операторами Function и End Function. Она выполняет какую-то операцию, но при этом обязательно возвращает какое-нибудь значение. Значение возвращается через имя функции.
Функция — это подпрограмма специального вида, которая, кроме получения параметров, выполнения действий и передачи результатов работы через параметры имеет ещё одну возможность — она может возвращать результат. Вызов функции является, с точки зрения языка программирования, выражением, он может использоваться в других выражениях или в качестве правой части присваивания. Подробнее см. в статье Функция (программирование).
Подпрограммы (процедура)
Подпрограммы, входящие в состав классов в объектных языках программирования, обычно называются методами. Этим термином называют любые подпрограммы-члены класса, как функции, так и процедуры; когда требуется уточнение, говорят о методах-процедурах или методах-функциях.
6.2.4 Принцип проектирования программ сверху-вниз и снизу–вверх.
Программирование «сверху вниз», или нисходящее программирование – это методика разработки программ, при которой разработка начинается с определения целей решения проблемы, после чего идет последовательная детализация, заканчивающаяся детальной программой. Является противоположной методике программирования «снизу вверх».
При нисходящем проектировании задача анализируется с целью определения возможности разбиения ее на ряд подзадач. Затем каждая из полученных подзадач также анализируется для возможного разбиения на подзадачи. Процесс заканчивается, когда подзадачу невозможно или нецелесообразно далее разбивать на подзадачи.
В данном случае программа конструируется иерархически – сверху вниз: от главной программы к подпрограммам самого нижнего уровня, причем на каждом уровне используются только простые последовательности инструкций, циклы и условные разветвления.
Программирование «снизу вверх», или восходящее программирование – это методика разработки программ, начинающаяся с разработки подпрограмм (процедур, функций), в то время когда проработка общей схемы не закончилась. Является противоположной методике программирования «сверху вниз».
Такая методика является менее предпочтительной по сравнению с нисходящим программированием так как часто приводит к нежелательным результатам, переделкам и увеличению времени разработки.
Программирование «сверху вниз», или пошаговая детализация. Суть метода заключается в разбиении исходной задачи на последовательность нескольких меньших подзадач. Эти подзадачи, в свою очередь, тоже распадаются на подзадачи и т. д. до тех пор, пока не останутся только элементарные алгоритмы.
Пример. Чтобы написать число 512, сначала пишут цифру 5, затем 1 и, наконец, 2. При этом цифры рисуют, последовательно прорисовывая линии, из которых они состоят. Принтер напечатает это число точками.
При разработке программы пошагово, методом «сверху вниз» сначала пишется текст основной программы, в котором, вместо каждого связного логического фрагмента текста, вставляется вызов подпрограммы, которая будет выполнять этот фрагмент. Вместо настоящих, работающих подпрограмм, в программу вставляются «заглушки», которые ничего не делают.
Полученная программа проверяется и отлаживается. После того, как программист убедится, что подпрограммы вызываются в правильной последовательности (то есть общая структура программы верна), подпрограммы-заглушки последовательно заменяются на реально работающие, причём разработка каждой подпрограммы ведётся тем же методом, что и основной программы.
Разработка заканчивается тогда, когда не останется ни одной «затычки», которая не была бы удалена. Такая последовательность гарантирует, что на каждом этапе разработки программист одновременно имеет дело с обозримым и понятным ему множеством фрагментов, и может быть уверен, что общая структура всех более высоких уровней программы верна. При сопровождении и внесении изменений в программу выясняется, в какие именно процедуры нужно внести изменения, и они вносятся, не затрагивая части программы, непосредственно не связанные с ними. Это позволяет гарантировать, что при внесении изменений и исправлении ошибок не выйдет из строя какая-то часть программы, находящаяся в данный момент вне зоны внимания программиста.
В теории и практике программирования наиболее популярны стратегии «сверху вниз» и «снизу вверх». Такие полярные варианты взаимодействия процессов проектирования и реализации оказываются применимыми только для программ небольшого или среднего размера. Создание же крупной программы обычно связано с поиском разумного компромисса между этими вариантами. Существует и еще одно решение – программирование «вширь».
Программирование «вширь» — ориентиром провозглашается набор однородных модулей. В одной программе может быть выявлено несколько однородных наборов. После того как однородные модули выявлены, приступают к непосредственному программированию, которое, собственно, и разбивается на этапы. На первом этапе создается лишь минимальное число представителей каждого из выделенных однородных наборов. Если поиск однородности проводился достаточно энергично, то обычно оказывается, что объем работ первого этапа реализации сравнительно невелик.
Источник: studopedia.ru
Понятие и структура подпрограммы. Процедуры и функции, их сущность, назначение, различие.
Основное различие между процедурой и функцией состоит в том, что процедура только выполняет какую-либо законченную последовательность действий, не возвращая результата работы в основную программу, а функция и выполняет действия, и возвращает результат.
Описания процедур, их виды. Стандартные процедуры. Формальные и фактические параметры.
Без параметров с параметрами
Параметры-значения используются для задания начальных значений в процедуре.
Параметры-переменные для вывода результата.
Описание процедур с параметрами:
раздел описания локальных переменных
раздел выполняемых операторов
(вычисления дискриминанта квадратного уравнения)
Procedure Discr (A, B, C: real; var D: real);
Вызов данной процедуры в основной программе:
Описание процедур без параметров:
раздел описания локальных переменных
раздел выполняемых операторов
Вызов данной процедуры в основной программе
Пример процедуры без параметров
(вычисления дискриминанта квадратного уравнения)
Procedure Discr;
Стандартная подпрограмма (процедура или функция) — подпрограмма, включенная в библиотеку программ ЭВМ, доступ к которой обеспечивается средствами языка программирования. Вызывается она по имени с заданием фактических параметров с типом описанным при описании данной процедуры в библиотечке процедур и функций.
Формальные параметры – данные, с которыми работает подпрограмма (ПП). Это внутренние данные для ПП. Они перечисляются в заголовке ПП и связаны с фактическими параметрами. Фактические параметры – данные, передаваемые в ПП и возвращаемые из нее. Это внешние для ПП данные, с которыми имеет дело вызывающая часть программы. В ПП им соответствуют формальные параметры.
Указываются в списке фактических параметров при обращении к ПП.
Понятие функции и ее описание. Вызов функции. Стандартные функции.
Функция – это подпрограмма, результат выполнения которой есть единственное скалярное значение, присваиваемое имени этой функции.
Function (параметры: тип): тип; раздел описаний локальных переменных begin раздел операторов
Пример функции
(вычисления дискриминанта квадратного уравнения)
Function Discr (A, B, C: real): real;
Вызов данной процедуры в основной программе
Источник: studfile.net
Подпрограммы
Аннотация: В данной лекции рассматривается работа с подпрограммами — процедурами и функциями. Подробно рассматриваются аргументы, передаваемые в подпрограммы, параметры по значению, параметры по ссылке. Рассматриваются различные способы реализации подпрограмм, а также такое важное понятие, как область видимости переменных и других объектов.
Цель лекции
Освоение работы с подпрограммами, с параметрами по ссылке, параметрами по значению, с досрочным выходом из программ и подпрограмм, с областью видимости переменных.
Подпрограммы
Вначале языки программирования были проще, они выполнялись строго сверху-вниз, один оператор за другим. Такие языки еще называли линейными. Типичный пример линейных языков — Бейсик.
Единственную возможность организовать хоть какую-то логику в таких языках предоставлял оператор безусловного перехода GOTO , который в зависимости от условия, «перепрыгивал» на заранее расставленные метки. В современных языках программирования GOTO тоже остался, наверное, для любителей антиквариата. Но его применение может привести к трудно обнаруживаемым логическим ошибкам времени выполнения ( run-time errors ). Использование GOTO в современном программировании считается дурным тоном. Мы не будем изучать эту возможность, поскольку для организации логики есть куда более «продвинутые» средства! Одним из таких средств являются подпрограммы.
Подпрограмма — это часть кода, которую можно вызвать из любого места программы неопределенное количество раз.
Другими словами, подпрограммы подобны строительным кирпичикам, из которых, в конце концов, получается здание — программа . Без подпрограмм можно обойтись, если вы пишете небольшую учебную программу на пару десятков строк кода. А если это серьезное приложение , с парой сотен модулей, в каждом из которых могут быть тысячи строк кода?
Как такую программу написать, не разбивая задачу на отдельные части? Подпрограммы помогают улучшить код, структурировать его. Поэтому языки высокого уровня, которые позволяют использовать подпрограммы, называют ещё процедурно-ориентированными языками. И наш компилятор FPC тоже относится к таким языкам.
Подпрограммы бывают двух типов: процедуры и функции — первые просто выполняют свою работу, вторые еще и возвращают результат этой работы.
Процедуры
На самом деле, мы уже неоднократно использовали процедуры. Например, когда генерировали событие нажатия на кнопку. Это событие — процедура. Процедура начинается с ключевого слова procedure и имеет следующий синтаксис :
procedure (); const ; type ; var ; ; begin ; end;
Большая часть указанного синтаксиса является необязательной — процедура может не иметь параметров, констант, пользовательских типов данных, переменных и т.п. — она может быть очень простой, например:
procedure ErrorMessage; begin ShowMessage(‘Ошибка!’ +#13 + ‘На ноль делить нельзя!’); end;
Такую процедуру можно вызвать из любого места программы, но процедура обязательно должна быть описана выше — ведь иначе компилятор не будет знать о ней. Есть еще возможность предварительно объявить процедуру, но об этом чуть позже. Итак, если эта процедура описана выше, то мы можем вызвать её, просто указав её имя:
ErrorMessage;
Компилятор перейдет к процедуре и выполнит её код (в данном случае — выведет сообщение об ошибке ). После этого компилятор вернется назад, и выполнит следующий за вызовом процедуры оператор.
Параметры
Параметры подпрограмм — достаточно важная тема, поговорим об этом подробней. В процедуру (или в функцию) можно передать какие то исходные данные, чтобы процедура их обработала. Такие данные называются параметрами, или формальными параметрами. Пример — пользователь ввел какое-то число (а на самом деле, строку из цифровых символов), нам нужно удвоить его, а результат сообщить пользователю. Описать подобную процедуру можно следующим образом:
procedure Udvoenie(st: string); var r: real; begin //полученную строку преобразуем в число: r:= StrToFloat(st); //теперь удвоим его: r:= r * 2; //теперь выведем результат в сообщении: ShowMessage(FloatToStr(r)); end;
Этот пример уже сложнее, правда? На самом деле, всё просто. Давайте разберем, что тут к чему. Итак, строка объявления процедуры:
procedure Udvoenie(st: string);
объявляет процедуру Udvoenie с параметром строкового типа st . Это означает, что теперь мы можем вызвать процедуру, передав ей в качестве параметра какую-то строку. Параметр st условно можно считать внутренней переменной процедуры, в которую компилятор скопирует передаваемую процедуре строку. Этот способ передачи данных в подпрограмму называется параметром по значению. Допустим, в дальнейшем мы вызвали процедуру таким образом:
Udvoenie(‘123.4’);
Компилятор сделает вызов процедуры, передав в параметр st указанное значение ‘123.4’ . Или же мы можем вызвать процедуру иначе, передав в неё значение , которое хранится в какой то другой строковой переменной:
myst:= ‘123.4’; Udvoenie(myst);
Результат будет таким же. Тут важно помнить, что тип передаваемого значения обязательно должен совпадать с типом параметра. Если параметр у нас string , то и передавать ему нужно значение типа string . Компилятор копирует это значение в параметр . Другими словами, если внутри процедуры мы изменим значение параметра st , это никак не отразится на переменной myst, поскольку мы изменим копию данных, а не сами данные.
Пойдем дальше. А дальше мы объявляем вещественную переменную r :
var r: real;
Здесь она необходима, ведь нам нужно умножить значение параметра на два, поэтому мы вынуждены будем преобразовать строковое представление числа в настоящее число — ведь строку на два не умножишь! Результат поместим в r :
begin //полученную строку преобразуем в число: r:= StrToFloat(st);
Служебным словом begin мы начинаем тело процедуры . Стандартной функцией StrToFloat(st) мы преобразуем строковое значение параметра st в число, и присвоим это число переменной r . Далее всё просто:
//теперь удвоим его: r:= r * 2; //теперь выведем результат в сообщении: ShowMessage(FloatToStr(r)); end;