Понятие программного продукта

Все программы по характеру использования и категориям пользователей можно разделить на два класса - утилитарные программы (УП) и программные продукты (изделия) (ПП). УП предназначены для удовлетворения нужд их разработчиков. Чаще всего УП выполняют роль сервиса в технологии обработки данных либо являются программами решения функциональных задач, не предназначенных для широкого распространения. ПП предназначены для удовлетворения потребностей пользователей, широкого распространения и продажи.

В настоящее время существуют и другие варианты легального распространения ПП, которые появились с использованием глобальных или региональных телекоммуникаций: freeware – бесплатные программы, свободно распространяемые, поддерживаются са­мим пользователем, который правомочен вносить в них необходимые изменения; shareware – некоммерческие (условно-бесплатные) программы, которые могут определённое время ис­пользоваться бесплатно. При условии регулярного использования осуществляется взнос определённой суммы.

ПП должен быть подготовлен к экс­плуатации, иметь необходимую техническую документацию, предоставлять сервис и гаран­тию надежной работы программы, иметь товарный знак изготовителя, а также желательно наличие кода государственной регистрации. Только при таких условиях созданный прог­раммный комплекс может быть назван ПП. Таким образом, ПП – комплекс взаимосвязанных программ для ре­шения определенной проблемы (задачи) массового спроса, подготовлен­ный к реализации как любой вид промышленной продукции.

Качество программных продуктов (ПП) определяется следующими характеристиками:

1) Мобильность означает независимость ПП от технического комплекса системы обработки данных, операционной среды, технологии обработки данных и т.п.

2) Надёжность определяется бессбойностью и ус­тойчивостью в работе программ, точностью выполнения предписанных функций обработки, возможностью диагностики возникающих в процессе работы программ ошибок.

3) Эффективность оценивается как с позиций требований пользователя, так и с точки зрения расхода вычислительных ресурсов, необходимых для эксплуатации ПП (объем внешней памяти для размещения программ и объем оперативной памяти для запуска программ).

4) Учёт человеческого фактора означает обеспечение дружественного ин­терфейса для работы пользователя, наличие контекстно-зависимой подсказки или обучающей системы, хорошей документации для освоения заложенных в ПП функциональных воз­можностей и др.

5) Модифицируемость означает способность ПП к внесе­нию изменений, например расширение функций обработки, переход на другую техничес­кую базу обработки и т.п.

6) Коммуникативность основана на максимально воз­можной интеграции ПП с другими программами, обеспечении обмена данными в общих форматах представления (экспорт/импорт БД, внедрение или связывание объектов и др.).

7) В условиях рынка важными характерис­тиками ПП также являются: стоимость; количество продаж; время нахождения на рынке (длительность продаж); известность фирмы-разработчика и программы; наличие программных продуктов аналогичного назначения и др.

 

Проектирование программ

Современный подход к проектированию программ основан на декомпозиции за­дачи. Целью при декомпозиции является создание модулей, которые представляют собой небольшие, относительно самостоятельные программы, взаимодействующие друг с другом по хорошо определенным и простым правилам. Если эта цель достигнута, то разработка отдельных модулей может осуществляться различными людьми независимо друг от друга, при этом объединенная программа будет функционировать правильно.

Любой программный продукт (ПП) характеризуется своим жизненным циклом, состоящим из следующих ниже этапов.

1) Постановка задачи, маркетинг и спецификация ПП предназначены для изучения требований к создаваемому программному продукту. В ходе этой работы выявляются свойства, которыми должна обладать система в ко­нечном виде (замысел), описываются функции системы, характеристики интерфейса. Чтобы приступить к решению задачи необходимо точно её сформулировать, т.е. ответить на вопросы: что дано и что нужно найти.

2) Проектирование программы. Сначала производится проектирование архитектуры программной системы. Это предполагает первичную стадию проектирования и заканчивается декомпозицией. Разрабатывается структура модулей. По каждому модулю разрабатывается спецификация модуля: имя/цель (дается имя модулю и предложение о функции модуля с формальными параметрами), неформальное описание (обзор действий модуля), ссылки (какие модули ссылаются на него, и на какие модули ссылается данный модуль), вход/выход (формальные и фактические параметры, глобальные, локальные и общие для ряда модулей переменные), примечания (полезные комментарии общего характера по модулю). Затем происходит детальное проектирование – процедурное описание программы, выбор и оценка алгоритма для реализации каждого модуля.

