Процедуры и функции для работы с файлами

Простые типы

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

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

Порядковые типы

К порядковым типам относятся (см. рис.4.1) целые, логический, символьный, перечисляемый и тип-диапазон. К любому из них применима функция ORD(X), которая возвращает порядковый номер значения выражения X. Для целых типов функция ORD(X) возвращает само значение X, т.е. ORD(X) = X для X, принадлежащего любому шелому типу. Применение ORD(X) к логическому, символьному и перечисляемому типам дает положительное целое число в диапазоне от 0 до 1 (логический тип), от 0 до 155 (символьный), от 0 до 65535 (перечисляемый). Тип-диапазон сохраняет все свойства базового порядкового типа, поэтому результат применения к нему функции ORD(X) зависит от свойств этого типа.

К порядковым типам можно также применять функции:

PRED (X) - возвращает предыдущее значение порядкового типа (значение, которое соответствует порядковому номеру ORD(X)- 1), т.е.

ORD(PRED(X)) = ORD(X) - 1;

SUCC (X) - возвращает следующее значение порядкового типа, которое соответствует порядковому номеру ORD(X) +1, т.е.

ORD(SUCC(X)) = ORD(X) + 1.

Например, если в программе определена переменная

var

с : Char;

begin

с := '5' ;

end.

то функция PRED(C) вернет значение '4', а функция SUCC(C) - значение '6'.

Если представить себе любой порядковый тип как упорядоченное множество значий, возрастающих слева направо и занимающих на числовой оси некоторый отрезок, то функция PRED(X) не определена для левого, a SUCC(X) - для правого конца этого отрезка.

Целые типы. Диапазон возможных значений целых типов зависит от их внутреннего представления, которое может занимать один, два или четыре байта. В табл. 4.1 приводится название целых типов, длина их внутреннего представления в байтах и диапазон возможных значений.

Таблица 4.1

Целые типы
Название Длина, байт Диапазон значений
Byte 0. . .255
ShortInt -128. . .+127
Word 0. . .65535
Integer -32768.. .+32767
LongInt -2 147 483 648... +2 147 483 647

При использовании процедур и функций с целочисленными параметрами следует руководствоваться «вложенностью» типов, т.е. везде, где может использоваться WORD, допускается использование BYTE (но не наоборот), в LONGINT «входит» INTEGER, который, в свою очередь, включает в себя SHORTINT.

Перечень процедур и функций, применимых к целочисленным типам, приведен в табл.4.2. Буквами b, s, w, i, l обозначены выражения соответственно типа BYTE, SHORTINT, WORD, INTEGER и LONGINT, x - выражение любого из этих типов; буквы vb, vs, vw, vi, vl, vx обозначают переменные соответствующих типов. В квадратных скобках указывается необязательный параметр.

Таблица 4.2

Стандартные процедуры и функции, применимые к целым типам
Обращение Тип результата Действие
abs (x) x Возвращает модуль х
chr(b) Char Возвращает символ по его коду
dec (vx[, i] ) - Уменьшает значение vx на i, а при отсутствии i -на 1
inc(vx[, i] ) - Увеличивает значение vx на i, а при отсутствии i - на 1
Hi(i) Byte Возвращает старший байт аргумента
Hi(w) To же То же
Lo(i) " Возвращает младший байт аргумента
Lo (w) " То же
odd(l) Boolean Возвращает True, если аргумент - нечетное число
Random (w) Как у параметра Возвращает псевдослучайное число, равномерно распределенное в диапазоне 0...(w-l)
sgr (x) X Возвращает квадрат аргумента
swap ( i ) Integer Меняет местами байты в слове
swap (w) Word  

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

var

а : Integer;

х, у : Real;

begin

а := 32767; {Максимально возможное значение типа INTEGER}

х := а + 2; {Переполнение при вычислении этого выражения!}

у := LongInt(а)+2; {Переполнения нет после приведения переменной к более мощному типу}

WriteLn(x:10:0, у:10:0)

end.

В результате прогона программы получим

-32767 32769

Логический тип. Значениями логического типа может быть одна из предварительно объявленных констант FALSE (ложь) или TRUE (истина). Для них справедливы правила:

ord(False) = 0;

ord(True) = 1;

False < True;

succ(False)= True;

pred(True) = False.

Поскольку логический тип относится к порядковым типам, его можно использовать в операторе счетного типа, например:

var

1 : Boolean;

begin

for 1 := False to True do ....

Символьный тип. Значением символьного типа является множество всех символов ПК. Каждому символу приписывается целое число в диапазоне 0...255. Это число служит кодом внутреннего представления символа, его возвращает функция ORD.

Для кодировки используется код ASCII (American Standard Code for Information Interchange - американский стандартный код для обмена информацией). Это 7-битный код, т.е. с его помощью можно закодировать лишь 128 символов в диапазоне от 0 до 127. В то же время в 8-битном байте, отведенном для хранения символа в Турбо Паскале, можно закодировать в два раза больше символов в диапазоне от 0 до 255. Первая половина символов ПК с кодами 0...127 соответствует стандарту ASCII (табл. 4.3). Вторая половина символов с кодами 128...255 не ограничена жесткими рамками стандарта и может меняться на ПК разных типов (в прил.2 приведены некоторые распространенные варианты кодировки этих символов).

Таблица 4.3

Кодировка символов в соответствии со стандартом ASCII
Код Символ Код Символ Код Символ Код Символ
NUL BL ® '
ЗОН ! A a
STX " В b
ЕТХ # С с
EOT $ D d
ENQ % E e
АСК & F f
BEL ' G g
BS ( H h
НТ ) I i
LF * J j
VT + k k
FF , L i
CR - M m
SO . N n
SI / О
DEL p P
DC1 Q q
DC2 R r
DC3 S s
DC4 T t
NAK U u
SYN V V
ETB w w
CAN X X
EM У У
SUB : z z
ESC / [ {
FS < \ l
GS = ] }
RS > ^ ~
US ? n

Вещественные типы

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

Таблица 4.4

