• Главная
• В избранное
• Наш E-MAIL
• Добавить материал
• Нашёл ошибку
• Вниз

Комментарии — это фрагменты исходного текста программы, которые не компилируются и служат для пояснения кода. Для обозначения комментариев в программах на языке Object Pascal используют следующие конструкции:

• // — комментарии в одной строке;

• { } или (* *) — многострочные комментарии.

Примеры:

i:= i+1; // увеличиваем на единицу счетчик

s:= IntToStr(i); {используем функцию IntToStr, которая возвращает – строковое представление целочисленного параметра}

Идентификаторы – это имена констант, переменных, типов, свойств, процедур, функций, программ и программных модулей. Могут быть длиной до 255 символов, начинаться с символа или знака подчеркивания; могут содержать символы, цифры и знаки подчеркивания и не должны содержать пробелы.

В языке Object Pascal идентификаторы не чувствительны к регистру букв, то есть нет различия между строчными и заглавными буквами. Таким образом, идентификатор функции IntToStr равнозначен идентификатору inttostr или intTOstr.

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

• and, array, as, asm, at, automated;

• begin;

• case, class, const, constructor;

• destructor, div, do, downto;

• else, end, except, exports;

• file,finalization, finally, for, function;

• goto;

• if, implementation, in, inherited, initialization, inline,interface, is;

• label, library;

• mod;

• nil, not;

• object, of, on, or, out;

• packed, private, procedure, program, property, protected, public, published;

• raise,record, repeat, resourcestring;

• set, shl, shr, string;

• then, threadvar, to, try, type;

• unit, until, uses;

• var;

• while, with;

• xor.

К числовым типам языка Object Pascal относятся целочисленные и типы чисел с плавающей запятой (табл. Д.1).

Таблица Д.1. Числовые типы данных языка Object Pascal

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

В языке Object Pascal используются два обобщенных строковых типа:

• String — если в проекте Delphi указана директива компилятора {$H+} (поддержка больших строк), то этому типу соответствуют строки длиной от 0 до 2147483648 символов; в противном случае типу String соответствуют строки длиной от 0 до 255 символов;

• PChar — тип, аналогичный строковому типу языка C.

По своей сути, строковые значения — это массивы символов, в которых нумерация элементов для типа String начинается с 1, а для типа PChar — с 0.

Переменная булевого типа занимает один байт памяти и может принимать только одно из двух значений: True ("истина", "да", 1) или False ("ложь", "нет", 0). Булев тип обозначается при помощи ключевого слова Boolean.

Массив — это упорядоченная именованная совокупность однотипных значений, к которым можно обращаться по их порядковому номеру (индексу). Для описания массивов в языке Object Pascal используют следующие формы:

• array [1..N1] of type — одномерный массив фиксированного размера (N1 — размерность массива, type — тип значений, хранимых в массиве);

• array[1..N1, 1..N2] of type — двухмерный массив фиксированного размера;

• array[1..N1, 1..N2, 1..N3] of type — трехмерный массив фиксированного размера;

• array of type — массив переменного размера. Длину таких массивов можно изменять в процессе выполнения программы при помощи процедуры SetLength. Индексация значений начинается с 0.

Константа — это именованное фиксированное значение. Для объявления констант используют конструкцию вида:

const имя_константы = значение;

Например:

const Factor = 1.756;

Тип константы определяется автоматически по присвоенному ей значению.

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

var имя_переменной: имя_типа;

Например :

var

 i: Integer; //переменная i типа Integer

 s: String; //переменная S типа String

 MyArray: array[1..10] of Char; {переменная MyArray — массив значений типа Char. Эту переменную можно было бы также объявить как String[10]}

При обращении и инициализации переменных используют следующие правила:

• для присвоения значений переменным используют оператор присваивания :=;

• строковые и символьные значения, присваиваемые переменным, заключают в одинарные кавычки ('с', ' строка');

• для обращения к отдельным элементам массива или отдельным символам строки используют запись вида: а[1] — для одномерных массивов и строк; а[3][1] – для двухмерных массивов; а[1][6][2] — для трехмерных массивов и т. д.;

• в качестве типа переменной может быть указан как встроенный тип языка Object Pascal, так и пользовательский, определенный при помощи ключевого слова type (создание пользовательских типов рассматривается ниже).

К переменным в программе обращаются по их идентификаторам.

Пример для типа String:

var

 s1, s2: String; //объявляем две переменные типа String

 с: Char; //и одну типа Char

 ...