3) Построение модели и разработка алгоритма. Строится модель задачи, моделируется предметная область и разрабатывается алгоритм решения задачи в соответствии с построенной моделью. На этом этапе необходимо провести анализ правильности алгоритма. Наиболее распространенная процедура доказательства правильности алгоритма – это прогон его на множестве различных тестов. Однако это не гарантирует того, что не может существовать случая, в котором программа не сработает. Для каждого шага предлагается некое обоснование его правильности для всех подходящих входных и выходных данных.

4) На этапе реализации алгоритма происходит конструирование и реализация ал­горитма на конкретном языке программирования и его прогон при тестовых и нормальных условиях для подтверждения работы системы. Этот этап зависит от того, какой язык программирования выбран, на каком компьютере алгоритм будет реализован. С этим связаны выбор типов данных, вводимых структур данных, связь с окружающей средой и т.п.

5) Анализ и тестирование алгоритма и его сложности необходим для оценки ресурсов компьюте­ров, на которых он будет работать, времени обработки конкретных данных, приспособления в работе в локальных сетях и телекоммуникациях. Перед началом эксплуатации программы необходим этап ее отладки и тести­рования. Тестирование – это процесс исполнения программ с целью выявления (обнару­жения) ошибок. Хорошим считается тест, который имеет большую вероятность обнаружения еще не выявленной ошибки. Удачным считается тест, который обнаруживает ещё не выявленную ошибку. В процессе отладки программ часто используют метод трассировки – вывод промежуточных данных по всей программе.

6) Документирование ПП является обязательным видом работ, выполняемых, как правило, не самим разработчиком, а лицом, связанным с распространением и внедрением ПП. Документация должна содержать необходимые сведения по установке и обеспечению надежной работы ПП и др. Документация, как правило, также содержит автоматизированную контекстно-зависимую помощь (HELP); демо-версии, работающие в активном режиме по типу обучающих систем (электронный учебник) или пассивном режиме (ролик, мультфильм) - для демонстрации функциональных возможностей программного продукта и информа­ционной технологии его использования.

7) Распространение и эксплуатация включает рекламную кампанию по продвижению ПП, создание дилерской и дистрибьютерной сети, пунктов сервисного обслуживания и др. Эксплуатация ПП идет параллельно с его сопровождением, при этом эксплуатация может начинаться и в случае отсутствия сопровождения или продолжаться в случае завершения сопровождения ещё какое-то время. В процессе эксплуатации ПП производится устранение обнаруженных ошибок.

8) Снятие ПП с продажи и отказ от сопровождения происходят, как правило, в случае изменения технической политики фирмы-разработчика, неэффективности работы программного продукта, наличия в не неустранимых ошибок, отсутствия спроса. Длительность жизненного цикла для различных ПП неодинакова. Для большинства современных ПП она составляет 2-3 года. Хотя достаточно часто встречаются на компьютерах и давно снятые с производства программные продукты.

Классификация структур данных языка программирования Паскаль.

 

При решении простых задач достаточно обходится простыми типами данных. Однако естественно и часто очень удобно группировать однотипные данные в последовательности – массивы, строки символов, объединять разнотип­ные данные об одном объекте в виде записей и т.д.

Под структурой данных обычно понимают тот или иной способ организации элементов данных, обеспечивающий их обычно формальное объединение в единое целое.

Любой из структурированных типов характеризуется множественностью образующих этот тип элементов. Каждый элемент, в свою очередь, может принадлежать структурирован­ному типу, что позволяет говорить о возможной вложенности типов.

 

Массивы.

Часто используемый составной тип – массив – это последовательность, состоящая из фиксированного числа однотипных элементов. Все элементы массива имеют общее имя (имя массива) и различаются индексами. Индексы можно вычислять, их тип должен быть ординальным (порядковым). При описании массивов используются служебные слова ARRAY и OF. В описании массива указывается тип его элементов и типы их индексов:

type <имя типа> = array[<список типов индексов>] of <тип элементов>;

Тип элементов – произвольный, он может быть составным. Число типов индексов называется размерностью массива. После описания типа массива конкретные массивы можно задать в разделе описания переменных. Например:

type vector=array[1..10] of real; tab=array['А'..'2',1..5] of byte;

var а,b:vector; с:table;

Обращение к элементу массива осуществляется с помощью задания имени переменной, за которым следует заключенный в квадратные скобки список индексов элемента. Например:

а[i]:=3.1; b[k*k+1]:=0; write(mas[4]); a[3]:=a[1]+a[2];

Если массивы имеют одно и то же описание, то во многих версиях Паскаля допустимо их копирование (через оператор присваивания), например b:=а;

Описание массива можно совместить с описанием соответствующих переменных:

var а,b: array[1..10] of real; d: array[byte] of char;

В Турбо-Паскале разрешена инициализация начальных значений составных переменных с помощью типизированных констант. Типизированные константы используются как переменные того же типа. Их применение экономит память, однако они не могут быть использованы для определения других переменных того же типа. Схема описания констант массива:

const <имя массива>:<тип массива> = <список значений элементов>;

Тип массива может быть описан ранее:

type digits=array[1..3] of char; const а:digits =('0','3','8');

Пример: Используя массив, составим программу, которая напечатает 20 чисел Фибоначчи.

program fibon; const n=20;

var а:array[1..n] of integer; {в массиве будем хранить числа} k:integer;

begin а[1]:=1; а[2]:=1; {задаём первые числа Фибоначчи}

for k:=3 to n do a[k]:=a[k-1]+a[k-2]; {задаём остальные числа}

for k:=1 to n do write(a[k]:5); {выписываем} end.

 

Основные алгоритмы обработки массивов (даны фрагменты программ):

1) Найти наибольший элемент двумерного массива n*m.

max:=a[1,1]; for i:=1 to n do for j:=1 to m do if a[i,j]>max then max:=a[i,j];

2) Найти сумму всех элементов одномерного массива.

sum:=0; for i:=1 to n do sum:=sum+a[i]; writeln(sum);

3) Заменить все элементы массива по некоторому правилу (напр., их квадратами).

for i:=1 to n do a[i]:=sqr(a[i]);

4) Найти количество элементов массива, равных данному значению.

kol:=0; for i:=1 to n do if a[i]=kol then inc(kol); writeln(kol);

Замечание. Обработка элементов двумерных массивов (матриц) обычно выполняется с помощью двойного цикла FOR (см. первый пример). Один цикл управляет номером строки, другой –номером столбца.

 

Основные методы сортировки массивов (приведены процедуры)

 

1. Метод простого выбора.

procedure sorting1(var a:ar);

{поскольку в процессе работы процедуры массив изменится,

формальный параметр а описывается как параметр-переменная }

var i,j,k:integer; m:integer;

{m - значение максимального элемента рассматриваемой части массива }

begin for i:=10 downto 2 do {цикл по длине рассматриваемой части массива}

  begin {поиск максимального элемента и его номера в текущей части массива }

    k:=i; m:=a[i]; {начальные значения максимального элемента и его

          индекса в рассматриваемой части массива }

          for j:=2 to i-1 do

          if a[j]>m then begin k:=j; m:=a[k] end;

          if k<>i then begin {перестановка} a[k]:=a[i]; a[i]:=m end

    end end.

 

2. «Метод пузырька».

procedure sorting2(var a:ar);

var k,i,t:integer; {k - номер просмотра (изменяется от 1 до n-1),

i - номер пары, t – промежут. переменная для перестановки местами элементов }

begin for k:=1 to n-1 do  {цикл по номеру просмотра}

   for i:=1 to n-k do if a[i]>a[i+1] then { перестановка элементов }

      begin t:=a[i]; a[i]:=a[i+1]; a[i+1]:=t end

end.

 

3. Метод прямого включения.

procedure sorting3 (var a:ar); var k,j,x:integer;

begin for k:=2 to n do

   begin x:=a[k];  j:=k-1;

      while (j>0)and(x>=a[j]) do begin a[j+1]:=a[j]; dec(j) end; a[j+1]:=x end

end.

 

4. Метод слияний.

procedure sorting4 (k,m,n:integer);

begin i:=k+1; j:=m+1; k:=1;

   while (i<=m)and(j<=n) do { пока не закончилась хотя бы одна часть }

      begin if a[i]<=b[j] then begin c[k]:=a[i]; inc(i); end

            else begin c[k]:=b[j]; inc(j); end;

      inc(k); end; {один из массивов-частей обработан полностью, осталось

                    перенести в "с" остаток другого массива-части }

   while i<=m do begin c[k]:=a[i]; inc(i); inc(k); end;

   while j<=n do begin c[k]:=b[j]; inc(j); inc(k); end

