Программирование на языке Object Pascal

Размещено на http://www.allbest.ru/

Элементы языка Object Pascal

Алфавит: буквы ((a-z) - верхний и нижний регистр), цифры, 16-тиричные цифры, специальные символы и зарезервированные слова. Pascal - не чувствителен к регистрам (а = А), арабские цифры (0 - 9), 16-тиричные цифры (0 - 9 - а - f), специальные знаки (=, +, -, *, /, , , `, :, ;, (, ), {, }, [, ], ^, @, $, #), пары символов (<=, >=, <>, :=, (*, *), .., _).

Пробел с кодом ASCII 0 - 32. Зарезервированные слова не могут использоваться в качестве идентификатора (название операции, функции, переменных, констант).

Директивы - связанные со стандартными объявлениями в программе, их нельзя использовать в качестве идентификаторов переменных программ.

{$1-} - отключить контроль ошибок ввода-вывода.

{$1+} - включить контроль ошибок ввода-вывода.

Идентификатор - имена (константы, метки), переменные (объекты, процедуры, функции, модули, программы…)

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

X1; 1X; _1X

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

Константы

Константа - переменная, не имеющая своего значения в ходе выполнения программы. Они бывают именные и неименные.

Именные - символ или набор символов с присвоенным им значением.

Неименные - любое число. Константы могут быть целого типа, вещественного, шестнадцатеричное число, вещественное число, логическая константа, символ, строка символов, конструктор множества и признак неопределенного показателя (NIL).

Целые числа - записываются со знаком (или без) в десятичной системе счисления, в диапазоне (от -10263 до 10-263 - 1), вещественное число, записанное в экспоненциальной форме имеет вид: (±#.###…# ) - мантисса, (E±###...#) - экспонента (порядок).

Экспоненциальный формат - формат с плавающей запятой.

250=(2,5*100)=2,5*E+2

E+2=102

0,0125=1,25* E-2

E-2=10-2

Шестнадцатеричное число:

Для их записи используются шестнадцатеричные числа, которым соответствует знак $ (00000000 = FFFFFFFF)

$10 =16

1 байт ($00 - $FF = 0 - 255)

Логические константы имеют два значения: истина (1) и лож (0), логические константы занимаю 1 байт, хотя задействован 1 бит.

Символьные константы (любой символ ASCII таблицы) 1 символ = 1 байт. Символы заключаются в апострофы (` '), а также допустима их запись, используя ASCII код (`ABC'=#65#66#67=`A'#66#`C'). В OPascal есть возможность работать с символами в системе кодирования Unicode (отличается от ASCII тем, что занимает 2 байта).

Конструктор множества - список элементов множества обрамленный в ([ ]): ([1.2-1.7],[red, green, blue], [ ]).

Выражения

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

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

Приоритет определяется в порядке убывания:

1). Унарные операции: +, -, not

2). Мультипликативные: *, /, mod, div(\), and, SHL, SHR

3). Аддитивные: +, -, or, xor

4). Операции отношения: =, <>, <, >, <=, >=, in

Структура управления операциями:

При запуске среды Delphi инициализируется новый проект (по умолчанию новый проект считается приложением, т.е. при его компиляции будут созданы исполнители _.exe файлы).

Delphi позволяет создавать и другие приложения: приложения Web, элементы приложения ActiveX…

Структура проекта Delphi

Проект состоит из нескольких типов файлов:

Файл проекта (расширение _.dpr)

Файл форм (расширение _.dfm)

Файл модулей (расширение _.pas)

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

Пример файла проекта (файл проекта создается автоматически):

Program Project1.

User

Forms, Unit1 in `Unit 1.pas' {Form 1}

Begin

Application. Initialize;

Application. Createform (TForm 1, Form 1);

Application. Run;

End;

В Delphi существует возможность создавать консольные приложения. Это создано для совместимости с программами на Pascal.

Program ABC;

{Appupe Console}

Uses

Begin

Write in (`Hello!');

End;

Среда Delphi предназначена для создания приложений, работающих над управлением Windows. Однако существуют возможности создавать приложения работающие под Dos. В Delphi предусмотрены средства для создания 32-разрядных консольных приложений, которые могут выполняться в MS-DOS. Для создания консольного приложения:

Файл \ new \ consol application

Структура модуля исходного кода

В OPascal исходный код каждой программы разбит на модули.

Модуль состоит из 4 разделов:

Обязательные:

1). Интерфейсный;

2). Раздел реализации;

Не обязательные:

3). Раздел инициализации;

4). Раздел завершения.

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

Unit имя модуля;

Interface;

Uses список модулей;

(1);

Implementation;

Uses список модулей;

(2);

Initialization;

(3);

Finalization;

(4);

End

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

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

Модули, из которых состоят приложения, делятся на: созданные разработчиком и созданные в Delphi.

Встроенные модули.

System - содержит основные функции Delphi, его не нужно подключать с использованием слова Uses, т.к. он подключается к каждому модулю по умолчанию.

Модули, подключенные к интерфейсному разделу по умолчанию, доступны в любом месте данного модуля. Модули, подключенные в разделе реализации, доступны во всем этом разделе за исключением интерфейсного раздела. В разделах инициализации и завершения расположен код, выполняемый только один раз, в начале и конце работы модуля. Если модулей в программе несколько, то последовательность выполнения их разделов инициализации соответствует порядку их следования после ключевого слова Uses. Разделы завершения выполняются в обратном порядке.

Структура программной единицы на языке OPascal

К программным единицам относятся: раздел описания, процедура, функция.

Все они имеют единую структуру:

<Объявление программной единицы>;

<Раздел описания>

Implementation (begin - для процедур и функций)

<Список исполняемых операторов>

End. (; - для процедур и функций)

Раздел описания состоит из (порядок следования различен):

1). Блок используемых модулей (uses <список модулей>);

2). Блок описания типов (type);