s1:= 'Строка'; //присваиваем s1 некоторое значение

с:= s[1]; //переменная с хранит значение 'С'

s2:= s1 + с; //в s2 сохраняем строку 'СтрокаС'

…

Пример для динамического массива:

var

 MyArray: array of Char; s: String;

 …

SetLength(MyArray, 1); //устанавливаем длину массива = 1

A[0]:= 'С';

SetLength(MyArray, 2); //устанавливаем длину массива = 2

А[1]:= 'т';

s:= А[0] + А[1] + 'рока' //в s сохраняется значение 'Строка'

…

Для объявления пользовательских типов, используют конструкцию вида:

type имя_типа = описание_типа;

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

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

set of первое_значение..последнее_значение;

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

Например:

type

 TNumbers = set of 1..10;

 TAlphabet = set of 'a';

var

 Odds, Evens: TNumbers;

 ABC: TAlphabet;

 …

Odds:= [1, 3, 5, 7, 9];

Evens:= [2, 4, 6, 8, 10];

ABC:= ['a', 'b', 'с'];

…

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

type имя_типа = (элемент1, ... , элементN);

По умолчанию, первому элементу соответствует число 0, второму — 1 и т.д. Для того чтобы сопоставить с каким-либо элементом другое значение, следует использовать запись вида элемент = число.

Для извлечения числа, соответствующего некоторому элементу, используется функция Ord.

Пример:

type

 TDigits = (Zero, One, Two, Three, Four, Five, Six, Seven Eight, Nine, Ten);

 TConstants = (a = 10, b = 3);

var

 x: TDigits;

 k: TConstants;

 MyResult: integer;

 …

k:= b; //k присваиваем значении 3

if x = Zero then k:= a //если x=0, то к присваиваем 10

 MyResult:= Ord(k); //MyResult = 3 или 10

 …

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

type имя_типа = начало..конец;

Переменные этого типа не могут принимать значений вне указанного диапазона. Пример:

type

 TDigits = (Zero, One, Two, Three, Four, Five, Six, Seven, Eight, Nine, Ten); //перечислимый тип

 T123 = One..Three; //подтип

 TABC = 'A'..'C'; //еще один подтип

var

 i: T123; //переменная I может принимать значения от 1 до 3

 с: TABC; // переменная с может содержать 'A', 'B' или 'C'

Запись  – это структурированный набор разнотипных элементов. Отдельные элементы записи называются полями. Для объявления записи используется следующая конструкция:

record

 полe1: тип;

 …

 полeN: тип;

end;

Запись можно объявлять как в разделе type, так и в разделе var:

type TCD = record //запись для хранения данных о музыкальном CD

 Group String; //поле, хранящее название исполнителя

 Year: Integer; //поле, хранящее год альбома

 Title: String; //поле, хранящее название альбома

end;

var MyCD: TCD;

или непосредственно

var MyCD: record

 Group: String;

 Year: Integer;

 Title: String;

end;

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

MyCD.Group:= 'Название группы';

MyCD.Year:= 2005;

MyCD.Title:= 'Название альбома';

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

Класс может быть создан на основе другого класса — в этом случае он называется производным, а базовый класс — родительским. Производный класс наследует все свойства и методы родительского класса, а также может содержать собственные уникальные свойства и методы. Для объявления класса используют конструкцию вида:

type имя_класса = class(имя_родительского_класса)

published

 {объявление опубликованных членов класса}

private

 {объявление закрытых членов класса}

public

 {объявление открытых членов класса}

protected

 {объявление защищенных членов класса}

end;

Все члены класса по характеру доступа к ним делятся на четыре категории: закрытые (private), защищенные (protected), открытые (public) и опубликованные (published).

Элементы класса, определенные в разделе public, без каких-либо ограничений открыты для доступа извне программного модуля. Без ограничений доступны также и элементы, определенные в разделе published, однако они отличаются тем, что для них генерируется информация о типах времени выполнения (RTTI — Run Time Type Information). Информация RTTI используется для различных целей: например, для организации отображения значений свойств в инспекторе объектов.

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

Элементы, определенные в разделе protected, доступны в модуле, в котором объявлен класс, а также доступны всем членам классов, производных от данного класса.

По умолчанию при создании программных модулей Object Pascal раздел protected не создается, а раздел published не указывается явно. Все члены класса, которые не определены в разделах private и public, по умолчанию относятся к категории published.

