Процедуры в Паскале
Работа из раздела: «
Программирование и комп-ры»
Министерство образования Российской Федерации.
Северо-Кавказский Горно-Металлургический Институт (СКГТУ)
кафедра промышленной электроники .
факультет электронной техники, ПЭ-04-1 .
К У Р С О В А Я Р А Б О Т А
«
»
(вариант №9)
Выполнил Дзотцоев Лев Казгериевич
Преподаватель Яровой Иван Федорович
«___» «______________» 200__
Г. Владикавказ 2004 год
Задание
1. Приведите синтаксис описания и вызова процедуры. Опишите виды,
назначение формальных и фактических параметров. Приведите пример
описания процедуры, её вызова и поясните его.
2. Даны целые m и n. Составить программу вычисления
x = (m! +n!)/(m+n)!, где k=1x2x3x4x..xK
В программе предусмотреть:
. Ввод m и n
. Описание процедуры-функции для вычисления значения факториала :
f(k) = k! = 1x2x3x..xK
. Отображение на экране дисплея значения Х
. Комментарии в основных местах программы
2.1 Отладить и провести счет по программе.
2.2 Привести в пояснительной записке:
. Текст программы с пояснениями
. Исходные данные и результаты счета
СОДЕРЖАНИЕ
Задание
1
Содержание
2
Синтаксис описания и вызова процедуры
3
Параметры
4
Пример описания и вызова процедуры
5
Виды параметров
6
Программа
12
Пояснительная записка
13
Заключение
15
Литература
16
Приложение
17
Синтаксис описания и вызова процедуры.
Программа объемом до 10000 операторов считается малой, до 100000 операторов
– средней. Понятно, что строить такие программы непосредственно из
элементарных операции практически невозможно. Для упрощения разработки
программ в Pascal-е можно использовать подпрограммы - процедуры и функции.
Они представляют собой инструмент, с помощью которого любая программа
может быть разбита на ряд в известной степени независимых друг от друга
частей. Такое разбиение необходимо по двум причинам.
Во-первых, это средство экономии памяти: каждая подпрограмма существует в
программе в единственном экземпляре, в то время как обращаться к ней можно
многократно из разных точек программы. При вызове подпрограммы
активизируется последовательность образующих ее операторов, а с помощью
передаваемых подпрограмме параметров нужным образом модифицируется
реализуемый в ней алгоритм.
Вторая причина заключается в применении современных методов нисходящего
проектирования программ. В результате применение этих методов алгоритм
представляется в виде последовательности относительно крупных подпрограмм,
реализующих более или менее самостоятельные смысловые части алгоритма.
Подпрограммы в свою очередь могут разбиваться на менее крупные
подпрограммы, те - на подпрограммы нижнего уровня и т.д. Последовательное
структурирование программы продолжается до тех пор, пока реализуемые
подпрограммами алгоритмы не станут настолько простыми, чтобы их можно было
легко запрограммировать.
Pascal даже в сравнении с промышленными системами программирования обладает
очень мощными средствами работы с подпрограммами.
Процедуры и функции, как уже отмечалось, представляют собой относительно
самостоятельные фрагменты программы, оформленные особым образом и
снабженные именем. Упоминание этого имени в тексте программы называется
вызовом процедуры (функции). Отличие функции от процедуры заключается в
том, что результатом исполнения операторов, образующих тело функции, всегда
является некоторое единственное значение простого, строкового типа или
указателя, поэтому обращение к функции можно использовать в соответствующих
выражениях наряду с переменными и константами.
В структуре Pascal программ существует специальный раздел для
описания процедур и функций. Как известно, любое имя в программе должно
быть обязательно описано перед тем, как оно появится среди исполняемых
операторов. Не делается исключения и в отношении процедур: каждую
необходимо описать в разделе описаний.
Описать подпрограмму - это значит указать ее заголовок и тело. В
заголовке объявляются имя процедуры и формальные параметры, если они есть.
За заголовком следует тело подпрограммы, которое состоит из раздела
описаний и раздела исполняемых операторов. В разделе описаний процедур
могут встретиться описания процедур низшего уровня, в тех - описания других
подпрограмм и т.д.
Синтаксис и вызов (в общем) процедур:
Procedure <имя процедуры>
Uses <имена модулей>
Label <имена меток>
Const <имена констант>
Type <имена типов>
Var <имена локальных переменных>
<раздел объявления подпрограмм>
Begin
<операторы>
End;
Для выполнения процедуры необходим её вызов. Вызов осуществляется по имени
данной процедуры в теле программы. Имя процедуры воспринимается как
оператор. При его выполнении выполняется вся подпрограмма.
Описание подпрограммы состоит из заголовка и тела подпрограммы.
Заголовок
Заголовок процедуры имеет вид:
PROCEDURE <имя> (<сп.ф.п.>);
Здесь <имя> - имя подпрограммы <сп.ф.п.> - список формальных параметров;
{Сразу за заголовком подпрограммы может следовать одна из стандартных
директив ASSEMBLER, EXTERNAL, FAR, FORWARD, INLINE, INTERRUPT, NEAR}
Параметры
Параметры бывают формальные и фактические. Параметры, которые записываются
в скобках после имени процедуры, называются формальными параметрами. Они
указывают на то, что для выполнения данной процедуры необходимы
дополнительные данные – фактические параметры.
Список формальных параметров необязателен и может отсутствовать.
{Использование процедур без параметров оправданно только в том случае, если
в них не используется обращение к глобальным переменным. Использование
таких процедур ограниченно той программой, для которой они написаны и
затруднено для других программ}.
Если же он есть, то в нем должны быть перечислены имена формальных
параметров и их тип, например:
Procedure YZ (a : real; b : integer: с : char)
Как видно из примера, параметры в списке отделяются друг от друга
точками с запятой. Несколько следующих подряд однотипных параметров можно
объединять в подсписки, например, вместо
Procedure Z (а : integer; b : integer)
можно написать проще:
Procedure Z (a, b : integer)
Операторы тела подпрограммы рассматривают список формальных параметров
как своеобразное расширение раздела описаний: все переменные из этого
списка могут использоваться в любых выражениях внутри подпрограммы. Таким
способом осуществляется настройка алгоритма подпрограммы на конкретную
задачу.
Первый формальный параметр заменяется первым фактическим, второй-вторым и
т. д.
Механизм замены формальных параметров на фактические позволяет нужным
образом настроить алгоритм, реализованный в подпрограмме. Турбо Паскаль
следит за тем, чтобы количество и тип формальны параметров строго
соответствовали количеству и типам фактических параметров в момент
обращения к подпрограмме. Напомним: смысл используемых фактических
параметров зависит от того, в каком порядке они перечислены при вызове
подпрограммы. Пользователь должен сам следить за правильным порядком
перечисления фактических параметров при обращении к подпрограмме. Приведем
пример. рассмотрим интересующую нас часть программы (не самой удачной, но
это пока неважно) для вычисления x = (5! + 2!)/(5+2)!
Program factorial(input,output);
……
{далее нас интересует описание процедуры:}
Procedure FL(L:integer, var z: integer); {объявление процедуры, её имя ,
список формальных параметров}
Begin
Z:=1;
While L>1 do
Begin
Z:=ZxL;{тело процедуры, которая также предусматривает, что 0! и 1!
=1}
L:=l-1;
end;
end;
……..
begin
……..
{теперь рассмотрим вызов процедуры}
FL(5,a);
FL(2,b);
FL(2+5,c);
..........
end.
В данном случае l, z формальные параметры. К слову, их не надо описывать в
разделе глобальных переменных.
Фактические параметры: 5, а, 2, b, 2+5, c. В “основном” разделе VAR должны
быть описаны а, b, c
При первом вызове процедуры фактический параметр 5 заменит формальный L,
фактический a заменит формальный z, во втором 2 заменит L, b заменит z.
В третьем соответственно 2+5 заменит L, c заменит z. Для того, чтобы
окончательно разобраться в программе, необходимо пояснить, какими бывают
виды формальных и фактических параметров, их назначение.
Виды параметров.
По способу передачи данных параметры можно разделить на несколько
категорий.
Любой из формальных параметров подпрограммы может быть либо параметром-
значением, либо параметром-переменной, либо параметром-константой. Если
параметры определяются как параметры-переменные, перед ними необходимо
ставить зарезервированное слово VAR, например:
Procedure tide (var a : real) Здесь параметр А - параметр-переменная.
Заголовок процедуры может быть устроен так, что некоторые группы формальных
параметров не содержат слова VAR. Например:
Procedure qwerty(a,b,c:real; var s:real);
Формальные параметры, которые входят в группы, не содержащие слова VAR,
называются формальными параметрами-значениями.
Определение формального параметра тем или иным способом существенно только
для вызывающей программы: если формальный параметр объявлен как параметр-
переменная, то при вызове подпрограммы ему должен соответствовать
фактический параметр в виде переменной определенного типа; если формальный
параметр объявлен как параметр-значение, то при вызове ему может
соответствовать произвольное выражение. Контроль за неукоснительным
соблюдением этого правила осуществляет компилятором Турбо Паскаля.
Для того чтобы понять, в каких случаях использовать параметры значения, а в
каких - параметры-переменные, рассмотрим, как осуществляется замена
формальных параметров на фактические в момент обращения к подпрограмме.
Если параметр определен как параметр-значение, то перед вызовом
подпрограммы это значение вычисляется, полученный результат копируется во
временную память и передается подпрограмме. Важно учесть, что даже если в
качестве фактического параметра указано простейшее выражение в виде
переменной или константы, все равно подпрограмме будет передана лишь копия
переменной (константы). Таким образом, назначение параметра-значения –
передача данных из программы в подпрограмму. Если же параметр определен как
параметр-переменная, то при вызове подпрограммы передается сама переменная,
а не ее копия. Любые возможные изменения в подпрограмме параметра-значения
никак не воспринимаются вызывающей программой, так как в этом случае
изменяется копия фактического параметра, в то время как изменение параметра-
переменной приводит к изменению самого фактического параметра в вызывающей
программе. Параметр-константа схож с параметром-переменной: в подпрограмму
передается сама константа, но изменение её невозможно. Назначение такого
параметра совпадает с назначением параметра-значения . Формальные параметры-
константы указываются в заголовке программы после служебного слова const.
Его действие распространяется до ближайшей точки с запятой.
Поясним изложенное.
.....
var
a, b: integer;
......
procedure squar(a: integer; var b: integer);
begin
a:=sqr(a);
b:=sqr(b);
writeln(‘в квадрате они выглядят так: ’,a,’, ’,b);
end;
........
begin
a:=4; b:=6;
writeln(‘внимательно посмотрите на эти числа: ’, a,’, ’, b);
squar(a,b);
writeln(‘а так а не в квадрате: ’,a, ’, ’,b);
end.
Результаты выглядят так: внимательно посмотрите на эти числа: 4, 6
в квадрате они выглядят так: 16, 36
а так а не в квадрате: 4, 36
Этот пример может служить еще и иллюстрацией механизма «закрывания»
глобальной переменной а одноименной локальной: хотя переменная объявлена
как глобальная (она описана в вызывающей программе перед описанием
процедуры), в теле процедуры ее «закрыла» локальная переменная а,
объявленная как параметр-значение.
Итак, параметры-переменные используются как средство связи алгоритма,
реализованного в подпрограмме, с «внешним миром»: с помощью этих параметров
подпрограмма может передавать результаты своей работы вызывающей программе.
Разумеется, в распоряжении программиста всегда есть и другой способ
передачи результатов - через глобальные переменные. Однако злоупотребление
глобальными связями делает программу , как правило, запутанной, трудной в
понимании и сложной в отладке. В соответствии с требованиями хорошего стиля
программирования рекомендуется там, где это возможно, использовать передачу
результатов через фактические параметры-переменные.
С другой стороны, описание всех формальных параметров как параметров-
переменных нежелательно по двум причинам. Во-первых, это исключает
возможность вызова подпрограммы с фактическими параметрами в виде
выражений, что делает программу менее компактной. Во-вторых, и главных, в
подпрограмме возможно случайное использование формального параметра,
например, для временного хранения промежуточного результата, т.е. всегда
существует опасность непреднамеренно «испортить» фактическую переменную.
Вот почему параметры-переменные следует объявлять только те, через которые
подпрограмма в действительности передает результаты вызывающей программе.
Чем меньше параметров объявлено параметрами-переменными и чем меньше в
подпрограмме используется глобальных переменных, тем меньше опасность
получения непредусмотренных программистом побочных эффектов, связанных с
вызовом подпрограммы, тем проще программа в понимании и отладке.
Существует одно обстоятельство, которое следует учитывать при выборе
вида формальных параметров. Как уже говорилось, при объявлении параметра-
значения осуществляется копирование фактического параметра во временную
память. Если этим параметром будет массив большой размерности, то
существенные затраты времени и памяти на копирование при многократных
обращениях к подпрограмме могут стать peшающим доводом в пользу объявления
такого параметра параметром-переменной или передачи его в качестве
глобальной переменной.
Параметры массивы и параметры строки
Может сложиться впечатление, что объявление переменных в списке
формальных параметров подпрограммы ничем не отличается от объявления их в
разделе описания переменных. Действительно, в обоих случаях много общего,
но есть одно существенное различие: типом любого параметра в списке
формальных параметров может быть только стандартный или ранее объявленный
тип. Поэтому нельзя, например, объявить следующую процедуру:
Procedure S (а : array (1..10] of real);
так как в списке формальных параметров фактически объявляется тип -
диапазон, указывающий границы индексов массива.
Если мы хотим передать какой-то элемент массива, то проблем, как
правило, не возникает, но если в подпрограмму передается весь массив, то
следует первоначально описать его тип. Например:
…...
type
mas = array [1..10] of real;
.......
PROCEDURE S (a : mas);
…...
Поскольку строка является фактически своеобразным массивом, ее передача в
подпрограмму осуществляется аналогичным образом:
.......
type
intype =string[15];
outype = string[30];
FUNCTION St (i : intype) : outype:
Требование описать любой тип-массив или тип-строку перед объявлением
подпрограммы на первый взгляд кажется несущественным. Действительно, в
рамках простейших вычислительных задач обычно заранее известна структура
всех используемых в программе данных, поэтому статическое описание массивов
не вызывает проблем. Однако разработка программных средств универсального
назначения связана со значительными трудностями. По существу, речь идет о
том, что в Турбо Паскале невозможно использовать в подпрограммах массивы с
«плавающими» границами изменения индексов. Например, если разработана
программа, обрабатывающая матрицу из 10 х 10 элементов, то для обработки
матрицы из 9 х 11 элементов необходимо переопределить тип, т.е.
перекомпилировать всю программу. Этот недостаток, как и отсутствие в языке
средств обработки исключительных ситуаций (прерываний), унаследован из
стандартного Паскаля и представляет собой объект постоянной и вполне
заслуженной его критики. Разработчики Турбо Паскаля не рискнули кардинально
изменить свойства базового языка, но, тем не менее, включили в него
некоторые средства, позволяющие в известной степени смягчить отмеченные
недостатки.
Прежде всего, в среде Турбо Паскаля можно установить режим компиляции,
при котором отключается контроль над совпадением длины фактического и
формального параметра-строки. Это позволяет легко решить вопрос о передаче
подпрограмме строки произвольной длины. При передаче строки меньшего
размера формальный параметр будет иметь ту же длину, что и параметр
обращения; передача строки большего размера приведет к ее усечению до
максимального размера формального параметра. Следует сказать, что контроль
включается только при передаче строки, объявленной как формальный параметр-
переменная. Если соответствующий параметр объявлен параметром-значением,
эта опция игнорируется и длина не контролируется.
Значительно сложнее обстоит дело с передачей массивов произвольной
длины. Решить эту проблему при помощи не типизированных параметров
Процедурные типы
Процедурные типы - это нововведение фирмы Borland (в стандартном Паскале
таких типов нет). Основное назначение этих типов - дать программисту гибкие
средства передачи функций и процедур в качестве фактических параметров
обращения к другим процедурам и функциям.
Для объявления процедурного типа используется заголовок процедур, в
котором опускается ее имя, например:
type
Proc = Procedure (a, b, с : real; Var d : real);
Proc2 = Procedure (var a, b);
РгосЗ = Procedure;
В программе могут быть объявлены переменные процедурных типов, например,
так:
var
р1 : Proc;
ар : array [1..N] of Proc2;
Переменным процедурных типов допускается присваивать в качестве значений
имена соответствующих подпрограмм. После такого присваивания имя переменной
становится синонимом имени подпрограммы.
В отличие от стандартного Паскаля, в Турбо Паскале разрешается
использовать в передаваемой процедуре как параметры-значения, так и
параметры-переменные.
Нетипизированные параметры-переменные
Еще одно и очень полезное нововведение фирмы Borland - возможность
использования нетипизированных параметров. Параметр считается
нетипизированным, если тип формального параметра-переменной в заголовке
подпрограммы не указан, при этом соответствующий ему фактический параметр
может быть переменной любого типа. Заметим, нетипизированными могут быть
только параметры-переменные.
Нетипизированные параметры обычно используются в случае, когда тип
данных несущественен. Такие ситуации чаще всего возникают разного рода
копированиях одной области памяти в другую. Нетипизированные параметры
очень удобно использовать для передачи подпрограмме одномерных массивов
переменной длины.
Параметры- сложные типы данных
Рассмотрены прежде категории параметров не исчерпывают всех вопросов
передачи информации в Pascal-e. Использование в качестве параметров сложных
типов данных имеет свои особенности.
Рассмотрим массивы и строки открытого типа. Открытый массив (строка) –
массив (строка) без указания типа индекса (размера массива(строки)).
Пример:
Procedure getfive(var massiv: array of real);
В данном случае вместо формального параметра может использоваться любой
массив с элементами типа real. Индексация элементов открытого массива
всегда начинается с нуля. Такие массивы введены для того, чтобы
подпрограмма могла обрабатывать массивы любого размера.
Программа вычисления x=(m!+n!)/(m+n)!, где m, n целые (неотрицательные)
program factorial_(input,output); {название программы}
label 0; {описываем метку}
var
rez:real;
m,n:longint; {описали глобальные переменные, используемые в программе}
function fact(z: longint): real; {заголовок функции с формальным параметром-
значением, типом}
var
y: real; {описали локальную переменную}
begin
y:=1; {для получения результата необходимо присвоить у значение 1. также
при помощи этого реализуется вычисление 0! и 1!}
while z>1 do {запускаем цикл в обратную сторону, для упрощения опустим
множитель 1}
begin
y:=y*z;
z:=z-1
end;
fact:=y{вычисляем факториал, присваиваем его значение функции}
end; {конец функции}
begin{начало тела программы}
writeln('введите неотрицательные числа'); {для удобства пользователя просим
ввести числа}
0:readln(m,n); {в память вводятся числа}
if m or n <0 then begin
writeln(‘вы ошиблись, вводите неотрицательные числа’);
goto 0 {при ошибке пользователя предотвращаем выдачу неверного результата}
end;
rez:=(fact(m)+fact(n))/fact(m+n); {вычисляется значение данного выражения}
writeln('результат: ',rez) {выводим на экран результаты счета}
end.
Исходные данные и результаты счета:
m=0, n=0, x=2.0000000000E+00 (2)
m=3, n=5, x=3.1250000000E-03 (0,003125)
m=7, n=-3, вы ошиблись, вводите неотрицательные числа
Пояснительная записка
Теперь поясним нашу программу. program factorial_(input,output) – с этим
затруднений не возникает, factorial – имя программы, input-файл, откуда
происходит считывание данных, output-файл, куда происходит вывод данных. В
нашем случае (input,output) показывает, что программа требует ввода данных
и производит их вывод.
Label 0; описываем метку, которая нам пригодиться позже
var
rez:real;
m,n:longint; - описываем глобальные переменные.
function fact(z: longint): real; объявляем функцию, даем ей имя fl,
указываем формальные параметры. В данном случае это параметр-значение z.
var
y: real; описываем локальную переменную, т.е. она будет использоваться
только в теле функции. Real использован потому, что уже 13! Выходит за
рамки longint
begin
y:=1; необходимо присвоить переменной значение, равное единице, по крайней
мере по двум причинам:
1) при умножении числа на 1 получается это же число, поэтому при у=1
исключены ошибки в начале вычисления факториала.
2) известно, что 0!=1, поэтому при m или n = 0 цикл не запускается, а
значение 0! Оказывается равным 1.
while z>1 do запускаем цикл в обратную сторону, т. к. результат получается
один и тот же, но при этом не приходится описывать дополнительную локальную
переменную для запуска цикла с параметром. 1 исключаем из вычисления
факториала по вышеуказанным причинам.
begin
y:=y*z;
z:=z-1
end;
fact:=y этим оператором присваиваем функции значение факториала.
Точку с запятой перед end можно не ставить.
end; конец функции
begin начало тела программы
writeln('введите неотрицательные числа'); данный оператор выводит на экран
текст, заключенный между ‘’, помогает понять, чего же требует программа.
0:readln(m,n); при помощи этого оператора ввода информации исходные данные
заносятся в ячейки памяти.
if m or n <0 then begin writeln(‘вы ошиблись, вводите неотрицательные
числа’);
goto 0
end; если пользователь все же ввел отрицательные числа, то программа выдаст
неверный результат, данная последовательность операторов выводит на экран
сообщение об ошибке пользователя и возвращает к вводу чисел
rez:=(fact(m)+fact(n))/fact(m+n); вычисляем значение (m!+n!)/(m+n)!
writeln('результат: ',rez) данный оператор вывода информации выводит на
экран вычисленное значение.
end. конец программы
Приведем для пущей надежности еще несколько результатов счета
M=2 N=8 X=1.1111662257Е-02
M=4 N=4 X=1.1904761905Е-03
M=0 N=3 X=1.1666666667Е+00
M=3 N=15 X=2.0424836601Е-04
ЗАКЛЮЧЕНИЕ
Система программирования Турбо Паскаль содержит мощный инструмент
разработки программ – подпрограммы. В данной курсовой приведены синтаксис
процедур, виды и назначение параметров. Как мы увидели, программа
вычисления факториала с использованием функции гораздо более компактна, чем
та же программа без процедур-функций. Использование процедур-функций отнюдь
не является дурным тоном в программировании, поэтому каждый изучающий язык
программирования Паскаль должен обязательно иметь представление о
процедурах-функциях и уметь ими пользоваться.
Литература
А. Масюков. Краткий конспект лекций по информатике.
Интерактивный учебник Turbo Pascal 7.0
С. А. Абрамов. Начала программирования на языке паскаль
Приложение
ASSEMBLER - эта директива отменяет стандартную последовательность
машинных инструкций, вырабатываемых при входе в процедуру и перед выходом
из нее.
EXTERNAL - с помощью этой директивы объявляется внешняя подпрограмма.
FAR - компилятор должен создавать код подпрограммы, рассчитанный на дальнюю
модель вызова. Директива NEAR заставит компилятор создать код, рассчитанный
на ближнюю модель памяти. По умолчанию все стандартные подпрограммы
генерируются с расчетом на дальнюю модель вызова, а все остальные
подпрограммы - на ближнюю модель.
В соответствии с архитектурой микропроцессора ПК, в программах могут
использоваться две модели памяти: ближняя и дальняя. Модель памяти
определяет возможность вызова процедуры из различных частей программы: если
используется ближняя модель, вызов возможен только в пределах 64 Кбайт (в
пределах одного сегмента кода, который выделяется основной программе и
каждому используемому в ней модулю); при дальней модели вызов возможен из
любого сегмента. Ближняя модель экономит один байт и несколько микросекунд
на каждом вызове подпрограммы, поэтому стандартный режим компиляции
предполагает эту модель памяти. Однако при передаче процедурных параметров
соответствующие подпрограммы должны компилироваться с расчетом на
универсальную - дальнюю модель памяти, одинаково пригодную при любом
расположении процедуры и вызывающей ее программы в памяти.
Явное объявление модели памяти стандартными директивами имеет более
высокий приоритет по сравнению с настройкой среды.
FORWARD - используется при опережающем описании для сообщения компилятору,
что описание подпрограммы следует где-то дальше по тексту программы (но в
пределах текущего программного модуля).
INLINE - указывает на то, что тело подпрограммы реализуется с помощью
встроенных машинных инструкций.
INTERRUPT - используется при создании процедур обработки прерываний
опережающее описание:
Procedure В (j : byte);
forward;
Procedure A (i : byte);
begin
B(i);
End;
Procedure B;
Begin
…………….
A(j);
End;
Как видим, опережающее описание заключается в том, что
объявляется лишь заголовок процедуры В, а ее тело заменяется стандартной
директивой FORWARD. Теперь в процедуре А можно использовать обращение к
процедуре В - ведь она уже описана, точнее, известны ее формальные
параметры, и компилятор может правильным образом организовать ее вызов.
Обратите внимание: тело процедуры В начинается заголовком, в котором уже не
указываются описанные ранее формальные параметры.
Модуль – самостоятельная программная единица, ресурсы которой могут быть
использованы другими программами (фактически та же самая программа, но с
другим типом - .tpu);