Длина, байт Название Количество значащих цифр Диапазон десятичного порядка
Real 11. . .12 -39. ..+38
Double 15. ..16 -324. . .+308
extended 19. . .20 -4951. . .+4932
comp 19. . .20 -2*1063+1. . .+2*63-1

Как видно из табл.4.4, вещественное число в Турбо Паскале занимает от 6 до 10 смежных байт и имеет следующую структуру в памяти ПК:

s e m

Здесь s - знаковый разряд числа; е - экспоненциальная часть; содержит двоичный порядок; m - мантисса числа.

Мантисса m имеет длину от 23 (для SINGLE) до 63 (для EXTENDED) двоичных разрядов, что и обеспечивает точность 7.. .8 для SINGLE и 19.. .20 для EXTENDED десятичных цифр. Десятичная точка (запятая) подразумевается перед левым (старшим) разрядом мантиссы, но при действиях с числом ее положение сдвигается влево или вправо в соответствии с двоичным порядком числа, хранящимся в экспоненциальной части, поэтому действия над вещественными числами называют арифметикой с плавающей точкой (запятой).

Как видим, Турбо Паскаль характеризуется богатой гаммой вещественных типов, однако доступ к типам SINGLE, DOUBLE и EXTENDED возможен только при особых режимах компиляции. Дело в том, что эти типы рассчитаны на аппаратную поддержку арифметики с плавающей точкой и для их эффективного использования в состав ПК должен входить арифметический сопроцессор. Компилятор Турбо Паскаля позволяет создавать программы, работающие на любых ПК (с сопроцессором или без него) и использующие любые вещественные типы. Необходимая для этого настройка компилятора описана в прил.1. В процессе запуска Турбо Паскаль проверяет состав аппаратных средств и выявляет наличие или отсутствие сопроцессора.

В некоторых случаях бывает необходимо отключить автоконтроль. Для этого перед запуском Турбо Паскаля следует дать такую команду ДОС:

set 87=N

команда

set 87=Y

напротив, включает автоконтроль - эта команда активна по умолчанию.

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

Например, если «машинное эпсилон» (см. пример 2.6 в гл.2) вычисляется с помощью такой программы:

{$N+,E+}

type

RealType = Real:

var

epsilon : RealType;

begin

epsilon := 1;

while 1+epsilon/2 > 1 do

epsilon := epsilon/2;

WriteLn(epsilon)

end.

то независимо от объявления типа REALTYPE (он может быть SINGLE, REAL, DOUBLE или EXTENDED) на печать будет выдан результат

1.08420217248550Е-0019

что соответствует типу EXTENDED. Происходит это по той причине, что все операнды вещественного выражения 1 + epsilon/2 в операторе WHILE, перед вычислением автоматически преобразуются к типу EXTENDED. Чтобы получить правильный результат (например, для типа REALTYPE = REAL он будет 9 . 09494701772928Е-0013), программу необходимо изменить следующим образом:

{$N+,E+}

type

RealType= Real;

var

epsilon, epsl:RealType;

begin

epsilon := 1;

repeat

epsilon := epsilon/2;

epsl := 1 + epsilon

until epsl = 1;

WriteLn(2*epsilon)

end.

Следует учесть, что тип REAL оптимизирован для работы без сопроцессора. Если Ваш ПК оснащен сопроцессором, использование типа REAL приведет к дополнительным затратам времени на преобразование REAL к EXTENDED. Поэтому никогда не используйте REAL на ПК с сопроцессором, т.к. дополнительные затраты времени на преобразование типов могут свести на нет все преимущества сопроцессора. При разработке программ, критичных ко времени счета, следует заменять его типами SINGLE или DOUBLE: по сравнению с типом REAL скорость вычислений на машинах с сопроцессором в этом случае увеличивается в 2...3 раза. Если в ПК нет арифметического сопроцессора, скорость обработки данных всех вещественных типов приблизительно одинакова.

Особое положение в Турбо Паскале занимает тип СОМР, который трактуется как вещественное число без экспоненциальной и дробной частей. Фактически, СОМР - это «большое» целое число со знаком, сохраняющее 19...20 значащих десятичных цифр (во внутреннем представлении СОМР занимает 8 смежных байт). В то же время в выражениях СОМР полностью совместим с любыми другими вещественными типами: над ним определены все вещественные операции, он может использоваться как аргумент математических функций и т.д. Наиболее подходящей областью применения типа СОМР являются бухгалтерские расчеты: денежные суммы выражаются в копейках или центах и действия над ними сводятся к операциям с достаточно длинными целыми числами.

Для работы с вещественными данными могут использоваться встроенные математические функции, представленные в табл. 2.5. В этой таблице REAL означает любой вещественный тип, INTEGER - любой целый тип.

Таблица 4.5

Стандартные математические функции Турбо Паскаля
Обращение Тип параметра Тип результата Примечание
abs (x) Real, Integer Тип аргумента Модуль аргумента
АrсТаn (х) Real Real Арктангенс ( значение в радианах)
cos (х) To же То же Косинус, угол в радианах
ехр (х) " " Экспонента
frас (х) " " Дробная часть числа
int(x) " " Целая часть числа
ln(x) " " Логарифм натуральный
Pi - " л = 3.141592653...
Random - " Псевдослучайное число, равномерно распределенное в диапазоне 0...[1]
Pandom(x) Integer Integer Псевдослучайное целое число, равномерно распределенное в диапазоне 0...(х-1)
Randomize - - Инициация генератора псевдослучайных чисел
sin(x) Real Real Синус, угол в радианах
sqr (x) To же То же Квадрат аргумента
sqrt (x) " " Корень квадратный

Структурированные типы

Любой из структурированных типов (а в Турбо Паскале их четыре: массивы, запиcи, множества и файлы) характеризуется множественностью образующих этот тип элементов, т.е. переменная или константа структурированного типа всегда имеет неcколько компонентов. Каждый компонент, в свою очередь, может принадлежать cтруктурированному типу, что позволяет говорить о возможной вложенности типов. В Турбо Паскале допускается произвольная глубина вложенности типов, однако суммарная длина любого из них во внутреннем представлении не должна превышать -5520 байт.

