[an error occurred while processing this directive]
<pre>

─PL63
─LS1
─SRP 47
─TM0
─HM2
─DH//-|P-//
─LM5
│..................................................................&lt;
                3.6 Процедуры и функции
        
     Процедуры&nbsp;&nbsp; представляют&nbsp;&nbsp; собой&nbsp; наиболее&nbsp; мощное&nbsp; средство
структурирования&nbsp; программ&nbsp; рассматриваемой&nbsp;  версии языка BASIC.
Можно&nbsp; сказать,&nbsp; что&nbsp; данное&nbsp;&nbsp; средство&nbsp;&nbsp; приближает&nbsp;&nbsp; BASIC&nbsp;&nbsp; по
предоставляемым возможностям к такому&nbsp; мощному языку структурного
программирования, как PASCAL, сохраняя при&nbsp; этом&nbsp; его&nbsp; простоту и
наглядность.&nbsp; Считается,&nbsp; что&nbsp; данная версия языка BASIC является
практически&nbsp; первой&nbsp; в&nbsp; мире,&nbsp;&nbsp; которая&nbsp;&nbsp; предоставляет&nbsp; механизм
процедур&nbsp; и&nbsp; процедур-функций.&nbsp; Что&nbsp;&nbsp; же&nbsp;&nbsp; такое&nbsp; процедура?&nbsp; Это
произвольная последовательность операторов языка&nbsp; BASIC,&nbsp; которая
может&nbsp; быть&nbsp; вызвана&nbsp; по&nbsp; имени&nbsp; в&nbsp; любом месте программы. Обычно
совокупность&nbsp; операторов,&nbsp; оформленная в виде процедуры выполняет
некоторую самостоятельную логическую функцию (решает подзадачу) в
рамках определенной программы (задачи).
     В&nbsp; рамках данного пособия у&nbsp; нас&nbsp; нет&nbsp; возможности&nbsp; подробно
остановиться на&nbsp; принципах&nbsp; модульности&nbsp; и&nbsp; методах&nbsp; структурного
программирования,&nbsp;&nbsp; базирующихся&nbsp;&nbsp; на&nbsp;&nbsp; понятии&nbsp;&nbsp; процедуры&nbsp;&nbsp; или
подпрограммы (применительно, например, к языку FORTRAN). Желающих
ознакомиться&nbsp;&nbsp; более&nbsp; детально&nbsp; с&nbsp; этими&nbsp; вопросами,&nbsp; отсылаем&nbsp; к
фундаментальной&nbsp; учебной&nbsp;  литературе. Мы&nbsp; же&nbsp; сейчас остановимся
подробнее на общей организации программы и&nbsp; методических&nbsp; основах
использования&nbsp; процедур&nbsp; и&nbsp; процедур-функций с точки зрения языка
BASIC. 
     Применительно&nbsp;&nbsp; к&nbsp;&nbsp; понятиям&nbsp;&nbsp; процедур&nbsp;&nbsp; и&nbsp; прцедур-функций
существуют две языковые категории это определение (или описание )
и&nbsp;&nbsp; обращение&nbsp;&nbsp; (или&nbsp; вызов).&nbsp; В&nbsp; целом,&nbsp; программа&nbsp; использующая
процедуры&nbsp; и&nbsp; (или)&nbsp; процедуры-функции делится на две секции: 1 -
выполняемая часть (головная программа)&nbsp; заканчивается&nbsp; операторам
END; 2 - описание процедур и процедур-функций.  Желательно, чтобы
первая секция в исходном тексте программы предшествовала второй.
     Отметим,&nbsp; что&nbsp; все&nbsp; инструкции языка&nbsp; BASIC,&nbsp; относящиеся&nbsp; к
первой&nbsp; секции,&nbsp; выполняются&nbsp; как&nbsp;&nbsp; обычно,&nbsp; и&nbsp; среди&nbsp; них&nbsp; могут
содержаться обращения по именам&nbsp; к процедурам и (или) процедурам-
функциям.&nbsp; Эти обращения не вызывают&nbsp; переходов&nbsp; в&nbsp; программе&nbsp; из
первой секции&nbsp; во&nbsp; вторую&nbsp; (в&nbsp; отличие от операторов GOSUB, ON...
GOSUB) с возвратом. Правильнее будет считать, что такие обращения
вызывают&nbsp;&nbsp;&nbsp; выполнение&nbsp;&nbsp;&nbsp; другой&nbsp;&nbsp;&nbsp; программы&nbsp;&nbsp;&nbsp; (процедуры&nbsp;&nbsp; или
процедуры-функций),&nbsp; исходный&nbsp; текст которой содержится во второй
секции. При этом&nbsp; такая&nbsp; самостоятельная программа использует три
вида&nbsp; переменных&nbsp; (допускаются&nbsp; все&nbsp; типы&nbsp;&nbsp; данных):&nbsp;&nbsp; переменные
вызывающей&nbsp;&nbsp; программы&nbsp;&nbsp; (глобальные&nbsp;&nbsp; переменные);&nbsp;&nbsp; собственные
переменные,&nbsp;&nbsp;&nbsp; определенные&nbsp;&nbsp;&nbsp; только&nbsp;&nbsp;&nbsp; внутри&nbsp;&nbsp; процедуры&nbsp;&nbsp; или
процедуры-функции&nbsp;&nbsp; (локальные);&nbsp;&nbsp; переменные,&nbsp; значения&nbsp; которых
передаются из вызывающей программы при вызове.
     Для&nbsp; описания&nbsp; процедуры&nbsp; или процедуры-функции используется