Рассмотрим, к примеру, фрагмент объявления класса TForm (модуль Forms.pas), базового для форм в приложениях Delphi:

TForm = class(TCustomForm) public

procedure ArrangeIcons;

 procedure Cascade;

 …

published

 property Action;

 property ActiveControl;

 …

end;

В данном случае видно, что класс TForm является производным от класса TCustomForm (реализован в том же модуле Forms.pas) и содержит открытые методы ArrangeIcons, Cascade и т.д., а также опубликованные свойства Action, ActiveControl и т.д.

Примечание

Объявление класса и его членов осуществляется в разделе interface программного модуля, а непосредственная реализация свойств и методов — в разделе implementation (структура программного модуля Object Pascal рассматривается ниже).

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

type TForm1 = class(TForm)

private

 { Private declarations }

public

 { Public declarations }

end;

var Form1: TForm1;

Это означает, что в модуле приложения объявлен класс TForm1, производный от класса TForm, а затем объявлена переменная типа TForm1. Такие переменные — экземпляры класса — называют объектами.Все компоненты Delphi — это объекты, экземпляры того или иного класса.

Свойства — это именованные интерфейсы доступа к данным объекта. Например, у объекта класса tform, есть свойства height ("высота"), Width ("ширина"), Color ("цвет") и др. Присваивая свойствам значения соответствующего типа, можно изменять внешний вид или характер поведения объекта.

Для доступа к свойствам объекта используется такая же конструкция , как и для доступа к полям записи, например:

var Form1: TForm1;

…

Form1.Caption:= 'Заголовок формы';

Form1.Font.Color := clWhite;

…

В данном случае, свойство Font ("шрифт") — это тоже объект класса TFont, у которого есть свойство Color ("цвет").

Такой же способ доступа используется и для всех компонентов, размещенные на форме в Delphi:

type TForm1 = class(TForm)

 Edit1: TEdit;

private

 { Private declarations }

public

 { Public declarations }

end;

var Form1: TForm1;

…

Form1.Edit1.Text:= '';

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

Для доступа к методам используется тот же подход, что и для свойств:

Button1.Click; //вызов метода, реализующего нажатие клавиши

Для упрощения программного кода при работе с записями и классами в языке Object Pascal используется конструкция with-do. Например, фрагмент кода

MyCD.Group:= 'Название группы';

MyCD.Year:= 2005;

MyCD.Title:= 'Название альбома';

Form1.Caption:= 'Заголовок формы';

Form1.Font.Color:= clWhite;

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

with MyCD do begin

 Group:= 'Название группы';

 Year:= 2005;

 Title:= 'Название альбома';

end;

with Form1 do begin

 Caption:= 'Заголовок формы';

 Font.Color: = clWhite;

end;

Еще один вариант записи этого же фрагмента:

with MyCD, Form1 do begin

 Group:= 'Название группы';

 Year:= 2005;

 Title:= 'Название альбома';

 Caption:= 'Заголовок формы';

 Font.Color:= clWhite;

end;

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

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

• файл проекта с расширением .dpr;

• программные модули форм — файлы с расширением .pas;

• двоичные данные формы — файлы с расширением .dfm.

Файл .dfm Delphi формирует автоматически на основании значений, присвоенных свойствам формы и размещенных на ней компонентов. Файлы .dpr и .pas также создаются Delphi автоматически, но в них можно вносить изменения вручную. Рассмотрим их структуру.

Файл проекта Delphi — это, по сути, главный программный модул не связанный ни с какой формой. В нем указываются ссылки на программные модули приложения и создаются формы. Он имеет следующую с т руктуру:

program имя_программы; //заголовок

//раздел, в котором указываются ссылки на модули форм

uses

 Forms,

 Unit1 in 'Unit1.pas' {Form1}; //главная форма приложения

 //ссылки на остальные формы приложения

 //…

{$R *.res} {директива компилятора о подключении файла ресурсов программы}

begin

 //инициализация приложения как объекта

 Application.Initialize;

 //создание главной формы приложения

 Application.CreateForm(TForm1, Form1);

 //создание остальных форм

 //…

 //запуск приложения

 Application.Run;

end.

Перед словом begin можно добавлять объявления констант, типов и переменных, а между словами begin и end — добавлять собственный программный код.

Файл программного модуля (формы или независимый) имеет следующую структуру:

unit имя_модуля;

//начало интерфейсной части модуля

interface