В целях совместимости со стандартным Паскалем в Турбо Паскале разрешается черед описанием структурированного типа ставить зарезервированное слово PACKED, предписывающее компилятору, по возможности, экономить память, отводимую под объекты структурированного типа; но компилятор фактически игнорирует это указание: «упаковка» данных в Турбо Паскале осуществляется автоматически зезде, где это возможно.

Массивы

Массивы в Турбо Паскале во многом схожи с аналогичными типами данных в других языках программирования. Отличительная особенность массивов заключается в том, что все их компоненты суть данные одного типа (возможно, структурированного). Эти компоненты можно легко упорядочить и обеспечить доступ к любому из них простым указанием его порядкового номера, например:

type

digit =array[0..9] of Char ;

matrix =array[Byte] of Single;

var

m : matrix;

d : digit;

i : Integer;

begin

.......

m[17] := ord(d[i-l])/10;

.......

end.

Описание типа массива задается следующим образом:

<имя типа> = ARRAY [ <сп.инд.типов> ] OF <тип>

Здесь <имя типа> - правильный идентификатор;

ARRAY, OF - зарезервированные слова (массив, из);

<сп.тд.типов> - список из одного или нескольких индексных типов, разделенных запятыми; квадратные скобки, обрамляющие список, - требование синтаксиса;

<тип> - любой тип Турбо Паскаля.

В качестве индексных типов в Турбо Паскале можно использовать любые порядковые типы, кроме LONGINT и типов-диапазонов с базовым типом LONGINT.

Определить переменную как массив можно и непосредственно при описании этой переменной, без предварительного описания типа массива, например:

var

а,b : array [1..10] of Real;

Обычно в качестве индексного типа используется тип-диапазон, в котором задаются границы изменения индексов. Так как тип <тип>, идущий за словом OF, - любой тип Турбо Паскаля, то он может быть, в частности, и другим массивом, например:

type

mat = array [0..5] of array [-2..2] of array [Char] of Byte;

Такую запись можно заменить более компактной:

type

mat = array [0..5,-2..2,Char] of Byte;

Глубина вложенности структурированных типов вообще, а следовательно, и массивов - произвольная, поэтому количество элементов в списке индексных типов (размерность массива) не ограничено, однако суммарная длина внутреннего представления любого массива, как уже говорилось, не может быть больше 65520 байт. В памяти ПК элементы массива следуют друг за другом так, что при переходе от младших адресов к старшим наиболее быстро меняется самый правый индекс массива. Если, например,

var

а : array[1. .2,1. .2] of Byte;

begin

a [1,1]:=1;

a [2,1]:=2;

a [l, 2]:=3;

a [2,2]:=4;

end.

то в памяти последовательно друг за другом будут расположены байты со значениями 1,3,2, 4 . Это обстоятельство может оказаться важным при использовании стандартной процедуры копирования памяти MOVE.

В Турбо Паскале можно одним оператором присваивания передать все элементы одного массива другому массиву того же типа, например:

var

а,b:array [1..5] of Single;

begin

.....

a := b;

.....

end.

После этого присваивания все пять элементов массива А получат те же значения, что и в массиве В. Однако над массивами не определены операции отношения. Нельзя, например, записать

if a = b then ...

Сравнить два массива можно поэлементно, например:

var

a,b:array [1..5] of Single;

eq:Boolean;

i:Byte;

begin

.....

eq := True; for i := 1 to 5 do

if a[i] <> b[i] then

eq := False;

if eq then

.....

end.

Процедуры и функции для работы с файлами - student2.ru Процедуры и функции для работы с файлами - student2.ru Процедуры и функции для работы с файлами - student2.ru

Записи

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

Структура объявления типа записи такова:

<имя типа> = RECORD <сп.полей> END

Здесь <имя типа> - правильный идентификатор;

RECORD, END - зарезервированные слова (запись,конец); <сп.полей> - список полей; представляет собой последовательность разделов записи, между которыми ставится точка с запятой.

Каждый раздел записи состоит из одного или нескольких идентификаторов полей, отделяемых друг от друга запятыми. За идентификатором (идентификаторами) ставится двоеточие и описание типа поля (полей), например:

type

BirthDay = record

day,month : Byte;

year : Word

end;

var

a,b : Birthday;

.......

В этом примере тип BIRTHDAY (день рождения) есть запись с полями DAY, MONTH и YEAR (день, месяц и год); переменные А и В содержат записи типа BIRTHDAY.

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

а := b;

К каждому из компонентов записи можно получить доступ, если использовать составное имя, т.е. указать имя переменной, затем точку и имя поля:

а.day := 27;

b.year := 1939;

Для вложенных полей приходится продолжать уточнения:

type

BirthDay = record

day,month: Byte;

year : Word

end;

var

с : record

name : String;

bd : BirthDay

end;

begin

.....

if c.bd.year = 1939 then ...

end.

Чтобы упростить доступ к полям записи, используется оператор присоединения WITH:

WITH <переменная> DO <оператор>

Здесь WITH, DO - ключевые слова (с, делать);

<переменная> - имя переменной типа запись, за которым, возможно, следует список вложенных полей; <оператор> - любой оператор Турбо Паскаля.

Например:

with c.bd do month := 9;

Это эквивалентно

with с do with bd do month := 9;

или

with c,bd do month := 9;

или

c.bd.month := 9;

Турбо Паскаль разрешает использовать записи с так называемыми вариантными полями, например:

type

Forma = record

Name: String;

case Byte of

0: (Birthplace: String [40]);

1: (Country : String [20];

EntryPort : String [20];

EntryDate : 1. . 31;

ExitDate : 1..31)

end;

В этом примере тип FORMA определяет запись с одним фиксированным полем NAME и вариантной частью, которая задается предложением CASE... OF. Вариантная часть состоит из нескольких вариантов (в примере - из двух вариантов: 0 и 1). Каждый вариант определяется константой выбора, за которой следует двоеточие и список полей, заключенный в круглые скобки. В любой записи может быть только одна вариантная часть, и, если она есть, она должна располагаться за всеми фиксированными полями.

