• Комментарии
  • Идентификаторы
  • Встроенные типы данных
  • Числовые типы
  • Символьный тип
  • Строковые типы
  • Булев тип данных
  • Массивы
  • Константы
  • Переменные
  • Пользовательские типы данных
  • Множества
  • Перечислимые типы
  • Подтипы
  • Записи
  • Классы
  • Определение членов класса
  • Свойства класса
  • Методы класса
  • Конструкция with-do
  • Структура проекта Delphi
  • Файл проекта .dpr
  • Файл программного модуля .pas
  • Процедуры и функции
  • Параметры
  • Вызов процедур и функций
  • Досрочный выход из процедуры или функции
  • Операторы
  • Оператор присваивания
  • Арифметические операторы
  • Булевы операторы
  • Операторы сравнения
  • Побитовые операторы
  • Строковые операторы
  • Операторы, применяемые к множествам
  • Операторы, применяемые с объектами
  • Группировка операторов
  • Порядок выполнения операторов
  • Блоки программного кода
  • Конструкции ветвления
  • Оператор if
  • Оператор case
  • Циклические конструкции
  • Конструкция for-do
  • Конструкция while-do
  • Конструкция repeat-until
  • Досрочный выход из циклов
  • Обработка исключений
  • Блок операторов finally
  • Приложение Г

    Язык ObjectPascal

    Комментарии

    Комментарии — это фрагменты исходного текста программы, которые не компилируются и служат для пояснения кода. Для обозначения комментариев в программах на языке 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

    Целочисленные типы Диапазон значений Типы чисел с плавающей запятой Диапазон значений
    Byte 0..255 Real 5.0·10-324..1.7·10308
    ShortInt -128..127 Real48 2.9·10-39..1.7·1038
    SmallInt -32768..32767 Single 1.5·10-45..3.4·1038
    Word 0..65535 Double 5.0·10-324..1.7·10308
    Integer, LongInt -2147483648..21474883647 Extended 3.6·10-4951..1.1·104932
    Cardinal, LongWord 0..4294967295 Comp -263+1..263–1
    Int64 -263..263–1 Currency -922337203685477.5808..922337203685477.5807

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

    Символьный тип обозначается при помощи ключевого слова 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; //вызов метода, реализующего нажатие клавиши

    Конструкция with-do

    Для упрощения программного кода при работе с записями и классами в языке 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

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

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

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

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

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

    Файл проекта .dpr

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

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

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

    uses

     Forms,

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

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

     //…


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

    begin

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

     Application.Initialize;

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

     Application.CreateForm(TForm1, Form1);

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

     //…

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

     Application.Run;

    end.

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

    Файл программного модуля .pas

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

    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 имеет синтаксис двух видов:

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

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

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

    Оператор case

    Конструкция 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-do для цикла с увеличением значения счетчика:

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

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

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

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

    Конструкция while-do

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

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

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

    Конструкция repeat-until

    Синтаксис конструкции 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, которое содержит строку с описанием ошибки.

    Блок операторов finally

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

    try

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

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

    finally

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

    end;

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





     

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