3). Описание пользовательских типов;

4). Описание констант (const <описание констант>);

5). Блок описания переменных (var <список переменных>);

6). Блок описания меток (label <список меток>);

7). Блок описания процедур и функций пользователя.

Любого из этих блоков может не быть (они не обязательны).

Программные единицы:

(Описание модуля)

Unit Unit 1;

Interface

Uses Windows, Massages, SysUnits, Classes, Forms;

Type

TForm 1 = class (TForm)

Button 1: TButton;

Label 1: TLabel;

Procedure Button 1 click (sender, TObject);

Var

Form 1: TForm 1;

x, y: integer;

s: string;

Const

n=100;

(1)

Procedure ABC;

Var

a: array [1…n] of byte;

Begin

For x:= 1 to n do

a[x]:=x;

end;

(Тело модуля)

Implementation

Procedure TForm 1. Button 1. Click (Sender: TObject);

Begin

Label 1. Caption := `Hello!';

ABC;

end;

END.

Операторы языка OPascal

1). Присваивание (:=): <переменная>:=<выражение>;

2). Пустой оператор (;): (ставится после вызова каждого оператора или процедуры функции);

Составной оператор - последовательность произвольных операторов программы, заключенная в операторные скобки:

Begin

…

End

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

Условный оператор:

If <условие> then <оператор 1> [else <оператор 2>]…

If x>0 then y:=3

Else

Begin

x:= ABS(x);

y:= SQR(x);

End.

Операторы повторения

Цикл со счетчиком:

For <параметр> = <начальное значение> to/down to <конечное значение> do <оператор>;

В операторе For на каждом шаге цикла происходит увеличение/уменьшение (по умолчанию) параметра цикла на 1. Параметром цикла может быть только переменная порядкового типа.

Вещественные типы имеют конечное число значений, которое определяется форматом внутреннего представления числа.

Любому из порядковых типов применима функция:

ORD(x) - которая возвращает порядковый номер значения;

PRED(x) - возвращает предыдущее значение;

SUCC(x) - возвращает следующее значение.

Оператор цикла с предусловием.

While <условие> do <оператор>;

Оператор выполняется до тех пор, пока условие истинно.

Procedure ABC

Var

i, n: integer;

Begin

n:= 100;

i:= 0;

While i<=n do begin

i:= i+2;

Memo1. (.nes. Add (IntToStr (i)));

End;

End.

Программа выводит все четные числа от 0 до 100.

Оператор цикла с пост условием.

Repeat

<список операторов>

Until <условие>;

Список операторов выполняется пока условие ложно.

Var

s, i, n: integer;

Begin

s:= 0;

n:= 100;

i:= 0;

Repeat

i:= i + 1;

s:= s + 1;

Until i = n;

Memo1. Lines. Add (`s=' + IntToSrt (s));

End;

Программа вычисляет сумму чисел натурального ряда до (n).

Оператор выбора.

Case <ключ выбора> of

<список выбора>;

[else <оператор>];

End;

Этот оператор позволяет выбрать одно из нескольких возможных продолжений программы.

Параметром, по которому осуществляется выбор, служит ключ выбора. (Это выражение любого порядкового типа).

Список выбора - одна или более конструкций вида:

<константа выбора 1>: <оператор 1>;

.

.

<константа выбора N>: <оператор N>;

Константа выбора должна быть того же типа, что и ключ выбора.

Оператор Case работает в следующем порядке:

· Вычисляется выражение (ключ выбора);

· В последовательности операторов находится такой, которому предшествует константа, равная вычисленному значению;

· Найденный оператор выполняется, после чего Case завершает работу.

Если в списке выбора не найдена константа соответствующая ключу, управление передается оператору, который следует за else. Часто операторы, включающие в себя else можно опустить и тогда, при отсутствие нужной константы, ничего не произойдет и Case завершает свою работу.

Procedure Calk (a, b: integer);

Var

c: integer;

op: char;

Begin

op:= edit: text;

Case op of

`+' c:= a + b;

`-' c:= a - b;

`*' c:= a * b;

`/' c:= a dir b;

Else begin

Memo1.Lines.Add (`указан неверный арифметический оператор');

Exit

End;

End;

Memo1.Lines.Add (`c='+IntToStr(c));

End;

Процедура имитирует процедуру арифметического калькулятора.

Метки и оператор перехода go to.

Go to <метка>;

Этот оператор позволяет передать управление оператору, следующему за меткой.

Метка располагается, непосредственно, перед оператором, которому передается управление и отделяется от него (:). Перед появлением в коде программы, метка должна быть объявлена в блоке описания (label). Метка, описанная в блоке label, обязательно должна быть объявлена.

Метки, объявленные в процедуре или функции, локализуются в ней, поэтому передача управления извне процедуры или функции на внутреннюю метку невозможна.

Go to <метка>;

Procedure ABC;

Var

i: integer;

Label

Metka1, ab

Begin

…

Metka1:

…

Go to ab;

…

ab:

…

End;

Типы данных языка OPascal

Любые константы, переменные и значения функций OPascal характеризуются своими типами. Тип определяет множество допустимых значений, которые можно иметь тот или иной объект, а так же множество операций допустимых над этим объектом. Тип определяет формат представления переменной или константы в память ЭВМ.

I. Простые:

1). Порядковый тип.

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

Ш Целый тип.

Диапазон возможных значений целых типов зависит от их внутреннего представления, которое может занимать в памяти: 8, 16, 32, 64 бита.

Тип	Диапазон	Размер (в битах)
Shortint	-128…127	8 (со знаком)
Smallint	-32768…32767	16 (со знаком)
Integer	-2147483648…2147483647	32 (со знаком)
INT64	?-10263…10263-1	64 (со знаком)
Byte	0…255	8 (без знака)
Word	0…65535	16 (без знака)
LongWord	0…4294967295	32 (без знака)

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