Замечательной особенностью вариантной части является то обстоятельство, что все заданные в ней варианты «накладываются» друг на друга, т.е. каждому из них выделяется одна и та же область памяти. Это открывает дополнительные возможности преобразования типов, например:

var

mem4 : record case Byte of

0 : (by : array'[0..3] of Byte);

1 : (wo : array [0..1] of Word);

2 : (lo : longint);

end;

В этом примере запись МЕМ4 имеет три варианта, каждый из которых занимает в памяти один и тот же участок из 4 байт. В зависимости от того, к какому полю записи мы обращаемся в программе, этот участок может рассматриваться как массив из 4 байт (поле ВТ), массив из двух целых типа WORD (поле WO) или, наконец, как одно целое число типа LONGINT (поле LO). Например, этой записи можно сначала присвоить значение как длинному целому, а затем проанализировать результат по байтам или словам:

var

х : Word;

xb: Byte;

x1: Longint;

begin

.....

with m do

begin

lo := trunc(2*pi*x);

if wo[1] = 0

then if by[l] = 0 then

xb := x[0]

else

x := wo[0]

else

x1 := lo

end;

.....

end.

Предложение CASE... OF, открывающее вариантную часть, внешне похоже на соответствующий оператор выбора, но на самом деле лишь играет роль своеобразного служебного слова, обозначающего начало вариантной части. Именно поэтому в конце вариантной части не следует ставить END как пару к CASE... OF. (Поскольку вариантная часть - всегда последняя в записи, за ней все же стоит END, но лишь как пара к RECORD). Ключ выбора в предложении CASE... OF фактически игнорируется компилятором: единственное требование, предъявляемое к нему Турбо Паскалем, состоит в том, чтобы ключ определял некоторый стандартный или предварительно объявленный порядковый тип. Причем сам этот тип никак не влияет ни на количество следующих ниже вариантных полей, ни даже на характер констант выбора. В стандартном Паскале в качестве ключа выбора необходимо указывать некоторую переменную порядкового типа, причем в исполняемой части программы можно присваивать значение этой переменной и таким образом влиять на выбор полей. В Турбо Паскале также можно в поле ключа выбора указывать переменную порядкового типа и даже присваивать ей в программе значение, что однако не влияет на выбор поля: значения констант выбора в Турбо Паскале могут быть произвольными, в том числе повторяющимися, например:

type

reel = record

a : Byte;

b : Word;

end;

rec2 = record

с : longint;

case x : Byte of

1 : (d : Word);

2 : (e : record

case Boolean of

3 :( freel);

3 :( g Single);

'3':( с Word);

end)

end;

var

r : rec2;

begin

r.x := 255;

if r.e.g = 0 then

WriteLn('O.K. ')

else

WriteLn(r.e.g)

end.

В этом примере предложение

case Boolean of

в записи, определяемой в поле Е, объявляет ключом выбора логический тип, который, как известно, имеет лишь два значения - TRUE и FALSE. Константы же выбора следующих далее вариантов не только содержат совершенно не свойственные этому типу значения, но и две из них повторяются, а общее количество вариантов - три, а не два, как следовало бы ожидать.

Имена полей должны быть уникальными в пределах той записи, где они объявлены, однако, если записи содержат поля-записи, т.е. вложены одна в другую, имена могут повторяться на разных уровнях вложенности (см. поле С в последнем примере).

Множества

Множества - это наборы однотипных логически связанных друг с другом объектов. Характер связей между объектами лишь подразумевается программистом и никак не контролируется Турбо Паскалем. Количество элементов, входящих в множество, может меняться в пределах от 0 до 256 (множество, не содержащее элементов, называется пустым). Именно непостоянством количества своих элементов множества отличаются от массивов и записей.

Два множества считаются эквивалентными тогда и только тогда, когда все их элементы одинаковы, причем порядок следования элементов в множестве безразличен. Если все элементы одного множества входят также и в другое, говорят о включении первого множества во второе. Пустое множество включается в любое другое.

Пример определения и задания множеств:

type

digitChar= set of '0'..'9';

digit = set of 0. .9;

var

sl,s2,s3 :digitChar;

s4,s5,s6 :digit;

begin

.....

s1:=['1','2','3'];

s2:=['3','2','1'];

s3:=['2','3'];

s4:=[0..3,6];

s5:=[4,5];

s6:=[3..9];

.....

end.

В этом примере множества S1 и S2 эквивалентны, а множество S3 включено в S2 , но не эквивалентно ему.

Описание типа множества имеет вид:

<имя типа> = SET OF <баз.тип>

Здесь <имя типа> - правильный идентификатор;

SET, OF - зарезервированные слова (множество, из);

<баз.тип> - базовый тип элементов множества, в качестве которого может

использоваться любой порядковый тип, кроме WORD, INTEGER, LONGINT.

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

Над множествами определены следующие операции:

* пересечение множеств; результат содержит элементы, общие для обоих множеств; например, S4*S6 содержит [3], S4*S5 - пустое множество (см. выше);

+ объединение множеств; результат содержит элементы первого множества, дополненные недостающими элементами из второго множества:

S4+S5 содержит [0,1,2,3,4,5,6];

S5+S6 содержит [3,4,5,6,7,8,9];

- разность множеств; результат содержит элементы из первого множества, которые не принадлежат второму:

S6-S5 содержит [3,6,7,8,9];

S4-S5 содержит [0,1,2,3,6];

= проверка эквивалентности; возвращает TRUE, если оба множества эквивалентны;

<> проверка неэквивалентности; возвращает TRUE, если оба множества неэквивалентны;

<= проверка вхождения; возвращает TRUE, если первое множество включено во второе;

>= проверка вхождения; возвращает TRUE, если второе множество включено в первое;

IN проверка принадлежности; в этой бинарной операции первый элемент - выражение, а второй - множество одного и того же типа; возвращает TRUE , если выражение имеет значение, принадлежащее множеству:

3 in s6 возвращает TRUE;

2*2 in s1 возвращает FALSE.

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

INCLUDE (S,I)

Здесь S - множество, состоящее из элементов базового типа TSetBase;

I - элемент типа TSetBase, который необходимо включить во множество.

EXCLUDE - исключает элемент из множества. Обращение:

EXCLUDE(S,I)

Параметры обращения - такие же, как у процедуры INCLUDE.

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

В примере 4.1, иллюстрирующем приемы работы с множествами, реализуется алгоритм выделения из первой сотни натуральных чисел всех простых чисел. В его основе лежит прием, известный под названием «решето Эратосфена». В соответствии с этим алгоритмом вначале формируется множество BEGINSET, состоящее из всех целых чисел в диапазоне от 2 до N. В множество PRIMERSET (оно будет содержать искомые простые числа) помещается 1. Затем циклически повторяются следующие действия:

  • взять из BEGINSET первое входящее в него число NEXT и поместить его в PRIMERSET;
  • удалить из BEGINSET число NEXT и все другие числа, кратные ему, т.е.2*NEXT, 3*NEXT и т.д.

Цикл повторяется до тех пор, пока множество BEGINSET не станет пустым.

Эту программу нельзя использовать для произвольного N, так как в любом множестве не может быть больше 256 элементов.

Пример 4.1

Program Primer_numbers_detect;

{Выделение всех простых чисел из первых N целых}

const

N = 255; {Количество элементов исходного множества}

type

SetOfNumber = set of 1..N;

var

n1,next,i : Word; {Вспомогательные переменные}

BeginSet, {Исходное множество}

PrimerSet : SetOfNumber; {Множество простых чисел} .

begin

BeginSet := [2. .N] ; {Создаем исходное множество}

PrimerSet:= [1]; {Первое простое число}

next:= 2; {Следующее простое число}

while BeginSet <> [] do {Начало основного цикла}

begin

n1 := next;{n1-число,кратное очередному простому (next)}

{Цикл удаления из исходного множества непростых чисел:}

while n1 <= N do

begin

Exclude(BeginSet,nl);

n1 := n1+next {Следующее кратное}

end; {Конец цикла удаления}

Include(PrimerSet,next);

{Получаем следующее простое, которое есть первое невычеркнутое из исходного множества}

repeat

inc(next)

until (next in BeginSet) or (next > N)

end; {Конец основного цикла}

{Выводим результат:}

for i := 1 to N do

if i in PrimerSet then Write(i:8);

WriteLn

END.

Перед тем как закончить рассмотрение множеств полезно провести небольшой эксперимент. Измените описание типа SETOFNUMBER следующим образом:

type

SetOf Number = set of 1. . 1 ;

и еще раз запустите программу из предыдущего примера. На экран будет выведено

1 3 5 7

Множества BeginSet и PrimerSet состоят теперь из одного элемента, а программа сумела поместить в них не менее семи! Секрет этого прост: внутреннее устройство множества таково, что каждому его элементу ставится в соответствие один двоичный разряд (один бит); если элемент включен во множество, соответствующий разряд имеет значение 1, в противном случае - 0. Минимальной единицей памяти является один байт, содержащий 8 бит. Компилятор выделил множествам по одному байту, в результате мощность каждого из них стала равна 8 элементов. Максимальная мощность множества - 256 элементов. Для таких множеств компилятор выделяет по 16 смежных байт.

И еще один эксперимент: измените диапазон базового типа на 1.256. Хотя мощность этого типа составляет 256 элементов, при попытке компиляции программы компилятор сообщит:

Error 23: Set base type out of range.

(Ошибка 23: Базовый тип множества выходит за допустимые границы.)

Компилятор разрешает использовать в качестве базового типа целочисленный тип-диапазон с минимальной границей 0 и максимальной 255 или любой перечисляемый тип не более чем с 256 элементами (максимальная мощность перечисляемого типа -5536 элементов).

Строки

Тип STRING (строка) в Турбо Паскале широко используется для обработки текстов. Он во многом похож на одномерный массив символов ARRAY[O..N] OF CHAR, однако, в отличие от последнего, количество символов в строке-переменной может меняться от 0 до N, где N - максимальное количество символов в строке. Значение N определяется объявлением типа STRING [N] и может быть любой константой порядкового типа, но не больше 255 . Турбо Паскаль разрешает не указывать N, в этом случае длина строки принимается максимально возможной, а именно N=255 .

Строка в Турбо Паскале трактуется как цепочка символов. К любому символу в строке можно обратиться точно так же, как к элементу одномерного массива ARRAY [0..N] OF CHAR, например:

var

st : String;

begin

.....

if st[5] = 'A' then...

end.

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

var

st : String;

i : Byte;

begin

i := ord(st [0] ) ; {i - текущая длина строки}

while (i <> 0) and (st[i] = ' ') do

begin

dec(i);

st[0] := chr(i)

end;

.....

end.

Значение ORD(st[0]) , т.е. текущую длину строки, можно получить и с помощью функции LENGTH(st), например:

while (Length(st)<>0) and (st[Length(st)]=' ') do

st[0] := chr(Length(st)-1)

К строкам можно применять операцию «+» - сцепление, например:

st := 'а1 + 'b';

st := st + 'с'; {st содержит "abc"}

Если длина сцепленной строки превысит максимально допустимую длину N, то «лишние» символы отбрасываются. Следующая программа, например, напечатает символ 1:

var

st: String [1] ;

begin

St:='123';

WriteLn(st)

end.

Все остальные действия над строками и символами реализуются с помощью описываемых ниже стандартных процедур и функций.

CONCAT(S1 [,S2, ... , SN] ) - функция типа STRING; возвращает строку, представляющую собой сцепление строк-параметров SI, S2, ..., SN.

COPY(ST, INDEX, COUNT) - функция типа STRING; копирует из строки ST COUNT символов, начиная с символа с номером INDEX.

DELETE (ST, INDEX, COUNT) - процедура; удаляет СОUNT символов из строки ST, начиная с символа с номером INDEX.

INSERT (SUBST, ST, INDEX) - процедура; вставляет подстроку SUBST в строку ST, начиная с символа с номером INDEX.

LENGTH (ST) - функция типа INTEGER; возвращает длину строки ST.

POS (SUBST, ST) - функция типа INTEGER; отыскивает в строке STпервое вхождение подстроки SUBST и возвращает номер позиции, с которой она начинается; если подстрока не найдена, возвращается ноль.

STR(X [; WIDTH [: DECIMALS] ], ST) - процедура; преобразует число X любого вещественного или целого типов в строку символов ST так, как это делает процедура WRITELN перед выводом; параметры WIDTH и DECIMALS, если они присутствуют, задают формат преобразования: WIDTH определяет общую ширину поля, выделенного под соответствующее символьное представление вещественного или целого числа X, a DECIMALS - количество символов в дробной части (этот параметр имеет смысл только в том случае, когда Х- вещественное число).

VAL(ST, X, CODE) - процедура; преобразует строку символов ST во внутреннее представление целой или вещественной переменной X, которое определяется типом этой переменной; параметр CODE содержит ноль, если преобразование прошло успешно, и тогда в X помещается результат преобразований, в противном случае он содержит номер позиции в строке ST, где обнаружен ошибочный символ, и в этом случае содержимое Х не меняется; в строке ST могут быть ведущие пробелы, однако ведомые пробелы недопустимы; например, обращение val (' 123',k,i) пройдет успешно: k получит значений 123, в i будет помещен 0, в то время как обращение val (' 123 ' , k, i) будет ошибочным: значение k не изменится, a i будет содержать 4.

UPCASE (СН) - функция типа CHAR; возвращает для символьного выражения СН, которое должно представлять собой строчную латинскую букву, соответствующую заглавную букву; если значением СН является любой другой символ (в том числе строчная буква русского алфавита), функция возвращает его без преобразования.

Примеры:

var

х : Real;

у : Integer;

st,st1: String;

begin

st := concat('12','345'); {строка st содержит 12345}

st1 := copy(st,3,Length(st)-2); {st1 содержит 345}

insert('-',st1,2); {строка st1 содержит 3-45}

delete(st,pos('2',at),3); {строка st содержит 15}

str(pi:6:2,st); {строка st содержит 3.14}

val(''3,1415' ,x,y) ; {у содержит 2, х остался без изменения}

end.

Операции отношения =, о, >, <, >=, <= выполняются над двумя строками посимвольно, слева направо с учетом внутренней кодировки символов (см. табл.4.1 и прил.2). Если одна строка меньше другой по длине, недостающие символы короткой строки заменяются значением СНR(0) .

Следующие операции отношения дадут значение TRUE:

'''' < ' . '

'А' > '1'

'Turbo' <' Turbo Pascal'

'Паскаль' >'Turbo Pascal'

Файлы

  • Доступ к файлам
  • Имена файлов
  • Логические устройства
  • Инициация файла
  • Процедуры и функции для работы с файлами
  • Текстовые файлы
  • Типизированные файлы
  • Нетипизированные файлы

Под файлом понимается либо именованная область внешней памяти ПК (жесткого диска, гибкой дискеты, электронного «виртуального» диска), либо логическое устройство - потенциальный источник или приемник информации.

Любой файл имеет три характерные особенности. Во-первых, у него есть имя, что лает возможность программе работать одновременно с несколькими файлами. Во-вторых, он содержит компоненты одного типа. Типом компонентов может быть любой тип Турбо Паскаля, кроме файлов. Иными словами, нельзя создать «файл файлов». В-третьих, длина вновь создаваемого файла никак не оговаривается при его объявлении и ограничивается только емкостью устройств внешней памяти.

Файловый тип или переменную файлового типа можно задать одним из трех способов:

<имя> = FILE OF <тип>;

<имя> = TEXT;

<имя> = FILE;

Здесь <имя> - имя файлового типа (правильный идентификатор);

FILE, OF - зарезервированные слова (файл, из);

TEXT - имя стандартного типа текстовых файлов;

<тип> - любой тип Турбо Паскаля, кроме файлов.

Например:

type

product = record

name : String;

code : Word;

cost : comp

end;

textSO = file of String [80] ;

var

fl : file of char;

f2 : text;

f3 : file;

f4 : text80;

f5 : file of product;

В зависимости от способа объявления можно выделить три вида файлов:

  • типизированные файлы (задаются предложением FILE OF...);
  • текстовые файлы (определяются типом TEXT);
  • нетипизированные файлы (определяются типом FILE).

В наших примерах F1, F4 и F5- типизированные файлы, F2 - текстовый файл, F3 -нетипизированный файл. Вид файла, вообще говоря, определяет способ хранения информации в файле. Однако в Турбо Паскале нет средств контроля вида ранее созданных файлов. При объявлении уже существующих файлов программист должен сам следить за соответствием вида объявления характеру файла.

Доступ к файлам

Любой программе доступны два предварительно объявленных файла со стандартными файловыми переменными: INPUT - для чтения данных с клавиатуры и OUTPUT - для вывода на экран. Стандартный Паскаль требует обязательного упоминания этих файлов в заголовке программы, например, так:

PROGRAM NameOfProgram(input,output) ;

В Турбо Паскале это необязательно, вот почему заголовок программы можно опускать.

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

Файловая переменная связывается с именем файла в результате обращения к стандартной процедуре ASSIGN:

ASSIGN (<ф.п.>, <имя файла или л.у.>); .

Здесь <ф.п.> - файловая переменная (правильный идентификатор, объявленный в программе как переменная файлового типа);

<имя файла или л.у.> - текстовое выражение, содержащее имя файла или логическое устройство.

Если имя файла задается в виде пустой строки, например, ASSIGN(f, ' '), то в зависимости от направления обмена данными файловая переменная связывается со стандартным файлом INPUT или OUTPUT.

Процедуры и функции для работы с файлами

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

Процедура Close.

Закрывает файл, однако связь файловой переменной с именем файла, установленная ранее процедурой ASSIGN, сохраняется. Формат обращения:

CLOSE (<ф.п.>)

При создании нового или расширении старого файла процедура обеспечивает сохранение в файле всех новых записей и регистрацию файла в каталоге. Функции процедуры CLOSE выполняются автоматически по отношению ко всем открытым файлам при нормальном завершении программы. Поскольку связь файла с файловой переменной сохраняется, файл можно повторно открыть без дополнительного использования процедуры ASSIGN.

Процедура RENAME.

Переименовывает файл. Формат обращения:

RENAME (<ф.п.>, <новое имя>)

Здесь <новое имя> - строковое выражение, содержащее новое имя файла. Перед выполнением процедуры необходимо закрыть файл, если он ранее был открыт процедурами RESET, REWRITE или APPEND.

Процедура ERASE.

Уничтожает-файл. Формат обращения:

ERASE (<ф.п.>)

Перед выполнением процедуры необходимо закрыть файл, если он ранее был открыт процедурами RESET, REWRITE или APPEND.

Следующий фрагмент программы показывает, как можно использовать процедуры RENAME и CLOSE при работе с файлами. Предположим, что требуется отредактировать файл, имя которого содержит переменная NAME. Перед редактированием необходимо убедиться, что нужный файл имеется на диске, и переименовать его - заменить расширение этого файла на ВАК (страховочная копия). Если файл с таким расширением уже существует, его надо стереть.

var

fi : text; {Исходный файл}

fo : text; {Отредактированный файл}

name : String;

name_bak: String;

k, i: Word;

const

bak = '.bak';

begin

.......

{Получаем в name bak имя файла с расширением .ВАК:}

k := pos('.',name);

if k = 0 then

k := length(name) +1;

name_bak := copy(name,1,k-1) + bak;

{Проверяем существование исходного файла:}

assign(fi,name);

{$I-} ' reset(fi);

if lOResult <> 0 then

halt; {Завершаем программу: файла не существует}

close(fi); ,

{Проверяем существование .ВАК-файла:}

assign(fо,name_bak);

reset (fo);

{$I+}

if lOResult = 0 then

begin {Файл .ВАК существует:}

close(fo); {Закрываем его}

erase(fo) {и уничтожаем}

end;

{Проверки закончены, подготовка к работе:}

rename(f i,name_bak);

reset(fi);

assign(fo,name);

rewrite(fo);

.......

end.

Обратите внимание: проверка на существование файла .ВАК в данном примере необходима, так как обращение

rename(fi,name_bak);

вызовет ошибку в случае, если такой файл существует.

Процедура FLUSH.

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

FLUSH (<ф.п.>)

Любое обращение к файлу в Турбо Паскале осуществляется через некоторый буфер, что необходимо для согласования внутреннего представления файлового компонента (записи) с принятым в ДОС форматом хранения данных на диске. В ходе выполнения процедуры FLUSH все новые записи будут действительно записаны на диск. Процедура игнорируется, если файл был инициирован для чтения процедурой RESET.

Функция EOF (<ф. п. >) : BOOLEAN.

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

Процедура CHDIR.

Изменение текущего каталога. Формат обращения:

CHDIR (<путь>)

Здесь <путь> - строковое выражение, содержащее путь к устанавливаемому по умолчанию каталогу.

ПроцедураGETDIR.

Позволяет определить имя текущего каталога (каталога по умолчанию). Формат обращения:

GETDIR (<устройство>, <каталог>)

Здесь <устройство> - выражение типа WORD , содержащее номер устройства: 0 - устройство по умолчанию, 1 - диск А, 2 - диск В и т.д.;

<каталог> - переменная типа STRING, в которой возвращается путь к текущему каталогу на указанном диске.

Процедура MKDIR.

Создает новый каталог на указанном диске. Формат обращения:

MKDIR (<каталог>)

Здесь <каталог> - выражение типа STRING, задающее путь к каталогу. Последним именем в пути, т.е. именем вновь создаваемого каталога не может быть имя уже существующего каталога.^

Процедура RMDIR.

Удаляет каталог. Формат обращения:

RMDIR (<каталог>)

Удаляемый каталог должен быть пустым, т.е. не содержать файлов или имен каталогов нижнего уровня.

Функция IORESULT: WORD.

Возвращает условный признак последней операции ввода-вывода.

Если операция завершилась успешно, функция возвращает ноль. Коды ошибочных операций ввода-вывода представлены в прил.З. Следует помнить, что IORESULT становится доступной только при отключенном автоконтроле ошибок ввода-вывода. Директива компилятора {$I-} отключает, а директива {$I+} включает автоконтроль. Если автоконтроль отключен, а операция ввода-вывода привела к возникновению ошибки, устанавливается флаг ошибки и все последующие обращения к вводу-выводу блокируются, пока не будет вызвана функция IORESULT.

Ряд полезных файловых процедур и функций становится доступным при использовании библиотечного модуля DOS.TPU, входящего в стандартную библиотеку TURBO. TPL . Эти процедуры и функции указаны ниже. Доступ к ним возможен только после объявления USES DOS в начале программы (подробнее о работе с модулями см. гл.9).

Функция DISKFREE (<диск>) : LONGINT.

Возвращает объем в байтах свободного пространства на указанном диске. При обращении к функции выражение <диск> типа BYTE определяет номер диска: 0 - устройство по умолчанию, 1 - диск А , 2 - диск В и т.д. Функция возвращает значение -1, если указан номер несуществующего диска.

Функция DISKSIZE (<диск>) : LONGINT.

Возвращает полный объем диска в байтах или -1 , если указан номер несуществующего диска.

Процедура FINDFIRST.

Возвращает атрибуты первого из файлов, зарегистрированных в указанном каталоге. Формат обращения:

FINDFIRST (<маска>, <атрибуты>, <имя>)

Здесь <маска> - строковое выражение, содержащее маску файла;

<атрибуты> - выражение типа BYTE, содержащее уточнение к маске (атрибуты); <имя> - переменная типа SEARCHREC, в которой будет возвращено имя файла.

При формировании маски файла используются следующие символы-заменители ДОС:

* означает, что на месте этого символа может стоять сколько угодно (в том числе ноль) разрешенных символов имени или расширения файла;

? означает, что на месте этого символа может стоять один из разрешенных символов.

Например:

* . * выбирает все файлы из каталога;

с* . * выбирает все файлы с именами, начинающимися на с (cl.pas,сс!2345, c.dat и т.д.);

a?.dat выбирает имена файлов типа a0.dat, az.dat и т.д.

Маске может предшествовать путь'. Например, команда

с:\dir\subdir\*.pas

эзначает выбирать все файлы с расширением .PAS из каталога SUBDIR, находящегося на диске С; каталог SUBDIR зарегистрирован в каталоге верхнего уровня DIR, который, в свою очередь, входит в корневой каталог.

Байт <атрибуты> содержит двоичные разряды (биты), уточняющие, к каким именно файлам разрешен доступ при обращении к процедуре FINDFIRST . Вот как объявляются файловые атрибуты в модуле DOS. TPU:

const

Readonly = $01; {только чтение}

Hidden = $02; {скрытый файл}

SysFile = $04; {системный файл}

VolumeID = $08; {идентификатор тома}

Directory = $10; {имя подкаталога}

Archive =$20; {архивный файл}

AnyFile= $3F; {любой файл}

Комбинацией бит в этом байте можно указывать самые разные варианты, например $ 06 - выбирать все скрытые и/или системные файлы.

Результат работы процедуры FINDFIRST возвращается в переменной типа SEARCHREC. Этот тип в модуле DOS. TPU определяется следующим образом:

type

SearchRec = record

Fill : array [1..21] of Byte;

Attr : Byte;

Time : LongInt;

Size : LongInt;

Name : String.[12]

end;

Здесь Attr - атрибуты файла (см. выше);

Time - время создания или последнего обновления файла; возвращается в упакованном формате; распаковать параметр можно процедурой UNPACKTIME (см.ниже);

Size - длина файла в байтах;

Name - имя и расширение файла. Для распаковки параметра TIME используется процедура

UNPACKTIME(Time: Longlnt; var T:DateTime).

В модуле DOS. TPU объявлен следующий тип DateTime:

type

DateTime = record

year:Word; {год в формате 19ХХ}

month:Word; {месяц I..12}

day:Word; {день 1..31}

hour:Word; {час 0..23}

min:Word; {минуты 0..59}

sec:Word {секунды 0..59}

end;

Результат обращения к процедуре FINDFIRST можно проконтролировать с помощью функции DOSERROR типа WORD, которая возвращает значения:

0 - нет ошибок;

2 - не найден каталог;

18 - каталог пуст (нет указанных файлов).

Процедура FINDNEXT.

Возвращает имя следующего файла в каталоге. Формат обращения:

FINDNEXT (<сл.файл>)

Здесь <сл.фаш> - запись типа SEARCHREC (см. выше), в которой возвращается информация о файле.

Следующая простая программа иллюстрирует способ использования процедур FINDFIRST и FINDNEXT. Программа выводит на экран список всех PAS-файлов текущего каталога:

Uses DOS;

var

S: SearchRec;

begin

FindFirst('*.pas',AnyFile,S);

while DosError = 0 do begin

with S do

WriteLn(Name:12,Size:12);

FindNext(S)

end

end.

Процедура GETFTIME.

Возвращает время создания или последнего обновления файла. Формат обращения:

GETFTIME (<ф.п.>, <время>)

Здесь <время> - переменная типа LONGINT, в которой возвращается время в упакованном формате.

Процедура SETFTIME.

Устанавливает новую дату создания или обновления файла. Формат обращения:

SETFTIME (<ф.п.>, <время>)

Здесь <время> - время и дата в упакованном формате.

Упаковать запись типа DATETIME в переменную типа LONGINT можно процедурой

PACKTIME (var T:DateTime; var Time:LongInt).

(Описание типа DA TETIME см. выше).

Процедура GETFATTR.

Позволяет получить атрибуты файла. Формат обращения:

GETFATTR (<ф.п.>, <атрибуты>)

Здесь <атрибуты> - переменная типа WORD, в младшем байте которой возвращаются устанавливаемые атрибуты файла.

Процедура SETFATTR.

Позволяет установить атрибуты файла. Формат обращения:

SETFATTR (<ф.п.>, <атрибуты>)

Функция FSEARCH: PATHSTR.

Ищет файл в списке каталогов. Формат вызова:

FSEARCH (<имя>, <сп.каталогов>)

Здесь <имя> - имя отыскиваемого файла (строковое выражение или переменная типа PATHSTR; имени может предшествовать путь); <сп.каталогов> - список каталогов, в которых отыскивается файл (строковое выражение или переменная типа STRING); имена каталогов разделяются точкой с запятой.

Результат поиска возвращается функцией FSEARCH в виде строки типа PATHSTR. В строке содержится путь и имя файла, если поиск был успешным, в противном случае возвращается пустая строка.

Тип PATHSTR в модуле DOS.TPU объявлен следующим образом:

type

PathStr = String[79];

Следует учесть, что поиск файла всегда начинается в текущем каталоге и только после этого продолжается в тех, что перечислены в <сп.каталогов>. Если файл обнаружен, дальнейший поиск прекращается, даже если часть каталогов осталась непросмотренной. В частности, если файл зарегистрирован в текущем каталоге, он «заслонит» собой одноименные файлы в других каталогах.

Пусть, например, на диске имеется файл \SUBDIR\MYFILE.PAS. Тогда в случае, если текущий каталог - корневой, обращение

FSEARCH ('MYFILE,PAS','\SUB; \SUBDIR').

вернет строку \SUBDIR\MYFILE.PAS, а обращение

FSEARCH ('MYFILE.PAS1,'\SUB')

вернет пустую строку. Однако, если текущим установлен каталог SUBDIR, то в обоих случаях вернется строка MYFILE.PAS (если файл находится в текущем каталоге,в выходной строке путь к нему не указывается).

Процедура FSPLIT.

«Расщепляет» имя файла, т.е. возвращает в качестве отдельных параметров путь к файлу, его имя и расширение. Формат обращения:

FSPLIT (<файл>, <путь>, <имя>, <расширение>)

Здесь <файл> - строковое выражение, содержащее спецификацию файла (имя с расширением и, возможно, с предшествующим путем);

<путь> - переменная типа DIRSTR=STRING [67], в которой возвращается путь к файлу;

<имя> - переменная типа NAMESTR=STRING [8], в которой возвращается имя файла;

Наши рекомендации