специальный&nbsp; оператор DEF (от&nbsp; слова&nbsp; define&nbsp; -&nbsp; определять).&nbsp; Он
является первым оператором описания и имеет формат

                     DEF &lt;имя&gt;(список параметров),

где имя - идентификотор процедуры, начинающийся с корня&nbsp; PROC или
функции,&nbsp; начинающийся с корня FN;&nbsp; список&nbsp; параметров&nbsp; -&nbsp; список
произвольных&nbsp; имен&nbsp; переменных,&nbsp; рассматриваемых&nbsp; как&nbsp; формальные
параметры.
     Оператор DEF имеет смысл заголовка&nbsp; описания&nbsp; процедуры&nbsp; или
процедуры-функции,&nbsp;&nbsp; его&nbsp;&nbsp; действие&nbsp;&nbsp; заключается:&nbsp; во-первых,&nbsp; в
присвоении&nbsp; имени&nbsp; (начинающегося&nbsp; соответственно&nbsp; с PROC или FN)
следующей&nbsp; за&nbsp; ним&nbsp; последовательности&nbsp; инструкций&nbsp; языка&nbsp; BASIC,
выполнение которых будет осуществляться при&nbsp; вызове. Во-вторых, в
заголовке&nbsp; описания&nbsp; указывается&nbsp; список&nbsp; формальных&nbsp; параметров.
Имена&nbsp; переменных&nbsp; в&nbsp; этом списке служат лишь для обозначения тех
переменных&nbsp;&nbsp;  с&nbsp;&nbsp; которыми&nbsp;&nbsp; будут&nbsp;&nbsp;&nbsp; действительно&nbsp;&nbsp; выполняться
нижеследующие&nbsp;&nbsp; инструкции&nbsp;&nbsp; при&nbsp; обращении&nbsp;&nbsp; к&nbsp;&nbsp; процедуре&nbsp;&nbsp; или
прцедуре-функции. Имена формальных параметров&nbsp; никак не связаны с
именами фактических, так как они&nbsp; относятся&nbsp; к&nbsp; разным программам
(мы&nbsp; отмечали,&nbsp; что&nbsp; процедура&nbsp; или процедура-функция являются по
существу самостоятельными программами).
        Примеры имен процедур:
        PROCBOX, PROCDiana, PROCexample1 и т.д.

        Примеры имен процедур-функций:
        FNSUM, FNMean, FNexample1 и т.д.

        Примеры заголовков:
        DEF PROCNUM (X,Y,Z)
        DEF FNSwitch (NAME&curren;, Length%)

     Последовательность&nbsp; инструкций&nbsp; языка&nbsp; BASIC,&nbsp; следующая&nbsp; за
заголовком&nbsp; процедуры,&nbsp; носит&nbsp; название тела процедуры. Последним
оператором тела должен являтся&nbsp; специальный&nbsp; оператор&nbsp; ENDPROC&nbsp; -
конец описания. В теле могут использоваться не только переменные,
передаваемые&nbsp; через&nbsp; параметры,&nbsp; но&nbsp; и другие переменные, которые
подразделяются&nbsp; на&nbsp; локальные&nbsp; и&nbsp; глобальные.&nbsp; Локальные&nbsp; это&nbsp; те
переменные, которые существуют (известны) только&nbsp; в процедуре или
процедуре-функции,&nbsp;&nbsp; их&nbsp;&nbsp; значения&nbsp;&nbsp; являются&nbsp;&nbsp; недоступными&nbsp; для
вызывающей&nbsp;&nbsp; программы.&nbsp;&nbsp; Имена&nbsp; таких&nbsp; переменных&nbsp; присваиваются
независимо&nbsp; от&nbsp; имен&nbsp; вызывающей программы и  других процедур или
процедур-функций (в часности, могут&nbsp; совпадать).&nbsp; В&nbsp; языке&nbsp; BASIC
имеется&nbsp; оператор&nbsp; LOCAL,&nbsp; который&nbsp; используется&nbsp; для&nbsp; обьявления
переменных&nbsp; локальными&nbsp; внутри&nbsp; процедуры&nbsp; или процедуры-функции.
Оператор&nbsp;&nbsp; LOCAL&nbsp;&nbsp; является&nbsp; чисто&nbsp; описательным&nbsp; (невыполняемым)
оператором&nbsp; и&nbsp; должен&nbsp; следовать&nbsp; непосредстаенно&nbsp; за заголовком.
Формат оператора 

                   LOCAL список имен переменных