Функции применимые к целым типам:

ABS(x) - возвращает модуль числа;

CHR(x) - возвращает символ с ASCII кодом;

Inc(x,[i]) - увеличивает переменную x на значение i;

DEC(x,[i]) - уменьшает переменную x на значение i;

HI(x) - возвращает старший байт аргумента;

LO(x) - возвращает младший байт аргумента.

В памяти ЭВМ младший и старший байт хранятся в обратном порядке.

2 байта составляют машинное слово.

2 машинных слова составляют 2-ное слово.

Машинное слово состоит из старшего и младшего слова, которые в памяти хранятся в обратном порядке.

ODD(x) - возвращает (истина), если аргумент не четное число и (ложь) - если четное;

Random(x) - возвращает случайное число в диапазоне от 0 до x;

SQR(x) - возвращает квадрат числа (x);

Swap(x) - меняет местами старший и младший байт аргумента.

При действие с целыми числами, тип результата соответствует типу операнда, если операнды имеют разный тип, то тип результата будет соответствовать типу операнда с максимальным запасом значения. OPascal не контролирует возможные переполнения выполнения операции.

Ш Логический тип.

Значением логического типа может быть одна из двух констант: false(0), true(1).

Pred(true)=false

Suck(false)=true

Типы данных:

Boolean(bytebool) - false, true = 8 бит

Word bool - false, true 16 бит

Long bool - false, true 32 бита

Логический тип является порядковым и может быть использован в качестве параметра четного цикла.

Логические операции допустимые над этими числами:

Not - инвертирует значения (false true)

Or - оператор выбора (false или true)

And - оператор объединения (false и true)

Xor - обратно инвертирует значения (true false)

Ш Символьный тип.

Значением символьного типа является множество всех символов персонального компьютера, каждому символу соответствует его код (0-255 (код ASCII), 0-65535 (код Unicode)).

Для кодирования основных и управляющих символов достаточно 7 бит (1 половина таблицы ASCII).

Кодируется значение 0-127. Эта часть является стандартной и неизменной для всех персональных компьютеров. Управляющие коды имеют значение 0-32.

Символьный тип - Char 1 байт (ASCII), Wide Char 2 байта (Unicode):

Var

X:=Char;

Y:= Wide Char;

…

x:= `a'

y:= `b'

For x= `a' to z do

Для символьного типа определены следующие функции:

Chr(x) - возвращает символ ASCII кода = x

Ord(x) - возвращает код определенного символа x

Apcase(x) - переводит в верхний регистр значение x

Locase(x) - переводит в нижний регистр значение x

Значение функций Apcase и Locase работают только для символов латинского алфавита.

Ш Перечисляемый тип.

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

Соответствие между значениями перечисляемого типа и их порядковыми номерами устанавливается порядком перечисления. Первое значение имеет номер 0. Максимальная мощность 65535.

Порядковые типы объявляются в блоке описания типов:

Type

Имя типа (идентификатор1, идентификатор2…)

Day=(mon, tue, wen, thu, fri, sat, sun);

Color=(white, red, black);

Var

x:=day;

c:=color;

…

Begin

x:=tue

y:=red

For x:=mon to fri do …

Ш Тип диапазон.

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

Синтаксис записи:

Type

Имя типа = <минимальное значение>..<максимальное значение>;

Оценка = <1..5>

Цифра = <0..9>

Малая буква = <a..z>

Day2 = <tue..wed>

Тип диапазон также может быть объявлен в разделе описания переменных:

Var

X:=otcenka;

Y:=2..5;

Правила записи типа диапазона:

1). Двойная точка воспринимается как единый символ без пробела;

2). Левая граница диапазона не должна превышать правую;

3). Тип диапазон использует все свойства базового типа, но с ограничением связанным с меньшей мощностью.

2). Вещественный тип.

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

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

Встроенные функции для работы с вещественными числами:

Abs(x) - модуль (x);

Cos(x) - косинус (x);

Sin(x) - синус (x);

Exp(x) - экспонента;

Pi - возвращает число р;

Sqrt(x) - квадратный корень из (x);

Ceil(x) - возвращает наименьшее целое большее или равно (x);

Floar(x) - возвращает наибольшее целое меньшее или равное (x);

Frac(x) - возвращает дробную часть числа типа Extended;

Int(x) - возвращает целую часть числа (округляет);

IntPower(x,y) - возводит число (x) в степень (y);

Ldxep(x) - ex*р;

Ln(n) - натуральный логарифм числа (x);

Ln(xp1) - Ln(x+1) - натуральный логарифм от числа (x+1);

Log10(x) - 10-ный логарифм числа (x);

Log2(x) - 2-ичный логарифм числа (x);

LogN(n,x) - Lognx;

max(x,y) - нахождение максимального;

min(x,y) - нахождение минимального;

Power(x,y) - возводит в степень (y) число (x) (с дробными степенями);

Randomize - включает генератор случайных чисел;

Trunk(x) - отсекает дробную часть;

Rondom(x) - (x) - целое число (0..x);

Round(x) - округляет вещественное значение до ближайшего целого (результат имеет тип Int64; если число ровно по середине, то результат всегда четный);

Random - возвращает случайное вещественное число (0..1);

Название:	Диапазон:	Количество значений 10-ных чисел:	Размер (в битах):
Real 48 Single Real (Double) Extended Currency	От 2,9*10-19 до 1,7*1038 От 1,5*10-45 до 3,4*1038 От 5,0*10-324 до 1,7*10308 От 3,6*10-4951 до 1,1*104938 От -9*1014,### до 9*1014,###	10-12 7-8 15-16 19-20 19-20	32 48 69 80 64

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

Любая переменная структурированного типа всегда имеет несколько компонентов. Структурированные типы могут быть вложенными. Ограничений на суммарную длину структурированного типа не накладываются. Компилятор OPascal автоматически компактно хранит все структуры в памяти.

1). Массивы.

Массивы бывают двух типов: статические и динамические.

Ш Статические.

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

Синтаксис записи:

Type

Имя типа = array [диапазон 1, [диапазон 2]…] of тип;

Пример:

Type

Vector = array [1..10] of byte;

Mass1 = array [2..4] of extended;

Matrix = array [0..5,1..20] of int 64;

Var

a,b:vector;

x:matrix;

z:array [1..15] of bualean;

Если массивы имеют одинаковый тип a=b, то значение массива b переходит в массив a.

a:=b

Все массивы хранятся в памяти линейно. Для обращения к элементу массива используют: [ ].

a[3]:=2;

x[0.17]:=a[2]/4;

Ш Динамические массивы.

Динамический массив может менять в ходе выполнения программы размер.

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

Var

Имя: array of тип;

Многомерный динамический массив задается аналогично статическому, но без указания границы:

Var

A: array of byte

Задание размера массива и выделение для него памяти выполняется с помощью процедуры: SetLenght (имя, длина) длина - выражение целого типа. После выполнения этой процедуры выделяется память под этот массив и его индекс может измениться от 0 до -1.

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

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

Var

A: array of array of int64;

Begin

Set length (a; s);

a[1]:=1; [???]

a[2]:=2; [312]

a[3]:=3;

SetLenght (a;2); [31]

SetLenght (a;3); [31?]

Организуется с использованием динамической памяти массива.

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

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

1). Установка длинны динамического массива в (0)

SetLenght (имя; 0);

2). Присвоение значению длины массива nil:

имя:= nil;

3). Присвоение имени finalize (имя);

В OPascal для работы с динамическими массивами предусмотрены встроенные функции:

Copy (имя, начальный индекс, количество элементов) - восстановление начального имени;

High - возвращает максимальное значение индекса массива;

Low - возвращает букву названия массива.

Многомерный динамический массив - представляется как массив из массивов:

Var

A: array of array of byte

Begin

Setlength (a; 4);

Setlength (a [0]; 3); [???]

Setlength (a [1]; 1); [?]

Setlength (a[2];2); [??]

Setlength (a[3];5); [?????]

2). Записи:

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

Описание структуры записи происходит в разделе (type).

Type

Имя = record;

Список полей;

End;

Список полей представляет собой последовательность разделов записи следующего вида:

Имя1: type1;

Имя2: type2;

Имя3: type3;

Type

Student = record

FIO: string;

Gr: word;

Pol: Boolean;

Gruppa: string [10];

Rost: real;

Ves: real;

End;

...

Var

A: student;

Begin

A.FIO: `Иванов Иван Иванович';