uses

 {раздел ссылок на другие программные модули, классы, типы, переменные, процедуры или функции которых используются в данном модуле}

const

 {описания констант}

type

 {описание типов, в частности — класса формы}

var

 {описание переменных, в частности – экземпляра формы}

//начало раздела реализации

implementation

uses

 {раздел ссылок на другие программные модули}

{$R *.dfm} //директивы компилятора

const

 {описания констант}

type

 {описание типов }

var

 {описание переменных }

 {реализация процедур и функций модуля}

end.

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

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

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

procedure имя_процедуры(список_параметров);

 {Локальные объявления констант, типов и переменных}

begin

 //Тело процедуры

end;

Синтаксис функций:

function имя_процедуры(список_параметров): тип_возвращаемого_значения;

 {Локальные объявления констант, типов и переменных}

begin

 //Тело функции

 Result:= возвращаемое_ значение;

end;

Список параметров, передаваемых в процедуру или в функцию, имеет следующий синтаксис:

параметр1: тип; …; параметрN: тип

Если процедура или функция не принимает никаких параметров, то ее заголовок выглядит следующим образом:

procedure имя_процедуры;

function имя_процедуры: тип_возвращаемого_значения;

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

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

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

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

s:= IntToStr(i); //вызов функции IntToStr

delete(s, 1, 2); {вызов процедуры delete, которая удаляет из строки s два символа, начиная с первого. В данном случае, переменная s является параметром, передаваемым по ссылке}

Если в процедуру или функцию не передаются никакие параметры (как во многих методах объектов), то вызов осуществляется только по ее имени, например:

Button1.Click; //вызов метода (процедуры) Click

s:= GetCurrentDir; //вызов функции GetCurrentDir

Для досрочного выхода из процедуры или функции в ее теле следует указать вызов процедуры Exit.

Оператор — это конструкция языка Object Pascal, выполняющая определенную операцию. Все операторы можно разбить на несколько категорий.

Слева от оператора присваивания := указывается переменная или свойство объекта, а справа — некоторое значение или выражение. Тип значения или результат выражения должен соответствовать типу переменной или свойства.

Арифметические операторы возвращают значения, соответствующие типам числовых операндов:

• + — сложение;

• – — вычитание;

• * — умножение;

• / — деление чисел с плавающей запятой;

• div — целочисленное деление с отбрасыванием остатка;

• mod — получение остатка от целочисленного деления.

Булевы операторы возвращают значения типа Boolean:

• not — отрицание;

• and — логическое "И";

• or — логическое "ИЛИ";

• xor — логическое исключающее "ИЛИ".

Операторы сравнения возвращают значение типа Boolean:

• = — равно;

• <> — не равно;

• < — меньше;

• > — больше;

• <= — меньше или равно;

• >= — больше или равно.

Побитовые операторы выполняют действия с операндами с учетом их двоичного представления:

• not — побитовое отрицание (not 0 = 1; not 1 = 0);

• and — побитовое умножение (0 and N = 0; 1 and 1 = 1);

• or — побитовое сложение (1 or N = 1; 0 or 0 = 0);

• xor — побитовое исключающее сложение (0 xor 0 = 0; 0 xor 1 = 1; 1 xor 1 = 0);

• shl — побитовый сдвиг влево;

• shr — побитовый сдвиг вправо.

Строковые операторы применяются к операндам строкового или символьного типа:

• =, <>, <, >, <=, >= — операторы сравнения;

• + — оператор конкатенации (слияния операндов).

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

• + — объединение (результат — множество);

• – — вычитание (результат — множество);

• * — пересечение (результат — множество);

• <= – подмножество (результат — множество);

• >= — супермножество (результат — множество);

• = — равенство (результат — значение типа Boolean);

• <> — неравенство (результат — значение типа Boolean);

• in — вхождение множества, указанного слева от оператора, во множество, указанное справа (результат — значение типа Boolean).

С объектами применяют следующие операторы:

• as — приведение к производному классу. Пример использования:

var Obj: TObject; //объект класса TObject

…

with Obj as TButton do //приводим к классу TButton

 Caption:= 'Кнопка'; //то же, что Obj.Caption

• is — сравнение с классом. Пример использования:

var Obj: TObject; //объект класса TObject

…

if Obj is TButton then //если Obj – объект класса

 //TButton, то…

 Obj.Caption:= 'Кнопка';

• =, <> — операторы сравнения.

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