не&nbsp; требует комментария. В одной&nbsp; процедуре&nbsp; допускается&nbsp; наличие
нескольких операторов LOCAL.
     Переменные&nbsp; процедуры&nbsp; или процедуры-функции, не обьявленные
локальными с помощью&nbsp; оператора LOCAL и не являющиеся формальными
параметрами,&nbsp; относятся к глобальным&nbsp; переменным,&nbsp; т.е.&nbsp; доступны
вызывающей&nbsp;&nbsp; программе.&nbsp;&nbsp; Это&nbsp;&nbsp; обстоятельство&nbsp;&nbsp; требует&nbsp;&nbsp; особой
осторожности при&nbsp; работе&nbsp; с&nbsp; глобальными&nbsp; переменными, так как их
значения&nbsp; могут&nbsp; модифицироваться внутри процедуры, что,&nbsp; в&nbsp; свою
очередь,&nbsp; даст&nbsp; "побочный&nbsp;&nbsp; эффект"&nbsp;&nbsp; при&nbsp; дальнейшем&nbsp; выполнении
вызывающей программы. Отметим&nbsp; также,&nbsp; что фактические параметры,
заменяющие&nbsp; формальные,&nbsp; при вызове процедур&nbsp; и&nbsp; процедур-функций
передаются в тело&nbsp; процедуры&nbsp; своими&nbsp; значениями,&nbsp; но не именами.
Иначе говоря, значения фактичских параметров поступают на&nbsp; вход и
не&nbsp;&nbsp; модифицируются&nbsp;&nbsp; в&nbsp;&nbsp; вызывающей&nbsp;&nbsp; программе.&nbsp; По&nbsp; завершению
выполнения&nbsp; процедуры&nbsp; или процедуры-функции значения переменных,
являющихся фактическими параметрами,&nbsp; останутся&nbsp; такими&nbsp; же как и
при&nbsp; вызове. В этом смысле фактические&nbsp; параметры&nbsp; можно&nbsp; считать
локальными переменными&nbsp; процедур&nbsp; и процедур-функций. Здесь также
наблюдается&nbsp;&nbsp; принципиальная&nbsp;&nbsp; разница&nbsp;&nbsp; между&nbsp;&nbsp;&nbsp; процедурой&nbsp;&nbsp;&nbsp; и
подпрограммой&nbsp; в&nbsp; языке&nbsp; FORTRAN.&nbsp;&nbsp; Процедура,&nbsp;&nbsp; в&nbsp;&nbsp; отличие&nbsp;&nbsp; от
подпрограммы,&nbsp; не&nbsp; может&nbsp; иметь&nbsp; выходных&nbsp; параметров,&nbsp; а&nbsp; только
входные.&nbsp; Модификация&nbsp; значений переменных&nbsp; вызывающей&nbsp; программы
осуществляется только через&nbsp; механизм&nbsp; глобальных&nbsp; переменных. Из
этого следует, что процедура представляет собой существенно менее
универсальное&nbsp; средство,&nbsp; чем&nbsp; подпрограмма в Фортране,&nbsp; так&nbsp; как
имеет связь (привязку) с вызывающей программой. 
     Наконец отметим, что независимо от порядка в котором следует
описание процедур и процедур-функций во&nbsp; второй&nbsp; секции программы
(после&nbsp; оператора  END)  допускается  взаимный, сколь  угодно раз
вложенный вызов.&nbsp; Кроме&nbsp; того&nbsp; допускается&nbsp; вызов&nbsp; процедурами&nbsp; и
функциями самих себя , т.е. рекурсия.
     Поскольку&nbsp;&nbsp; процедуры&nbsp;&nbsp; и&nbsp;&nbsp; процедуры-функции&nbsp;&nbsp; имеют&nbsp; кроме
изложенного&nbsp; общего&nbsp; также&nbsp; и существенные отличия, дальнейшее их
рассмотрение проведем раздельно.
     Процедуры.&nbsp;&nbsp; Итак,описание&nbsp; процедур&nbsp; содержится&nbsp; во&nbsp; второй