A.Gr: 1987;

A.Pol: true;

...

With A do begin

Rost:= 180.5;

Ves:=98.2;

End;

… Доступ к каждому из компонентов записи осуществляется с использованием спецификатора.

Структура записи спецификатора:

спецификатор 1. [спецификатор 2 ...] идентификатор.

В данном случае спецификатором будет переменная типа (student), а идентификатором (pole).

… Для упрощения доступа к полям записи используются оператор:

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

Записи с вариантными полями

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

Модифицируем запись студент для хранения информации о местных студентах и приезжих, т.е. проживающих о общежитии:

Местные: улица, дом, квартира.

Приезжие: номер комнаты.

Type

Student = record;

FIO: string;

Gr: word;

Pol: Boolean;

Gpuppa: string [10];

Rost: real;

Ves: real;

Case mesting: Boolean of

True: (ul: string [20]; dom: string [5]; kv: word);

Fals: (N_Komn: word);

End;

End;

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

В памяти, запись хранится линейно.

Синтаксис записи:

Имя = record

Список полей:

Case <поле переключатель> : <тип> of

Вариант 1:(поле1: тип1;… полеN: типN);

End;

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

Ячейка (Название улицы или № комнаты) самая большая по количеству байтов.

3). Множества.

Множества - наборы однотипных, логически связанных друг с другом объектов. Характер связи между ними контролируется только программистом, а не компьютером. Максимальное количество элементов в множестве 256 минимальное 0.

Множества отличаются от массивов и записей непостоянством своих элементов. Элементы могут включаться в множество и выключаться из него. Механизм работы и множествами в Delphi схож с механизмом работы в математике.

Два множества считаются равными - если они содержат одинаковые элементы.

A {a, b, c, x}

B {c, x, y}

Пересечением - называются общие элементы двух множеств.

A ? B = {c, x} - пересечение.

A U B = {a, b, c, x, y} - объединение.

C = { } - пустое множество.

Если все элементы одного и того же множества входят в другое, то говорят, что A входит в B.

Формат записи множеств:

Type

<имя>= set of <базовый тип>

В качестве базового типа может использоваться любой подходящий тип кроме integer, int 64 …

Type

Mnozh = set of `a'…`z';

Var

S1, s2, s3: mnozh

Begin

