Вопрос22. Понятие подпрограммы. Локальные и глобальные переменные
Если переменная или константа описана в основной программе, она считается глобальной, и ее могут использовать любые процедуры и функции данной программы. Переменные, описанные внутри подпрограммы, называются локальными и могут быть использованы только внутри данной подпрограммы. Локальные переменные могут быть описаны как в заголовке программы, так и в разделе описания переменных.при совпадении имен глобальных и локальных переменных, локальные определения в пределах своего действия отменяют действия глобальных, и эти переменные никак не связаны между собой.
Рассмотрим две почти одинаковые программы.Program Variant1;
Var
X : real;
Procedure writeX;
Var
x : real;
Begin
write(x)
End;
Begin
X := Pi;;
writeX
End.
Program Variant2;
Var
X : real;
Procedure writeX;
Begin
write(x)
End;
Begin
X := Pi;
writeX
End.
Нетрудно догадаться о решаемой задаче: присвоить глобальной переменной х некоторое значение, а затем напечатать это число через специальную процедуру.
Во втором варианте программы переменная с именем Х описана только в основной программе, поэтому она, как глобальная переменная, доступна в подпрограмме. В результате будет напечатано значение числа П.
В первом варианте переменная х переопределена в подпрограмме, таким образом, в подпрограмме имеется локальная переменная х, ничем не связанная с переменной Х основной программы. Поскольку этой локальной переменной не присвоено значение, будет напечатано случайное число, содержащееся в соответствующей ячейке памяти.
Возникает вопрос, какова роль локальных переменных, нельзя ли все переменные описать как глобальные?
Процедура должна быть, по возможности, независима от основной программы, поэтому все переменные, нужные только в пределах процедуры, должны описываться как локальные. Общение основной программы с подпрограммой должно, как правило, идти через список параметров процедуры, что придает подпрограммам необходимую гибкость. Вместе с тем, излишне большое число параметров, передаваемое в подпрограмму при ее вызове, замедляет работу программы, поэтому не следует пренебрегать использованием в подпрограммах глобальных переменных.
Кроме локальных переменных, в программах могут быть и локальные подпрограммы. Это подпрограммы, текст которых размещен внутри текста подпрограммы более высокого уровня. Использование таких подпрограмм, как и локальных переменных, ограничивается подпрограммой, к которой они принадлежат.
Локальность или глобальность являются понятиями относительными. Программа с вложенными в нее подпрограммами представляет собой иерархическое дерево. Объект, локальный по отношению к более высокому уровню иерархии, ведет себя как глобальный по отношению к подпрограммам более низкого уровня.
Подпрограммы нужны для того, чтобы упростить структуру программы и облегчить ее отладку. В виде подпрограмм оформляются логические законченные части программы.
Подпрограмма - это фрагмент кода, к которому можно обратиться по имени. Она описывается один раз, а вызываться может столько раз, сколько необходимо. Одна и та же подпрограмма может обрабатывать различные данные, переданные ей в качестве аргументов.
В Паскале два вида подпрограмм: процедуры и функции. Они имеют незначительные отличия в синтаксисе и правилах вызова. Процедуры и функции описываются в соответствующих разделах описания, до начала блока исполняемых операторов.
Само по себе описание не приводит к выполнению подпрограммы. Для того чтобы подпрограмма выполнилась, ее надо вызвать. Вызов записывается в том месте программы, где требуется получить результаты работы подпрограммы. Подпрограмма вызывается по имени, за которым следует список аргументов в круглых скобках. Если аргументов нет, скобки не нужны. Список аргументов при вызове как бы накладывается на список параметров, поэтому они должны попарно соответствовать друг другу.
Процедура вызывается с помощью отдельного оператора, а функция - в правой части оператора присваивания, например:
inc(i); writeln(a, b, c); { вызовыпроцедур }
y := sin(x) + 1; { вызов функции }
Внутри подпрограмм можно описывать другие подпрограммы. Они доступны только из той подпрограммы, в которой они описаны. Рассмотрим правила описания подпрограмм.
Глобальные и локальные переменные
В IBM PC-совместимых компьютерах память условно разделена на так называемые сегменты. Адрес каждого байта составляется из номера сегмента и смещения относительно его начала.
Длина адресов сегмента и смещения - 16 бит, поэтому размер сегмента не может превышать 216 байт (64K). При вычислении адреса байта в оперативной памяти адрес сегмента сдвигается на 4 двоичных разряда влево, и к нему прибавляется смещение (рис. 1). Таким образом, длина адреса составляет 20 бит, и с помощью него можно адресовать память объемом 220 байт (1 мегабайт).
Компилятор Паскаля формирует сегмент кода, в котором хранится программа в виде машинных команд, сегмент данных, в котором выделяется память под глобальные переменные программы, и сегмент стека, предназначенный для размещения локальных переменных во время выполнения программы (рис. 2).
Глобальными называются переменные, описанные в главной программе. Переменные, которые не были инициализированы явным образом, перед началом выполнения программы обнуляются. Время жизни глобальных переменных - с начала программы и до ее завершения. Глобальные переменные доступны в любом месте программы или подпрограммы, кроме тех подпрограмм, в которых описаны локальные переменные с такими же именами.
Внутри подпрограмм описываются локальные переменные. Они располагаются в сегменте стека, причем распределение памяти происходит в момент вызова подпрограммы, а ее освобождение - по завершении подпрограммы. Значения локальных переменных между двумя вызовами одной и той же подпрограммы не сохраняются и эти переменные предварительно не обнуляются. Локальные переменные могут использоваться только в подпрограмме, в которой они описаны, и всех вложенных в нее.
В подавляющем большинстве случаев для обмена данными между вызывающей и вызываемой подпрограммами предпочтительнее использовать механизм параметров. Если все данные передаются подпрограммам через списки параметров, для локализации места ошибки достаточно просмотреть заголовки подпрограмм, а затем - тексты только тех из них, в которые передается интересующая нас переменная.
Виды параметров подпрограмм
Список параметров, то есть величин, передаваемых в подпрограмму и обратно, содержится в ее заголовке. Для каждого параметра обычно задается его имя, тип и способ передачи. Либо тип, либо способ передачи могут не указываться.
Важно запомнить, что в заголовке подпрограммы нельзя вводить описание нового типа, там должны использоваться либо имена стандартных типов, либо имена типов, описанных программистом ранее в разделе type.
В Паскале четыре вида параметров:
значения;
переменные;
константы;
нетипизированные параметры.
Параметры-значения
Параметр-значение описывается в заголовке подпрограммы следующим образом:
имя : тип;
Например, передача в процедуру Р величины целого типа записывается так:
procedure P(x :integer);
Имя параметра может быть произвольным. Параметр х можно представить себе как локальную переменную, которая получает свое значение из главной программы при вызове подпрограммы. В подпрограмму передается копия значения аргумента.
Механизм передачи следующий: из ячейки памяти, в которой хранится переменная, передаваемая в подпрограмму, берется ее значение и копируется в область сегмента стека, называемую областью параметров. Подпрограмма работает с этой копией, следовательно, доступа к ячейке, где хранится сама переменная, не имеет. По завершении работы подпрограммы стек освобождается. Такой способ называется передачей по значению.
При вызове подпрограммы на месте параметра, передаваемого по значению, может находиться выражение. Тип выражения должен быть совместим по присваиванию с типом параметра.
Например, если в вызывающей программе описаны переменные
var x : integer;
c : byte;
y :longint;
то следующие вызовы подпрограммы Р, заголовок которой описан выше, будут синтаксически правильными:
P(x); P(c); P(y); P(200); P(x div 4 + 1);
Недостатками передачи по значению являются затраты времени на копирование параметра, затраты памяти в стеке и опасность его переполнения, когда речь идет о параметрах, занимающих много места - например, массивах большого размера. Поэтому более правильно использовать для передачи в подпрограмму исходных данных параметры-константы, о которых речь пойдет чуть дальше.
Параметры-переменные
Признаком параметра-переменной является ключевое слово var перед описанием параметра:
var имя : тип;
Например, передача в процедуру Р параметра-переменной целого типа записывается так:
procedure P(var x : integer);
При вызове подпрограммы в область параметров копируется не значение переменной, а ее адрес, и подпрограмма через него имеет доступ к ячейке, в которой хранится переменная. Этот способ передачи параметров называется передачей по адресу. Подпрограмма работает непосредственно с переменной из вызывающей программы и, следовательно, может ее изменить.
ВНИМАНИЕ При вызове подпрограммы на месте параметра-переменной может находиться только ссылка на переменную точно того же типа.
Проиллюстрируем передачу параметров-значений и параметров-переменных на примере.
Пример №1.
var a, b, c, d, e : word;
procedure X(a, b, c : word; var d : word);
var e : word;
begin
c := a + b; d := c; e := c;
writeln ('Подпрограмма:');
writeln ('c = ', c, ' d = ', d, ' e = ', e);
end;
begin
a := 3; b := 5;
x(a, b, c, d);
writeln ('Главная программа:');
writeln ('c = ', c, ' d = ', d, ' e = ', e);
end.
Результаты работы этой программы приведены ниже:
Подпрограмма:
c = 8 d = 8 e = 8
Главная программа:
c = 0 d = 8 e = 0
Значение переменной с в главной программе не изменилось, поскольку переменная передавалась по значению, а значение переменной ес тем же именем.не изменилось потому, что в подпрограмме была описана локальная переменная
Параметры-константы
Параметр-константу можно узнать по ключевому слову const перед описанием параметра:
const имя : тип;
Это ключевое слово говорит о том, что в пределах подпрограммы данный параметр изменить невозможно. При вызове подпрограммы на месте параметра может быть записано выражение, тип которого совместим по присваиванию с типом параметра. Фактически параметры-константы передаются по адресу, но доступ к ним обеспечивается только для чтения.
Например, передача в процедуру Р параметра-константы целого типа записывается так:
procedure P(const x : integer);
Подведем итоги. Если данные передаются в подпрограмму по значению, их можно изменять, но эти изменения затронут только копию в области параметров и не отразятся на значении переменной в вызывающей программе. Если данные передаются как параметры-константы, изменять их в подпрограмме нельзя. Следовательно, эти два способа передачи должны использоваться для передачи в подпрограмму исходных данных.
Параметры составных типов (массивы, записи, строки) предпочтительнее передавать как константы, потому что при этом не расходуется время на копирование и место в стеке.
Результаты работы процедуры следует передавать через параметры-переменные, результат функции - через ее имя.
Нетипизированные параметры
Как можно догадаться из названия, при описании нетипизированных параметров не указывается тип. Передаются они всегда по адресу - либо как константы, либо как переменные, например:
procedure P(const a, b; var y);
Есть одно важное ограничение: передать-то их можно, а вот делать с ними в подпрограмме что-либо до тех пор, пока они не приведены к какому-то определенному типу, все равно нельзя!
Пример №2.
Функция сравнения на равенство двух величин произвольного размера и типа.
Function EQ(const x, y; size : word) : boolean;
type
mas_byte = array[0 .. MaxInt] of byte;
var
n : integer;
begin
n := 0;
while (n < size) and (mas_byte(x)[n] = mas_byte(y)[n]) do
inc(n);
EQ := n = size;
end;
В эту функцию фактически передаются только адреса начала расположения в памяти двух переменных, поэтому необходим еще один параметр: длина сравниваемых величин в байтах (параметр size). Единственный способ выяснить, равны ли две величины, размер которых заранее не известен - их побайтное сравнение, поэтому оба параметра приводятся к типу mas_byte, объявленному в функции. При описании массива используется стандартная константа MaxInt, в которой хранится максимальное значение для величин типа integer, то есть 32767.
С помощью функции EQ можно сравнить две любые величины. Пусть, например, в программе описаны переменные:
var a, b : array [1 .. 10] of byte; x: real; c: string;
Следующие обращения к функции EQ будут корректны:
EQ(a, b, sizeof(a)) { сравнение двух массивов }
EQ(a[2], b[5], 4) { сравнение 2-5 элементов массива "a" с 5-8 элементами массива "b", соответственно }