секции&nbsp; программы&nbsp; (после&nbsp; оператора END), начинается с заголовка
описания&nbsp; (оператор&nbsp; DEF),&nbsp; далее&nbsp;&nbsp; могут&nbsp; следовать&nbsp; определения
локальных&nbsp; переменных&nbsp; (оператор LOCAL),&nbsp; затем&nbsp; собственно&nbsp; тело
процедуры и, наконец,&nbsp; завершается&nbsp; описание&nbsp; оператором ENDPROC.
Обращение&nbsp;&nbsp; к&nbsp;&nbsp; процедуре&nbsp; (вызов)&nbsp; осуществляется&nbsp; в&nbsp; вызывающей
программе&nbsp; оператором,&nbsp; представляющим&nbsp; собой&nbsp; имя&nbsp; процедуры, за
которым в круглых скобках следует список&nbsp; фактических&nbsp; параметров
(если&nbsp; таковые&nbsp; имеются).&nbsp; Рассмотрим пример фрагмента программы,
использующего процедуру для вывода&nbsp; на экран горизонтальной линии
в&nbsp; виде&nbsp; последовательности&nbsp; символов&nbsp; подчеркивания&nbsp; в&nbsp; заданном
диапазоне позиций строки с N по M.

         5 MODE 0
        10 INPUT "Введите через запятую&nbsp; номера&nbsp; левой&nbsp; и&nbsp; правой
                  позиции строки" lev, prav
        20 PROCline (lev, prav)
        30 END
        40 DEF PROCline (N,M)
        50 LOCAL I
        60 PRINT TAB (N-1);
        70 FOR I=1 TO M-N+1
        80 PRINT "_";
        90 NEXT I
       100 PRINT
       110 ENDPROC.
                                                          
     В данном примере наличие формальных&nbsp; параметров&nbsp; N,M&nbsp; делает
процедуру&nbsp; достаточно универсальным средством, удобным, например,
при&nbsp; формировании&nbsp; таблиц&nbsp; на&nbsp; экране.&nbsp; Вторая&nbsp; секция&nbsp; программы
(строки 40-110) является примером описания&nbsp; процедуры. Переменная
I&nbsp; является&nbsp; управляющей переменной цикла и&nbsp; объявлена&nbsp; локальной
(строка 50). Это полезно сделать, так как в принципе, обращение к
процедуре может встречаться в различных местах большой программы,
в&nbsp; которых переменная I  также&nbsp; используется.&nbsp; Наличие&nbsp; оператора
LOCAL как&nbsp; бы защищает внешние по отношению к PROCLine переменные
I от модификации внутри процедуры.
     Процедуры-функции.&nbsp;&nbsp;  Если&nbsp;&nbsp; процедуры&nbsp;&nbsp; предназначены&nbsp;&nbsp; для
именования&nbsp;&nbsp; и&nbsp; выполнения&nbsp; при&nbsp; обращении&nbsp; некоторой&nbsp; "логически
замкнутой"&nbsp; последовательности&nbsp; операторов&nbsp; языка&nbsp; Бейсик в самом
общем&nbsp; смысле,&nbsp; то&nbsp; процедуры-функции&nbsp; решают&nbsp; частную&nbsp; задачу&nbsp; -
сформировать выходное значение - как&nbsp; функцию задаваемых значений
аргументов&nbsp; (фактических&nbsp; параметров) по алгоритму, записанному в
виде тела процедуры&nbsp; с помощью формальных параметров. По принципу
обращения&nbsp;&nbsp; (вызова)&nbsp;&nbsp; процедуры-функции&nbsp;&nbsp; полностью&nbsp;&nbsp; аналогичны
встроенным&nbsp; функциям&nbsp; языка&nbsp; Бейсик&nbsp; т.е.&nbsp; используются также как
переменные&nbsp; вызывающей&nbsp; программы.&nbsp; Формируемое&nbsp; значение функции
присваивается&nbsp; непосредственно&nbsp; ее&nbsp; имени в&nbsp; последнем&nbsp; операторе
описания процедуры-функции. Он имеет&nbsp; вид&nbsp; оператора присваивания
без левой части
                    =выражение,

где&nbsp; выражение&nbsp; -&nbsp; произвольное&nbsp; арифметическое,&nbsp; логическое&nbsp; или
строковое&nbsp; выражение.&nbsp; Результат&nbsp; выражения&nbsp; присваивается&nbsp; имени
функции.
     Простейший пример фрагмента программы для&nbsp; нахождения&nbsp; суммы
произвольных трех чисел с использованием процедуры-функции

           5 MODE
          10 INPUT "Ввидите через запятую три
                    числа "А,В,С
          20 PRINT "Сумма равна"; FNSUM(A,B,C)
          30 END
          40 DEF FNSUM(X,Y,Z)
          50 = X+Y+Z

     Обращение&nbsp; к&nbsp; процедуре-функции делается в&nbsp; операторе&nbsp; PRINT
(строка&nbsp; 20&nbsp; головной&nbsp;&nbsp; программы),&nbsp; как&nbsp; к&nbsp; обычной&nbsp; переменной,
содержащей в качестве значения искомую сумму.
     Отметим&nbsp; еще&nbsp; раз,&nbsp; что&nbsp; описание&nbsp; (тело)&nbsp; процедуры-функции
заканчивается&nbsp; не&nbsp; специальным оператором (типа&nbsp; ENDPROC,&nbsp; как&nbsp; в
случае процедуры), а обычным оператором&nbsp; присваивания, только без
левой&nbsp;&nbsp; части.&nbsp;&nbsp; Именно&nbsp;&nbsp; этот&nbsp;&nbsp; оператор&nbsp;&nbsp; определяет&nbsp;&nbsp; значение
процедуры-функции, присваиваемое ее имени.
     Процедуры-функции&nbsp; позволяют&nbsp; неограниченно&nbsp; расширять набор