end. { далее остается лишь переписать результат слияния рассматриваемых

        частей - массив "с" - обратно в массив "а" }

5. Обменная сортировка с разделением по методу Хоара

procedure quick_sorting(m,l:integer); var i,j,x,w:integer;

begin i:=m; j:=1; x:=a[(m+l)div(2)];

    repeat while a[i]<x do inc(i); while a[j]>x do dec(j);

    if i<j then begin w:=a[i]; a[i]:=a[j]; a[j]:=w; inc(i); dec(j); end

    until i>j;

    if m<j then quick_sorting(m,j); if i<l then quick_sorting(i,l); end;

 

 

 

 

 

Строки.

Переменная типа строка предназначена для обработки цепочек символов. Каждый символ является элементом типа char. Строки могут вводиться с помощью стандартных операторов read/readln и выводиться стандартными операторами write/writeln.

Объявляются переменные типа строка в разделе var. При объявлении указываются идентификатор переменной, зарезервированное слово string и, в квадратных скобках, целое число - максимально возможная длина строки. Наибольшая длина строки составляет 256 символов. Если переменная имеет значение с максимальной длиной строки, то при объявлении переменной ограничиваются зарезервированным словом.

Пример:   var stroka:string[20];

Значение строкового типа (как и значение типа char) при записи внутри программы заключаются в апострофы. Для обработки строковых данных используется ряд встроенных функций:

1) Length (L) – определяет длину строки, являющуюся значением переменной L. Значение, возвращаемое этой функцией является целочисленным и отображает реальную длину строки, т.е. может не совпадать со значением длины строки, объявленным при декларации.

2) Upcase (C) – преобразует любой символ в прописной. Переменная C может иметь значение типа char, либо являться одним элементом из строки. Русские символы обрабатываться не могут!

3) Copy (L, A, B) – позволяет копировать фрагмент строки являющейся значением переменной L, начиная с позиции A в количестве B, где A и B - целые числа, причем значение A не превышает длины строки L, а значение B не превышает (длина строки L - A). Если эти правила нарушены, то ошибки компиляции не произойдет, но возможно совершение логической ошибки в программе.

4) Pos (L, M) – возвращает результат целочисленного типа, являющийся номером позиции, с которой строка L входит в строку M. Если строки L нет в строке M, то результат - 0.

5) Insert (L, M, A) – вставляет строку L в строку M, начиная с позиции с номером A. Фактически, вставка производится перед указанной позицией.

6) Delete (L, A, B) – удаляет из строки L B символов, начиная с позиции A. Если номера позиций в функциях Insert и Delete не соответствуют длине рассматриваемых строк, то произойдет ошибка компиляции.

7) Concat(s1,s2,...,sk) – сцепление (конкатенация) строк. Значение функции – результат соединения строк s1,s2,..,sk, если он содержит не более 255 символов.

8) Str(k,s) – преобразованиt  числа в строку символов. Строка s получается «навешиванием» апострофов на число k. Пример: str(564,s); (s='564').

9) Val(s,k,i) – преобразования строки из цифр в число. Число i=0, если в строке s нет символов, отличных от цифр, в противном случае i=позиции первого символа, отличного от цифры.

Пример: val('780',k, i); (k=780; i=0).

 

 

Пример программ (полностью).

 

1. Заменить в выражении функцию sqr на ехр. Замена выраже­ния sqr на ехр достигается последовательным применением процедур delete и insert:

program stroka; var a,b:string[40]; k:integer;

begin writеln('введите строку <= 40 символов'); readln(a); b:=a;

repeat k:=pos('sqr',b);

if k>O then begin delete(b,k,3); insert('exp',b,k); end

until k=0; writеln('старая строка=',а); writе1n('новая строка=',b); end.

 

2. Проверить, является ли слово перевёртышем.

program perevertysh; uses crt; var i,j:integer;s:string[20];

begin clrscr; writeln('Введи слово на проверку '); readln(s);

for i:=1 to length(s) do if s[i]<>s[length(s)-i+1] then j:=j+1;

if j>1 then writeln('Слово не "перевертыш"') else writeln('Слово "перевертыш"');

readkey; end.

 

Множества.

Множеством называется упорядоченная совокупность данных одного типа, записанных без повторений. Максимальное множество в Паскале состоит из 256 элементов. Нумерация элементов множества всегда начинается с нуля, независимо от объявленной в программе нижней границы, поэтому если, например, ошибочно описать множество: var S: set of 1..256;