В сложных выражениях операторы выполняются в следующем порядке:

1. ( ).

2. not.

3. *, /, div, mod, and, shl, shr, as.

4. +, –, or, xor.

5. =, <>, <, >, <=, >=, in, is.

Два и более операторов присваивания, а также вызовов процедур или функций можно выделять в блоки программного кода при помощи ключевых слов begin и end. Такие блоки используются в конструкции with-do, а также в рассматриваемых ниже циклических конструкциях и конструкциях ветвления.

Конструкции ветвления осуществляют переход к одному из блоков программного кода на основании проверки некоторого условия. К ним относятся операторы if и case.

Оператор if имеет синтаксис двух видов:

if выражение then блок_кода;

if выражение then блок_кода else блок_кода;

Если выражение возвращает значение True, то выполняется блок кода, расположенный после ключевого слова then, в противном случае выполняется или программный код, расположенный после конструкции if-then (в случае отсутствия ветки else), или же код, расположенный после ключевого слова else.

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

case выражение of

значение1: блок_кода1;

…

значениеN: блок_кодаN;

end;

или

case выражение of

значение1: блок_кода1;

…

значениеN: блок_кодаN;

else блок_кода;

end;

Если результат выражения совпадает со значением1, то выполняется блок_кода1; если со значением2 — 6лок_кода2 и т.д. Если результат выражения не совпадает ни с одним значением, то выполняется блок кода в ветке else, а при ее отсутствии — код после ключевого слова end, завершающего конструкцию case.

Примечание

Результат выражения, который сопоставляется со значениями в ветках конструкции case, может быть только целочисленного или символьного типа.

Для организации циклического выполнения программных блоков в языке Object Pascal используют циклические конструкции трех типов: for-do, while-do и repeat-until. Они отличаются характером начала и завершения цикла.

Синтаксис конструкции for-do для цикла с увеличением значения счетчика:

for идентификатор_счетчика := начальное_значение to конечное_эначение do блок_кода;

Синтаксис конструкции for-do для цикла с уменьшением значения счетчика:

for идентификатор_счетчика := начальное_значение downto конечное_значение do блок_кода;

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

Синтаксис конструкции while-do:

while выражение do блок_кода;

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

Синтаксис конструкции repeat-until:

repeat блок_кода until выражение;

Выход из цикла repeat-until происходит в том случае, если выражение, расположенное после ключевого слова until, дает значение True.

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

Исключение (exception) — это результат выполнения некорректного оператора, что привело к возникновению ошибки. В языке Object Pascal для обработки исключений предназначена специальная конструкция:

try

 //Операторы, которые могут привести к возникновению исключения

except

 //Операторы, выполняемые в случае возникновения исключения

end;

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

В частности, в блоке except можно обрабатывать исключения в зависимости от их типа с помощью конструкции

except

 on Тип_исключения1 do Блок_операторов1;

 on Тип_исключения2 do Блок_операторов2;

 …

 on Тип_исключенияN do Блок_операторовN;

end;

Типу исключения соответствует имя класса, производного от класса Exception. В отличие от других классов Delphi, имена классов исключений начинаются к латинской буквы "E". Перечислим некоторые из этих классов:

• EZeroDivide — деление на ноль;

• EAccessViolation — ошибка доступа к памяти;

• ERangeError — выход значения за границы допустимого диапазона;

• EStackOverflow — переполнение стека памяти из-за слишком больших переменных или чрезмерно большого количество рекурсивных вызовов процедур (вызов процедуры самой себя);

• EConvertError — ошибка преобразования (например, строки в число);

• EDatabaseError — ошибка при работе с базой данных;

• EOutOfMemory — переполнение памяти;

• EFCreateError — ошибка создания файла;

• EFilerError — ошибка чтения/записи при работе с файлом;

• EFOpenError — ошибка открытия файла;

• EIniFileException — ошибка при работе с INI-файлом;

• EInOutError — ошибка ввода-вывода.

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

except

 on E: Exception do Блок_операторов;

end;

При этом в блоке операторов после ключевого слова do можно обращаться к свойству E.Message, которое содержит строку с описанием ошибки.

Существует еще одна конструкция, связанная с обработкой исключений:

try

 //Операторы, которые могут привести к возникновению

 //исключения

finally

 //Операторы, которые выполняются при любых условиях

end;

Блок операторов после ключевого слова finally выполняется в любом случае, независимо от того, возникло исключение в блоке try или нет.