встроенных функций языка Бейсик в пользовательских программах.


             3.7     Работа с файлами

             3.7.1   Организация файлов

     Будем&nbsp; исходить&nbsp; из&nbsp; того,что&nbsp; читатель&nbsp; знаком&nbsp; с&nbsp; понятием
"файл",&nbsp; поэтому&nbsp; не&nbsp; приводим&nbsp; здесь&nbsp;&nbsp; одно&nbsp;&nbsp; из&nbsp; многочисленных
существующих&nbsp; определений.&nbsp; Отметим, что средства&nbsp; для&nbsp; работы&nbsp; с
файлами языка Бейсик&nbsp; предоставляют&nbsp; возможности&nbsp; ввода&nbsp; данных в
программу&nbsp; с&nbsp; магнитных носителей (операция чтения из&nbsp; файла),&nbsp; а
также вывода информации&nbsp; на&nbsp; устройства&nbsp; внешней памяти (операция
записи&nbsp; в&nbsp; файл).&nbsp; Мы будем рассматривать&nbsp; файлы,&nbsp; соостоящие&nbsp; из
записей, которые в свою&nbsp; очередь&nbsp; содержат&nbsp; данные,&nbsp; т.е. числа и
(или) символьные строки.
     В&nbsp; качестве магнитных носителей информации&nbsp; для&nbsp; организации
ввода-вывода&nbsp;&nbsp; данных&nbsp;&nbsp;&nbsp; в&nbsp;&nbsp;&nbsp; программах&nbsp;&nbsp;&nbsp; на&nbsp;&nbsp;&nbsp; Бейсике&nbsp;&nbsp; могут
выступать-кассета с&nbsp; магнитной&nbsp; лентой, гибкий диск (или флоппи),
диск&nbsp; типа&nbsp; "винчестер".&nbsp; Каждому&nbsp;&nbsp; из&nbsp;&nbsp; перечисленных&nbsp; носителей
соответствуют&nbsp; различные устройства записи-чтения&nbsp; информации,&nbsp; а
значит различные&nbsp; системы&nbsp; доступа&nbsp; к файлам и содержащимся в них
записям.&nbsp; Однако,&nbsp; нижерассматриваемые средства языка&nbsp; Бейсик&nbsp; не
зависят от типа&nbsp; устройства&nbsp; внешней&nbsp; памяти,&nbsp; поэтому программы,
использующие&nbsp;&nbsp; эти&nbsp;&nbsp; средства,&nbsp;&nbsp; не&nbsp;&nbsp; должны&nbsp; модифицироваться&nbsp; в
зависимости от используемого носителя информации.


               3.7.2  Открытие файлов

    Операция&nbsp; открытия&nbsp; файла предшествует непосредственно обмену
информацией между оперативной&nbsp; и&nbsp; внешней памятью ПЭВМ. Суть этой
операции можно условно рассматривать, как установление некоторого
канала&nbsp; связи,&nbsp; по&nbsp; которому&nbsp; будет&nbsp;&nbsp; осуществляться&nbsp;&nbsp; собственно
передача&nbsp; информации.&nbsp; Для работы с&nbsp; каждым&nbsp; файлом&nbsp; в&nbsp; программе
должен быть открыт отдельный канал связи.
    В языке Бейсик имеются три&nbsp; оператора&nbsp; открытия файла-OPENIN,
OPENOUT, OPENUP. Все они имеют одинаковый синтаксис

                числ. пер.=оператор ("имя ф."),

 где числ.пер. - произвольная&nbsp;&nbsp; числовая&nbsp;&nbsp; (целочисленная&nbsp; или
                 вещественная) переменная;
     оператор - один из трех указанных операторов открытия файла;
     имя файла- имя открываемого файла (см.п.6).
      Например,
               X=OPENIN ("FILENAME").
    Числовая&nbsp; переменная&nbsp; в&nbsp; левой&nbsp; части&nbsp;&nbsp; получает&nbsp; в&nbsp; качестве
значения номер канала связи для&nbsp; обмена информацией с указанным в
правой&nbsp; части&nbsp; файлом данных. Наличие трех&nbsp; различных&nbsp; операторов
открытия файла позволяет&nbsp; конкретизировать операции ввода-вывода,
которые&nbsp;&nbsp; в&nbsp;&nbsp; дальнейшем&nbsp; будут&nbsp;&nbsp; производиться,&nbsp;&nbsp; или&nbsp;&nbsp; наделить
открываемый&nbsp;&nbsp; канал&nbsp; связи&nbsp; определенными&nbsp; логическими&nbsp; функциями  
соответственно особенности каждого из операторов открытия файла.


    OPENIN.&nbsp;&nbsp; Открывает&nbsp;&nbsp; файл&nbsp;&nbsp; только&nbsp; для&nbsp;&nbsp; чтения.&nbsp;&nbsp; Оператор