В качестве базового типа (т.е. типа элементов, из которых состоит множество) может использоваться любой порядковый тип данных (кроме Word, Integer, Longint). В том числе тип-диапазон с минимальной границей 0 и максимальной 255. или любой перечисляемый тип не более чем с 256 элементами.

Для объявления множеств используется зарезервированное слово SET OF, за которым указывается тип элемента множества или сами элементы. Внутри программы элементы множества записываются в квадратных скобках. Константа [] означает пустое множество. Порядок перечисления элементов базового типа в константах безразличен, так как элементы во множестве не упорядочены.

Элементы множеств нельзя вводить с клавиатуры и выводить стандартными операторами, т.к. элементы множества относятся к перечисляемому типу.

Над множествами можно выполнять обычные операции: объединение (+), пересечение (*), разность двух множеств (-), смысл которых соответствует смыслу, принятому в математике.

Операция in проверяет принадлежность элемента множеству. Результатом операции будет логическое значение (true или false). Например 2 in [1..4] (true), 0 in [1..7] (false)

Множества можно сравнивать. Равными называются множества, состоящие из одинаковых элементов. Большим будет множество, у которого больше элементов. Из двух множеств с равным количеством элементов большим будет то, первое несовпадающее значение которого больше. Таким образом, к множественным величинам применимы операции: тождественность (=), нетождественность (<>), содержится в (<=), содержит (>=). Результат выполнения этих операций имеет логический тип, например:

['A','B'] = ['A','C'] даст FALSE                          ['A','B'] <> ['A','C'] даст TRUE

['B'] <= ['B','C'] даст TRUE                               ['C','D'] >= ['A'] даст FALSE.

Процедура Include включает новый элемент во множество. Обращение к про­цедуре: Include(S,I).  Здесь S –  множество, состоящее из элементов базового типа; I — элемент этого типа, который необходимо включить во множество. Процедура Exclude исключает элемент из множества. Обращение: Exclude(S,I). Параметры обращения  такие же, как у процедуры Include.

Пример. Выделить из множества целых чисел от 1 до 50 множество чисел, кратных 2 или 5.

program mnojestvo; var i:integer; m:set of 1..50;

begin m:=[]; {M - пустое множество}

for i:=1 to 50 do begin {просматриваем все числа от 1 до 50}

if (i mod 2=0)or(i mod 5=0) {если число делится на 2 или на 5}

then m:=m+[i]; {то добавляем это число во множество M}

end; writeln('Среди чисел от 1 до 50 на 2 или на 5 делятся: ');

for i:=1 to 50 do {снова просматриваем числа от 1 до 50}

if i in m {если число находится во множестве M}

then write(i,' '); {то выписываем это число и ставим пробел после него}

readln; end.

 

Множества часто удобно использовать при обработке строк.

Пример. Подсчитать, сколько различных символов встречается в строке.

program razn_symbol; uses crt; type mset=set of char;

var i,x:integer; s:string; cc:mset;

begin ClrScr;

writeln('Дана строка. Посчитать сколько различных символов встречается в ней.');

writeln('Вывести их на экран.'); writeln('Введите символы:'); readln(s);

for i:=1 to length(s) do

    if not (s[i] in cc) then begin x:=x+1; include(cc,s[i]); end;

writeln(x,'-различных символов'); readkey;

end.

 

Записи.

Запись – это структура данных, состоящая из фиксированного количества компо­нентов, называемых полями записи. В отличие от массива, поля за­писи могут быть разного типа. Чтобы можно было ссылаться на тот или иной ком­понент записи, поля именуются. Любое поле записи само может быть записью.

Логическая структура записи – это линейная таблица с фиксированным количеством ячеек, в которых могут записываться значения разных типов. Структура объявления типа запись:

var <идентификатор>:record <список полей> end;

Например: var student: record fio:string; fak:string; group:integer end;

Как и для массивов, значения переменных типа запись можно присваивать другим переменным того же типа, например: а:=b;

Остальные операции с записями осуществляются через действия с полями. К каждому полю записи можно обратиться, указав составное имя следующего формата:

<имя_переменной_запись>.<имя_поля>

Например:

student.fio:=’Иванов’; write(student.fak); read(student.group);

Чтобы упростить доступ к полям записи можно использовать оператор присоедине­ния with:

with  <переменная>  do  <оператор>;