S1:= [`a', `b', `t', `x'];

S2:= [`a'..`k', `x'..`z'];

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

* - пересечение; s1*s2 [`a', `b', `x']

- - разность; s1-s2 [`t']

= - проверка эквивалентности (возвращает true, если они эквивалентны);

<> - проверка не эквивалентности (возвращает true, если они эквивалентны);

+ - объединение множеств;

<= - проверка вхождения (возвращает true, если s1 входит в s2);

[s1<=s2]

>= - проверка вхождения (возвращает true, если s2 входит в s1);

[s1>=s2]

in - проверка принадлежности (возвращает true, если указанный элемент входит в множество);

<элемент> in <множество>

Некоторые алгоритмы для работы с массивами:

1) Заполнение массива случайными числами:

Var

a: array of integer;

i: integer;

Begin

Randomize;

Setlength (a, 10);

For i = 1 to n-1 do

a[i]:= random (101);

End;

s := (k * si-1) mod N,

где k - начальное значение (стартовое число).

2) Алгоритм поиска минимального и максимального элемента массива:

Var

a: array of integer;

i: integer;

min, max, n: integer;

nmin, nmax: integer;

Begin

N:= 10

Setlength (a, n);

For i = 1 to n-1 do

a[i]:= random (101);

End;

Max:= a[0]; nmax:= 0;

Min:= a[0]; nmin:= 0;

For i:= 1 to n-1 do begin

if a[i] > max then begin

max:= a[i];

nmax:= i;

End;

if a[i] < min then begin

min:= a[i];

nmin:= i;

End;

End;

End;

3) Алгоритм сортировки массива:

Существует множество способов сортировки массива:

· Метод min или max элемента;

· Метод пузырька;

· Метод Шелла;

· Метод бинарного поиска;

· ...

Метод min или max элемента:

Const

n = 100

Var

a: array [1..n] of integer;

temp, max, nmax, i, j: integer;

Begin

n:= 100

Setlength (a, n);

For i := 1 to n-1 do

a[i]:= random (101);

End;

max:= a[1], nmax:=1;

For i:= 1 to n-1 do begin

For j:= 2 to n do

if max < a[j] do begin

max:= a[j];

nmax:= j;

End;

if max > a[i] then begin

temp:= a[i];

a[i]:= max;

a[nmax]:= temp;

End;

max:= a[i+1];

nmax:= i+1;

End;

End;

End;

4) Алгоритм исключения элементов из отсортированного массива:

Var

a: array of byte;

n, n1, p, x, i: integer;

Begin

n:= 100

SetLenght (a, n);

For i = 1 to n-1 do

a[i]:= random (101);

End;

max:= a[1], nmax:=1;

For i:= 1 to n-1 do begin

For j:= 2 to n do

if max < a[j] do begin

max:= a[j];

nmax:= j;

End;

if max > a[i] then begin

temp:= a[i];

a[i]:= max;

a[nmax]:= temp;

End;

max:= a[i+1];

nmax:= i+1;

End;

End;

d:= 7; [исключенный элемент]

p:= -1;

For i:= 0 to n-1 do

if x=a[i] then p:=i;

if p=-1 then begin

ShowMessage (`такой элемент отсутствует');

Exit;

End;

For i:= p to n-1 do

a[i]:= a [i+1];

SetLenght (a,n-1);

End;

End;

5) Добавление элемента в отсортированный массив:

Var

a: array of integer;

n, p, x, i: integer;

Begin

n:= 100

SetLenght (a, n);

For i = 1 to n-1 do

a[i]:= random (101);

End;

max:= a[1], nmax:=1;

For i:= 1 to n-1 do begin

For j:= 2 to n do

if max < a[j] do begin

max:= a[j];

nmax:= j;

End;

if max > a[i] then begin

temp:= a[i];

a[i]:= max;

a[nmax]:= temp;

End;

max:= a[i+1];

nmax:= i+1;

End;

End;

x:= StrToInt (Edit1. text);

If x<= a[0] then

Begin

SetLenght (a, n+1);

For i:=n-1 down to 0 do

a[i+1]:=a[i];

a[0]:=x

End;

if x>a [n-1] then begin

SetLenght (a, n+1);

a[n]:=x;

End;

If (x>=a[0]) and (x<=a[n-1]) then begin

For i:= 0 to n-2 do

if (x>=a[i]) and (x<=a[i+1]) then

p:= i+1;

For i:= n-1 down to p do a[i+1]:= a[i]

a[p]:=x

End;

End;

6) Пример алгоритма работы с множествами:

Программа выделяет из 1 сотни натуральных чисел (все простые числа). Алгоритм заимствован из приема “Решето Эратосфена”.

Const

N=100;

Type

SetOfNamber = set of 1..n;

Var

n1, next, i: word;

BeginSet, PrimSet: SetOfNamber;

Begin

BeginSet:= [1..n];

PrimSet:=[1];

Next:= 2;

While begin set <> [ ] do begin

n1:=next;

While n1<=n do begin

BeginSet:=BeginSet - [n1];

N1:= n1+next;

End;

PrimSet:=PrimSet+[next];

Repeat

Ine(next);

Unit(next in BeginSet) or (next>n);

End;

7) Заполнение случайным образом двумерного массива (матрицы):

Var

a: array [1..n; 1..m] of byte

For i:=1 to n do

For j:= 1 to m do

a[i, j]:= random (11);

Совместимость и преобразование типов.

Два типа являются совместными если:

· Оба одинаковы;

· Один тип является типом-диапазоном другого;

· Оба вещественны;

· Оба целые;

· Оба являются типами-диапазонами одного и того же базового типа;

· Оба являются множествами, составленными из элементов одного и того же базового типа.

Пусть t1 - тип переменной, а t2 - тип выражения. Операция t1:=t2 возможна, если выполняются перечисленные 6 правил и t1,t2 - не являются файлами, массивами файлов и записями, содержащими поля файлов. А так же диапазон t2 лежит внутри диапазона t1. Или существует функция преобразования типов.

t1:=t2, [где t1: integer; а t2: real ]

[integer:= round(real)]

4). Файлы.

Под файлами понимается либо именованная область внешней памяти ПВЭМ, либо логическое устройство, которое является потенциальным источником или приемником информации (адаптер интерфейса - USB…).

Любой файл имеет три характерных особенности:

1. он обладает именем (это дает возможность работать одновременно с несколькими файлами в программе);

2. он содержит компоненты одного и того же типа (типом может быть любой тип OPascal кроме файла);

3. длина файла в OPascal не регламентируется (ограничение накладывает только емкость внешнего устройства).

По способу организации файлы делятся на:

1. файлы прямого доступа;

2. файлы последовательного доступа.

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

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

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

В OPascal существует три типа файлов:

1. текстовые;

2. типизированные;

3. не типизированные.