предназначен для открытия существующего файла данных, из которого
предусматривается&nbsp; ввод&nbsp; информации&nbsp; в программу.&nbsp; Запись&nbsp; (вывод
информации) в файл, открытый&nbsp; оператором OPENIN, запрещена. Таким
образом,&nbsp; оператор&nbsp; OPENIN&nbsp; обеспечивает&nbsp; защиту&nbsp;&nbsp; информации&nbsp;&nbsp; в
открываемом файле от модификации или дополнительной записи.


    OPENOUT. Открывает новый (несуществующий) на&nbsp; момент открытия
файл&nbsp; только&nbsp; для&nbsp; записи&nbsp; (вывода&nbsp; информации).&nbsp; Ввод&nbsp; данных&nbsp; в
программу&nbsp; из&nbsp; файла,&nbsp; открытого&nbsp; оператором OPENOUT, невозможен.
Если в поле оператора указано имя некоторого существующего файла,
то то он будет перезаписан,&nbsp; т.е.&nbsp; создается&nbsp; новый&nbsp; файл&nbsp; вместо
существующего.


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


               3.7.3   Операторы ввода-вывода

    Аналогично&nbsp; операторам ввода-вывода  на терминал&nbsp; -&nbsp; INPUT&nbsp; и
PRINT, в&nbsp; Бейсике&nbsp; имеются&nbsp; соответствующие&nbsp; операторы для обмена
информацией&nbsp;&nbsp; с&nbsp;&nbsp; файлом&nbsp; на&nbsp; устройстве&nbsp; внешней&nbsp;&nbsp; памяти.&nbsp;&nbsp; Это
соотвественно, операторы INPUT# и PRINT#. Еще раз подчеркнем, что
в&nbsp;&nbsp; программах&nbsp;&nbsp; на&nbsp;&nbsp; Бейсике&nbsp;&nbsp; использованию&nbsp; операторов&nbsp; обмена
обязательно&nbsp; должны&nbsp; предшествовать  операторы открытия некоторых
файлов. Формат оператора обмена следующий.

                  INPUT#N, список переменных.
                  PRINT#N, список переменных и констант,

     где N -произвольная числовая переменная&nbsp; (как привило та же,
что&nbsp; и в предшествующем операторе открытия&nbsp; файла),&nbsp; определяющая
установленный ПЭВМ номер канала связи с файлом.
     Список&nbsp; переменных&nbsp; представляет&nbsp; собой&nbsp; перечисление&nbsp; через