Здесь with, do – зарезервированные слова (с, делать); <переменная> — имя переменной типа запись, за которым, возможно, следует список вложенных полей; <оператор> — любой оператор.

При помощи этого оператора предыдущий пример можно записать так:

with student do begin fio:=’Иванов’; write(fak); read(group) end;

Для использования в программе набора с одинаковыми полями используются массивы записей:  
var A: array [1..10] of record fam: string; name: string; end;

Pascal позволяет использовать записи с «вариантными» поля­ми. Каждый вариант определяется константой выбора, за которой следует двоеточие и список полей, заключенный в круглые скобки. В любой записи может быть толь­ко одна вариантная часть, и, если она есть, она должна располагаться за всеми фик­сированными полями. Вариантная часть задается с помощью конструкции: case P of, где Р – ключ выбора, который может являться полем-признаком, определяющим какой из вариантов в данный момент будет использоваться, либо просто идентификатором стандартного или предварительно описанного порядкового типа.

Константа, определяющая значение поля-признака, или значение стандартного типа задает вариант записи и называется константой выбора. Возможные значения, ключа выбора,  перечисляются так же, как и в операторе варианта. Однако вместо указания выполняемого действия, как это делается в операторе варианта, указываются поля варианта, заключенные в круглые скобки. Описание вариантной части должно завершать описание записи в целом. Тип поля-признака Р можно указать в заголовке вариантной части, например:          

type izdanie=(book,journal,newspaper);

liter=record

title:string[30];

god_izdan:integer;

case  variants:izdanie of

             book: (author:string[40]; kol_ekz:byte);

             journal: (num:1..12);

             newspaper: (day:1..31; month:1..12);

             end;

var sved:liter;

Здесь тип liter определяет запись с двумя обычными полями, «полем-признаком» и вариантной частью, которая может состоять из одного, двух или трех полей. На логическом уровне они определяются различными значениями «поля-признака» - variants. Задание значения для этого поля, проверка текущего значения и выбор на этой основе тех или иных вариантных полей должен контролироваться программистом самостоятельно.

 

Файлы.

Файл - это последовательность однотипных компонентов. Компонентом файла может быть значение простого типа или структура, но не файл. Файл может быть компонентом другой структуры, но ни прямо, ни косвенно не может входить в состав другого файла.

Файл отличается от одномерного массива: 1) размещением на внешнем носителе; 2) произвольным в пределах носителя числом компонентов; 3) доступом к одному текущему компоненту в каждый момент времени.

В Паскале различают текстовые, типизированные и нетипизированные файлы. При работе с файлами ключевым понятием является понятие файловой переменной. Файловая переменная не является представлением одного конкретного файла. В зависимости от класса файла ее можно объявить одним из трех способов (ФП – файловая переменная).

var <ФП>: text;

<ФП>: file of <тип компонентов>;

<ФП>: file;

Для сопоставления файловой переменной с именем конкретного файла используется процедура assign(<ФП>,'путь_к_файлу\имя_файла');

Процедура assign должна быть первой среди действий работы с файлом. Если файл находится в текущей директории, то путь к нему можно не указывать.

Файл, содержимое которого полностью заменяется (или файл создаётся), открывается процедурой rewrite(<ФП>). Файл, содержимое которого продолжает использоваться путем чтения, открывается процедурой reset(<ФП>). Текстовые файлы могут быть открыты на дозапись процедурой append(<ФП>). При этом курсор устанавливается в конец файла.

Для чтения компонентов файла используются процедуры read, readln и blockread. Первым аргументом в их списке стоит файловая перемнная, а затем обычный список вывода. Для записи компонентов в файл используются процедуры write, writeln и blockwrite.

После завершения работы с файлом его необходимо закрыть процедурой close(<ФП>). Закрытый файл можно удалить erase(<ФП>) и переименовать rename(<ФП>,'новое_имя').

Функция eof является логической и возвращает значение истина если достигнут конец файла. При работе с текстовыми файлами в конец каждой строки добавляется соответствующий знак, который можно найти, используя логическую функцию eoln. Этот символ в конец строки может быть поставлен принудительно. Для этого используется клавиша [Enter].

Наряду с функциями eof и eoln могут использоваться seekeof(<ФП>) и seekeoln(<ФП>), "предчувствующие" окончание файла или строки, т.е. они распознают признак конца, если перед ним находятся пробелы или маркеры табуляции.