Типизированные файлы являются файлами прямого доступа, а не типизированные и текстовые - файлы последовательного доступа.

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

Любые файлы и логические устройства становятся доступны в модуле после процедуры открытия.

Эта процедура заключается:

1. в связывании ранее объявленной файловой переменной с именем файла;

2. в открытии файла для чтения и (или) записи.

Файловая переменная (дескриптор файла).

Объявление файловой переменной.

Var

F: TextFile; {текстовый файл}

F1: file of integer; {типизированный файл}

F2: file of string [20]; {типизированный файл}

F3: file; {не типизированный файл}

AssignFile - процедура связывания файловой переменной с именем файла:

AssignFile (<файловая переменная>, <имя файла или логическое устройство>);

Пример:

AssignFile (f, `c:\alpha.txt');

AssignFile (f1, `PRN');

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

Логические устройства в OPascal

К ним относятся стандартные аппаратные средства (клавиатура, экран, принтер, коммуникационные каналы). Аппаратные средства определяются специальными именами и называются логическими устройствами:

CON - консоль (клавиатура / экран; допустима передача в двух направлениях);

PRN - принтер (допустима передача в одном направлении);

COM 1 = (AUX) - последовательный интерфейс;

COM 2 - последовательный интерфейс;

LPT 1 - параллельный интерфейс;

LPT 2 - параллельный интерфейс.

Инициализация файла

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

1. reset (<файловая переменная>); - открытие файла для чтения;

2. rewrite (<файловая переменная>); - открытие файла для записи (при открытии rewrite файл стирается и создается заново).

3. append (<файловая переменная>); - открытие файла для записи (при открытии append происходит добавление в файл; работает только для текстовых файлов).

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

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

Закрытие осуществляется с помощью процедуры CloseFile (<файловая переменная>).

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

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

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

Eof(<файловая переменная>); - возвращает true если достигнут конец файла;

Eoln(<файловая переменная >); - возвращает true если достигнут конец строки;

SeekEof(<файловая переменная >); - возвращает true если до конца файла остались только символы разделители (` ', tab);

SeekEoln(<файловая переменная >);- возвращает true если до конца строки остались только символы разделители (` ', tab);

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

Erase(<файловая переменная >); - процедура стирает файл (перед стиранием необходимо закрыть файл);

Flush(<файловая переменная >); - процедура очищает внутренний буфер файла (при этом все изменения сохраняются на диске);

ReName(<файловая переменная >,<новое имя>); - процедура переименовывает файл…

Процедуры чтения записей:

Read(<файловая переменная >,<список вывода>); - читает информацию из файла;

ReadLn(<файловая переменная >,<список вывода>); - читает информацию из файла;

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

WriteLn(<файловая переменная >,<список ввода>); - записывает информацию в файл.

Ш Текстовые файлы.

Текстовые файлы связываются с файловыми переменными, принадлежащими стандартному типу TextFile, используются для хранения текстовой информации. В файлах такого типа так же могут храниться целые вещественные числа. Запись текстового файла имеет переменную длину, поэтому файлы такого типа относятся файлам последовательного доступа. При создании текстового файла, в конце каждой строки автоматически ставится специальный символ, который называется EoLn, который состоит из 2-х байтов.

В конце файла ставится специальный символ Eof.

Текстовые файлы открываются с помощью трех процедур:

Reset - для чтения;

RewRite - для записи;

Append - для добавления.

Чтение осуществляется с помощью процедуры Read и ReadLn, запись - Write и WriteLn.

Пример:

WriteLn(f,`ABC';12;`x';0,5); [ABC12x5E-1]

При переводе переменных типа String количество считываемых процедурой и помещенных в строки символов равно максимальной длине строки, если раньше не встретится признак EoLn; этот признак в строку не помещается. Если количество символов во входном потоке данных больше максимальной длинны строки, то лишние символы отбрасываются. При вводе числовых переменных процедура Read работает следующим образом: все ведущие знаки разделители и признаки конца строк пропускаются до появления первого значащего символа (и наоборот: любой из перечисленных символов, а так же признак конца файла считается концом подстроки). Выделенная таким образом подстрока рассматривается как строковое выражение числовой переменной; затем она конвертируется во внутреннее представление числа и результат присваивается переменной.

Ansistr = 256 символов.

WriteStr = 4 Гб.

` ' a b c ` ' EoLn ` ' ` ' ` ' 209 ` ' EoLn 2 ` ' 3 ` ' a5 ` '2,5 Eof

Var

F: TextFile;

S: string;

S2: string [2];

a, b, c: integer;

x: real;

Begin

AssignFile (f,`c:\FEI\alpha.txt');

Reset(f);

ReadLn(f,s) [s=`_abc ']

Read(f,a); [a=209]

Read(f,b,c); [b=2 c=3]

Read(f,x); [ошибка a5 перевести нельзя]

End;

Работа с текстовыми файлами.

1)._Пример Вывод текстового файла на экран:

Procedure TForm1.Button1.Click (…);

Var

F: TextFile;

S: string;

Begin

AssignFile(f,`c:\alpha.txt');

Reset(f);

While not Eof(f) do begin

ReadLn(f, s);

Memo1.Lines.Add(s);

End;

End;

Если в конвертируемой строке был нарушен требуемый формат - возникнет ошибка ввода / вывода.

Процедура Write и WriteLn обеспечивает вывод информации в текстовый файл. Список вывода аналогичен процедуре Read, за исключением числовых значений, для которых существует специальный формат: элемент [:m [: n]];

m - минимальная ширина поля, в которое будет помещен элемент;

n - максимальное количество знаков после ( , ).

Процедура WriteLn аналогична процедуре Write, но в конце добавляется признак конца строки.

2)._Пример Слияние двух текстовых файлов в третий:

Procedure TForm1.Button1.Click (…);

Var

f1, f2, f3: TextFile;

s: string;

Begin

AssignFile (f1,`c:\Fei\alpha1.txt');

AssignFile (f2,`c:\Fei\alpha2.txt');

AssignFile (f3,`c:\Fei\alpha3.txt');

Reset(f1);

Reset(f2);

Reset(f3);

While not Eof(f1) do begin

ReadLn(f1,s);

WriteLn(f3,s);

End;

While not Eof(f2) do begin

ReadLn(f2,s);

WriteLn(f3,s);

End;

CloseFile(f1);

CloseFile(f2);

CloseFile(f3);

ShowMessage(`OK!');

End;

Обработка ошибок при работе с файлами

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

{<обозначение>,<+ или ->}:

отключить контроль ошибок ввода / вывода: {I-};

включить контроль ошибок ввода / вывода: {I+}.

Если делается попытка чтения несуществующего файла или логического устройства, то возникает ошибка времени выполнения (from time error). Тип ошибки можно определить с помощью использования встроенной функции - IOResult: word; (эта функция возвращает результат последней операции ввода / вывода; если операция прошла успешно, функция возвращает (0), иначе возвращает код ошибки ввода / вывода).

Для использования этой функции необходимо отключить контроль ошибок ввода / вывода.



Procedure TForm1.Button1.Click (…);

Var

F: TextFile;

S: string;

Begin

AssignFile (f, Edit1.Text);

{I-}

Reset(f);

If IOResult<>0 then begin

ShowMessage (`неверное имя файла');

Exit;

End;

{I+}

While not Eof(f) do begin

ReadLn(f,s);

Memo1.Lines.Add(s);

End;

End;

В Delphi существуют объекты для работы с файлами. В частности объекты TOpenDialog и TSaveDialog. Эти объекты позволяют открывать и использовать стандартные диалоговые окна открытия и сохранения файла.

Вызов диалогового окна осуществляется с помощью метода ExeCute: Boolean; (который возвращает true если окно открывалось успешно и false в противном случает).

3)._Пример Открытие файла:

…

if OpenDialog1.Execute then begin

AssignFile (f,OpenDialog.FileName);

…

Reset(f);

End;

4)._Пример Процедура подсчитывает количество строк и символов в текстовом файле:

Procedure TForm1.Button1.Click(…);

Var

f: TextFile;

s: string;

i, k: int64;

Begin

AssignFile(f,'alpha.txt');

Reset(f);

k:=0;

i:=0;

While not Eof(f) do begin

ReadLn(f, s);

inc(i);

k:= k + length(s);

End;

memo1.Lines.Add (`alpha.txt содержит' + IntToStr(k) + `символов' + `и'+IntToStr(i) + `строк');

End;

Использование объекта TStringList (набор строк и является потомком объекта TStrings, каждая строка имеет свой индекс, к ней можно обратиться с помощью свойства *.strings[i] - i - необходимая строка).

Пример:

Var

T: TStringList;

...

Procedure TForm1.Button1.Click(...);

T:=TStringList.Create(...);

T.LoadFromFile (`c:\alpha.txt');

Memo1.Lines.Add(t.StringList[0]);

Memo1.Lines.Add(t.StringList[1]);

...

// по окончании работы объект t надо уничтожить

t.Free;

End;

Методы объекта StringList:

*.Count - возвращает количество строк в этом объекте;

*.SaveToFile - позволяет скинуть объект в файл.

Ш Типизированные файлы.

Длинна, любого компонента типизированного файла, постоянна, что дает возможность организовать прямой доступ к каждому из них. Каждая запись файла может быть доступна путем указания ее порядкового номера. После открытия файла, указатель стоит в его начале и указывает на первый компонент с номером (0). После каждого чтения или записи указатель смещается на одну позицию, т.е. на одну запись. Перемещение в списках ввода / вывода процедур read / write должны иметь тот же тип, что и компоненты файла (работает правило приведения типов). Если переменных в списках ввода / вывода несколько, то указатель будет смещаться после каждой операции обмена данными между переменными и фалом.

Работа с типизированными файлами

1)._Пример Объявление типизированного файла:

Var

F: file of integer;

T: file of string [20];

A: integer;

B: byte;

C: int64;

X: string [20];

...

Procedure TForn1.Button1.Click (...);

Begin

AssignFile(f,`c:\int.dat');

AssignFile(f,`c:\string.txt');

ReWrite(f);

ReWrite(t);

Write(f,a,b);

Write(t,x,`abcdef');

Reset(f);

Reset(t);

Read(f,c);

Read(t,x);

Write(t,`stuvw');

End;

Процедура Reset применима к типизированным файлам, открывает как для записи, так и для чтения одновременно. ReWrite работает аналогично текстовым.

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

Seek(<файловая переменная>,<номер записи>); - процедура смещает указатель файла к требуемой записи.

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

<номер записи> - выражение типа int64 содержащее номер записи.

FileSize(<файловая переменная>):int64; - функция возвращает количество записей в файле.

SizeOf(<экземпляр структуры>); - позволяет определить размер объекта:

Var

Z: word; [2]

...

FileSize(z);

...

FilePos(<файловая переменная>):int64; - функция возвращает порядковый номер записи, которая будет обработана следующей операцией ввода / вывода:

2)._Пример Создание базы данных содержащих информацию о погоде (база данных состоит из одной таблицы):

Месяц	День	0С	Скорость ветра	Направление ветра
byte	byte	real	real	String[3]

Type

Pogoda=recode;

m:bute;

d:bute;

t:real;

sv:real;

nv:string[3];

End;

Var

f:file of pogoda;

a,b:pogoda;

i:int64;

Procedure TForm1.Button1.Click(...);

{заполнение файла}

AssignFile(f,`c:\pogoda.dat');

ReWrite(f);



Procedure TForm1.Button2.Click(...);

{просмотр файла}

Reset(f);

While not Eof(f) do begin

Read(f,b);

i=i+1;

With StringGrid1 do begin

Cells[1,i]:=IntToStr(b.m);

Cells[2,i]:=IntToStr(b.d);

Cells[3,i]:=FloatToStr(b.t);

Cells[4,i]:= FloatToStr(b.sv);

Cells[5,i]:=b.nv;

End;

End;

End;

Ш Не типизированные файлы (бинарные).

Объявляются как переменные типа файл:

Var

f:file;

…

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

ь Эти файлы совместимы с любыми другими;

ь Высокая скорость обмена данными между диском и памятью.

Инициализация не типизированного файла осуществляется процедурами Reset и ReWrite:

Reset(<файловая переменная>[,<длинна записи>]);

Длинна записи не типизированного файла измеряется в байтах и по умолчанию равна 128 байт.

Тип данных Word(<длинна записи>) - 0..65535 максимальная длинна записи 64 Кбайт. Delphi не накладывает ограничений на длину записи не типизированного файла, за исключением ограничения на целый тип Word.

Жесткий диск состоит из нескольких дисков, которые в свою очередь состоят из секторов, состоящих из доменов. Размер физического сектора на жестком диске 512 байт. Для обеспечения максимальной скорости обмена данными длину записи не типизированного файла следует задавать кратной размеру физического сектора на диске (512 байт). Кроме того на логическом уровне каждому файлу выделяется как минимум 1 кластер. Каждый кластер занимает 2 или более смежных секторов. Как правило, на большинстве дисков 1 кластер читается или записывается за один оборот диска, по-этому, максимальную скорость обмена данными можно получить, если указать длину записи не типизированного файла равной размеру кластера в байтах.

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

Для этих файлов могут применяться все процедуры и функции, предназначенные для типизированных, за исключением Read и Write, которые заменяются высокоскоростными процедурами BlokRead и BlokWrite:

BlokRead(<файловая переменная 1>,<2>,<3>[,<4>]);

BlokWrite(<файловая переменная 1>,<2>,<3>[,<4>]);

1 - файловая переменная;

2 - буфер (т.е. имя переменной, которая будет участвовать в обмене данными с диском);

3 - количество записей, которые должны быть прочитаны или записаны за одно обращение к диску;

4 - возвращает при выходе из процедуры количество фактически обработанных записей.

Buff: array [1..1024] of byte;

BlokRead: (f,buff,2,x); [x=1]

За одно обращение к процедуре BlokRead / BlokWrite может быть передано n*(длинна записи) байт. Передача идет начиная с первого файла к переменной Buff. Программист должен заботиться о том, что бы длинна внутреннего представления переменной Buff была достаточной для размещения всех n*(длинна записи) байт. Если длинна буфера будет недостаточной или место на диске закончится то выведется: `ОШИБКА!'

Ш Потоки.

Stream - поток данных.

Thread - отдельно выполняющаяся программа (отдельный процесс); программный поток.

TSream - объект потока данных. Является базовым для потоков данных разного типа. В нем реализованы все необходимые свойства и методы, используемые для чтения и записи данных на различные типы носителей (память, диск, сеть …). Благодаря ему, доступ к различным типам носителей становится унифицированным (единым, одинаковым …). У объектов TSream существует несколько потомков одного уровня позволяющих работать с различными носителями информации.

Потомки TSream:

TFileStream - применяется для получения доступа к файлам.

TMemoryStream - применяется для получения доступа к памяти.

TStringStream - применяется для получения доступа к строкам, хранящимся в динамической памяти.

TWinSocketStream - применяется для получения доступа к данным из сети.

TOleStream - применяется для получения доступа к COM-интерфейсу (component object model).

Для всех этих объектов действуют основные методы и свойства родительского объекта TSream.

Основные свойства объекта TSream:

Position - указывает на текущую позицию курсора в потоке (начиная с нее будет происходить чтение файла).

Size - размер данных в потоке.

Методы объекта TSream:

CopyFrom - метод предназначен для копирования из другого потока:

1. указатель на поток, из которого надо копировать;

2. размер данных (байт) подлежащих копированию.

Read - позволяет прочитать данные из потока, начиная с текущей позиции курсора:

1. буфер, в который будет происходить чтение;

2. количество читаемых байтов.

Write - позволяет записывать данные в буфер (по параметрам аналогичен read);

Seek - позволяет переместиться в новую позицию в потоке:

1. число, указывающее на сколько байт нужно передвинуться;

2. от куда надо двигаться (не обязательные параметр). Может принимать 3-и значения:

· soFromBegining - от начала;

· soFromCurrent - с текущей позиции (по умолчанию);

· soFromEnd - с конца.

SetSize - устанавливает размер потока (один параметр - число указывающее новый размер потока (байт)).

Пример Работа с объектом TFileStream - чтение информации:

…

Var

f: TFileStream;

out: array [1..1024] of byte;

Begin

if OpenDialog1.Exwcute then

begin

f:=TFileStream.Create (OpenDialog1.FoleName, fmOpenRead);

f.Read(buf,1024);

f.Free;

end;

end;

fmOpenRead - режим работы с файлом.

Режимы работы с файлом для объектов TFileStream:

fmCreate - создает новый файл (если файл уже существует, то он открывает его в режиме записи);

fmOpenRead - открывает файл только для чтения;

fmOpenWrite - открывает файл только для записи (вся предыдущая информация стирается);

fmOpenReadWrite - добавляет информация в файл не удаляя предыдущую;

fmShareExclusive - при работе с файлами в таком режиме не одно приложение, кроме вашего не сможет его открыть;

fmDenyWrite - при работе с файлами в таком режиме другие приложения не могут писать в файл, но могут его читать;

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

III. Строки.

Строки используются для обработки текста:

Var

Имя: string;

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

Максимальное количество символов в строке 255.

Пример:

s: string; [0-255]

s1: string [10]; [0-10]