запятую&nbsp; идентификаторов переменных&nbsp; программы, которым присвоены
значения при чтении из файла (оператор INPUT#) и значения которых
будут&nbsp;&nbsp; записываться&nbsp; в&nbsp; файл&nbsp;&nbsp; (оператор&nbsp;&nbsp; PRINT#).&nbsp;&nbsp; В&nbsp;&nbsp; списке
могут, естественно, содержаться переменные всех допустимых&nbsp; типов
данных,&nbsp; а&nbsp; в операторе PRINT# в список могут входить и константы
всех типов, которые&nbsp; будут&nbsp; непосредственно&nbsp; записываться в файл.
Каждый&nbsp; оператор&nbsp; PRINT#&nbsp; формирует&nbsp; в&nbsp; файле&nbsp; отдельную&nbsp; запись.
Примеры операторов:

           INPUT#channel, date, name&curren;, address&curren;
           PRINT#file, X,Y,Z,A&curren;,"Monday",33.
        

               3.7.4  Закрытие файла

     По&nbsp; завершении всех операций обмена&nbsp; информацией&nbsp; с&nbsp; файлами
необходимо выполнить&nbsp; еще&nbsp; одну специальную процедуру, называемую
закрытием файла. Смысл ее&nbsp; состоит&nbsp; в&nbsp; следующем: во-первых, ПЭВМ
ставится в известность, что закрепленный канал связи освободился,
и&nbsp; может&nbsp; быть&nbsp; использован для установления связи,&nbsp; например,&nbsp; с
другим&nbsp; файлом;&nbsp; во-вторых,&nbsp; физически&nbsp; завершаюся&nbsp; все&nbsp; операции
обмена&nbsp;&nbsp; между&nbsp; оперативной&nbsp; памятью&nbsp;&nbsp; и&nbsp;&nbsp; внешним&nbsp;&nbsp; устройством;
в-третьих, система управления файлами&nbsp; получает&nbsp; все&nbsp; необходимые
данные,&nbsp; обеспечивающие&nbsp; доступ&nbsp; к&nbsp; записям&nbsp; закрываемого&nbsp; файла.
Закрытие файла осуществляется оператором  CLOSE#, формат которого

                    CLOSE# числ.пер.,

     где&nbsp;&nbsp;&nbsp; числ.пер.-полностью&nbsp;&nbsp; соответствует&nbsp;&nbsp; (совпадает)&nbsp;&nbsp; с
параметром&nbsp; одного&nbsp; из&nbsp; используемых&nbsp; ранее&nbsp; операторов&nbsp; открытия
файла.
     Заметим,&nbsp; что своевременное использование оператора закрытия
CLOSE# также необходимо, как и предварительное открытие файлов. В
противном случае&nbsp; файл может оказаться "запорченным", т.е. доступ
к содержащимся  в нем записям будет потерян.
     Прежде,&nbsp; чем&nbsp; перейти&nbsp; к дальнейшему&nbsp; описанию&nbsp;  команд&nbsp; для
работы с файлами рассмотрим&nbsp; простейшие примеры. Предположим, что
мы хотим создать файл с&nbsp; именем&nbsp; GROUP,&nbsp; в&nbsp; котором будем хранить
список&nbsp;&nbsp; студентов&nbsp;&nbsp; некоторой&nbsp; группы.&nbsp; Фрагмент&nbsp; программы&nbsp; для
занесения в файл имеет вид:           

           10 INPUT "Число студентов?" N
           20 C=OPENOUT ("GROUP")
           30 FOR I=1 TO N
           40 INPUT "Фамилия студента?" FAM&curren;
           50 PRINT#C, FAM&curren;
           60 NEXT I
           70 CLOSE#C

    Оператор&nbsp; 20&nbsp; создает&nbsp; и открывает&nbsp; для&nbsp; вывода&nbsp; файл&nbsp; GROUP,
оператор&nbsp; 50&nbsp; осуществляет&nbsp; вывод&nbsp; очередной&nbsp; записи,&nbsp; содержащей
фамилию студента (переменной FAM&curren;)&nbsp; в&nbsp; этот файл, наконец опертор
70&nbsp;&nbsp; осуществляет&nbsp;&nbsp; закрытие&nbsp;&nbsp; сформированного&nbsp; файла.&nbsp; Следующий
фрагмент&nbsp; программы соответственно распечатывает на экране список
студентов, содержащийся в файле GROUP:

           10 INPUT "Число студентов?" N
           20 C=OPENIN ("GROUP")
           30 FOR I=1 TO N
           40 INPUT#C, FAM&curren;
           50 PRINT I, FAM&curren;
           60 NEXT I
           70 CLOSE#C

     Заметим,что если в первом фрагменте&nbsp; ввод&nbsp; числа студентов N
представляется достаточно  естественным  (при  создании списка ),
то&nbsp; во&nbsp; втором&nbsp; он выглядит&nbsp; вынужденным,&nbsp; так&nbsp; как&nbsp; пользователь
программы не обязательно должен его знать. Другими словами, часто
при работе с файлами&nbsp; возникает&nbsp; задача&nbsp; прочитать&nbsp; весь файл, не
зная общее количество содержащихся в нем записей.
      В&nbsp; Бейсике существует специальная функция&nbsp;  EOF#&nbsp; -&nbsp; (конец
файла -&nbsp; End&nbsp; of&nbsp; File),&nbsp; которая&nbsp; проверяет&nbsp; есть ли в файле еще
записи, или уже достигнут конец файла. Формат

           EOF#(числ.пер.),

     где&nbsp; числ.пер.-переменная, содержащая номер канала&nbsp; связи&nbsp; с
открытым файлом. 
     Функция EOF# принимает логическое значение "истина", когда в
результате очередного ввода информациии будет прочитана последняя
запись (конец файла). Таким образом&nbsp; EOF#&nbsp; можно использовать для
проверки&nbsp;&nbsp; достижения&nbsp;&nbsp; конца&nbsp;&nbsp; файла.&nbsp; Так&nbsp; предыдущий&nbsp; фрагмент
распечатки&nbsp; списка&nbsp; может&nbsp; быть модифицирован с учетом отсутствия
необходимости  указания числа студентов следующим образом:

           10 C=OPENIN ("GROUP")
           20 I=1
           30 REPEAT
           40 INPUT C#,FAM&curren;
           50 PRINT I, FAM&curren;
           60 I=I+1
           70 UNTIL EOF#(C)
           80 CLOSE#C

     Условием окончания цикла (строки 20-70)&nbsp; является логическое
значение "истина", возвращенное функцией EOF#(C), т.е. считывание
_оследней записи файла "GROUP". 


          3.7.5. Организация файлов прямого доступа

    Выражение&nbsp; PTR#&nbsp; (Pointer)&nbsp; - указывает&nbsp; текущее&nbsp; место&nbsp; (или
точку) в файле при&nbsp; выполнении&nbsp; очередной&nbsp; операции ввода-вывода,
которое определяется в байтах от начала файла.
    Формат
           числ.пер.1=PTR#числ.пер.2               (1)      или
           PTR#числ.пер2=числ.пер.1.               (2)

     где&nbsp;&nbsp; числ.пер.1-соответственно&nbsp; получаемое&nbsp; или&nbsp; присваемое
                      значение указателя места в файле;
           числ.пер.2-определяет канал связи для открытого файла.
     Выражение PTR# позволяет в случае&nbsp; формата (1) определить из
какого&nbsp;&nbsp;&nbsp; места&nbsp;&nbsp;&nbsp; файла&nbsp;&nbsp;&nbsp; осуществляется&nbsp;&nbsp; очередная&nbsp;&nbsp; операция
чтения-записи,&nbsp; а&nbsp; в случае формата (2) указать конкретно место в
файле&nbsp;&nbsp; для&nbsp; выполнения&nbsp;&nbsp; соответствующих&nbsp;&nbsp; операций.&nbsp;&nbsp; Последнее
позволяет практически работать с файлами прямого доступа.
     Рассмотрим предыдущий пример, в котором сделаем для простоты
изменения,&nbsp; организовав&nbsp; файл&nbsp; с&nbsp; записями&nbsp; фиксированной&nbsp; длины.
Следующие&nbsp; два&nbsp; фрагмента&nbsp; иллюстрируют&nbsp; соответственно&nbsp; создание
файла с длинной записи в 20 байт  для занесения фамилий студентов
и&nbsp;&nbsp; выборочную&nbsp; распечатку&nbsp; на&nbsp; экране&nbsp; произвольных&nbsp; записей&nbsp; по
указываемому номеру.
    Первый&nbsp; фрагмент&nbsp; (создание&nbsp; файла с&nbsp; записями&nbsp; фиксированной
длины):
             10 C=OPENOUT ("GROUP")
             20 I=0
             30 REPEAT
             40 INPUT "Фамилия студента?" FAM&curren;
             50 IF FAM&curren;="" THEN GO TO 100
             60 PTR#C=20*I
             70 PRINT#C, FAM&curren;
             80 I=I+1
             90 UNTIL FALSE
            100 CLOSE#C

    Очевидно, что выражение PTR#C (сторока&nbsp; 70) управляет базовым
адресом заносимых записей в строке 80&nbsp; относительно начала файла,
каждый раз увеличивая его на 20.
    Теперь&nbsp; фрагмент&nbsp; вывода&nbsp; на&nbsp; экран&nbsp;&nbsp; записей&nbsp;&nbsp; с&nbsp; конкретным
порядковым номером:

             10 C=OPENIN ("GROUP")
             20 INPUT "Номер студента в списке"N
             30 PTR#C=20*(N-1)
             40 INPUT#C, FAM&curren;
             50 PRINT N, FAM&curren;
             60 INPUT "Будете еще делать запрос? (да/нет)?"К&curren;
             70 IF К&curren;="Да" THEN GO TO 20
             80 CLOSE#C

    В&nbsp; целом, использование выражение PTR#&nbsp; позволяет&nbsp; обеспечить
прямой доступ к произвольным записям файла с целью их извлечения,
модификации и т.д. Для модификации файла с записями фиксированной
длины&nbsp; бывает&nbsp; полезно получить информацию&nbsp; об&nbsp; общем&nbsp; количестве
записей&nbsp; в&nbsp; некотором текущем состоянии.&nbsp; В&nbsp; общем&nbsp; случае&nbsp; часто
необходимым оказывается  знать общий размер файла данных. 
    Выражение&nbsp; EXT#(EXTend)-преназначено&nbsp; для&nbsp; определения общего
размера открытого файла в байтах.
    Формат
                числ.пер.1=EXT#(числ.пер.2),

    где&nbsp; числ.пер. 1, числ.пер.2-имеют тот&nbsp; же&nbsp; смюсл,&nbsp; что&nbsp; и&nbsp; в
выражении PTR#.
    В часности, для файла с&nbsp; записями&nbsp; фиксированной длины, общее
количество записей определяется оператором 
             N=EXT#(C)/L,
      где N-общее количество записей;
          С-номер канала связи с открытым файлом,
          L-длина записи.


                3.7.6&nbsp;  Побайтные операции ввода-вывода с файлами
                        данных. Операторы BGET# и BPUT#

     Для некоторых специальных приложений в&nbsp; языке Бейсик имеются
средства записи в файл (чтения из файла) кодов отдельных символов
(байтов). Оператор BGET# (get a byte&nbsp; from&nbsp; file) предназназначен
для чтения из файла, а BPUT# (put a&nbsp; byte to life)-записи в файл.
Формат оператора BPUT#:

              BPUT# числ.пер.1,числ.пер.2,

     где числ.пер.1-номер канала связи с файлом, 
         числ.пер.2-переменная,&nbsp; число&nbsp; или&nbsp; выражение&nbsp; лежащие в
         диапазоне&nbsp; 0-255, т.е. размещаемые  в одном байте&nbsp;опера-
         тивной памяти.
      Например, BPUT#N, 32 или BPUT#A, Х MOD 256.
      Формат оператора BGET#:

              числ.пер.2=BGET#числ.пер.1.

     Байт, читаемый из файла с&nbsp; номером канала связи "числ.пер.1"
присваивается числовой переменной программы "числ.пер.2."
памяти.
</pre>
[an error occurred while processing this directive]