Exclude — Процедура Delphi


Содержание

Exclude — Процедура Delphi

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

О подпрограммах в Object Pascal

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

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

Использование подпрограммы состоит из 2 этапов: сначала подпрограмму описывают, а затем, уже в блоке инструкций программы, вызывают. Отметим, что в библиотеке Delphi имеется описание тысяч готовых подпрограмм, описывать которые, разумеется, уже не надо. А их вызовом мы уже неоднократно занимались — достаточно взглянуть на любой пример, где мы встречали инструкции, подобные таким:

write(‘Hello, world!’); readln;

Здесь и write, и readln — стандартные подпрограммы Object Pascal. Таким образом, с вызовом подпрограмм мы уже знакомы. Осталось узнать, как создавать собственные, или пользовательские, подпрограммы. Но прежде отметим, что все подпрограммы делятся на 2 лагеря: процедуры и функции. Мы уже использовали эти термины, и даже давали им описание, однако повторимся: процедуры — это такие подпрограммы, которые выполняют предназначенное действие и возвращают выполнение в точку вызова. Функции в целом аналогичны процедурам, за тем исключением, что они еще и возвращают результат своего выполнения. Результатом работы функции могут быть данные любого типа, включая объекты.

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

Как процедурам, так и функциям могут передаваться данные для обработки. Делается это при помощи списка параметров. Список параметров в описании подпрограммы и список аргументов, указываемых при ее вызове должен совпадать. Иначе говоря, если в описании определено 2 параметра типа Integer, то, вызывая такую подпрограмму, в качестве аргументов так же следует указать именно 2 аргумента и именно типа Integer или совместимого (скажем, Word или Int64).

ПРИМЕЧАНИЕ
На самом деле, Object Pascal позволяет довольно гибко обращаться с аргументами, для чего имеются различные методы, включая «перегружаемые» функции, значения параметров по умолчанию и т.д. Тем не менее, в типичном случае, количество, тип, и порядок перечисления аргументов при объявлении и при вызове процедуры или функции, должны совпадать.

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

Процедуры

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

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

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

ПРИМЕЧАНИЕ
Вопросы локальных и глобальных переменных, и вообще видимости в программах, будет рассмотрен позже в этой главе.

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

procedure TriplePrint(str: string); var i: integer; begin for i := 1 to 3 do begin writeln(‘»‘+str+'»‘); end; // конец цикла for end; // конец процедуры TriplePrint

Здесь мы определили процедуру TriplePrint, которая будет трижды выводить переданную ей в качестве аргумента строку, заключенную в двойные кавычки. Как видно, данная процедура имеет все составные части: ключевое слово procedure, имя, список параметров (в данном случае он всего один — строковая переменная str), блок объявления собственных переменных (целочисленная переменная i), и собственное тело, состоящее из оператора цикла for.

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

Отметим так же, что рассмотренная нами процедура сама содержит вызов другой процедуры — writeln. Процедуры могут быть встроенными. Иначе говоря, объявление одной процедуры можно помещать в заголовочную часть другой. Например, наша процедура TriplePrint может иметь вспомогательную процедуру, которая будет «подготавливать» строку к выводу. Для этого перед объявлением переменной i, разместим объявление еще одной процедуры. Назовем ее PrepareStr:

procedure PrepareStr; begin str := ‘»‘+str+'»‘; end;

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

Таким образом, мы получаем две процедуры, одна из которых (TriplePrint) может использоваться во всей программе, а другая (PrepareStr) — только внутри процедуры TriplePrint. Чтобы преимущество использования процедур было очевидно, рассмотрим их на примере программы, которая будет использовать ее неоднократно, для чего обратимся к листингу 6.1 (см. так же пример в Demo\Part1\Procs).

Листинг 6.1. Использование процедур

program procs; <$APPTYPE CONSOLE>procedure TriplePrint(str: string); procedure PrepareStr; begin str := ‘»‘+str+'»‘; end; var i: integer; begin PrepareStr; for i := 1 to 3 do begin writeln(str); end; end; // конец процедуры TriplePrint begin // начало тела основной программы TriplePrint(‘Hello. ‘); // первый вызов TriplePrint TriplePrint(‘How are you. ‘); // 2-й вызов TriplePrint(‘Bye. ‘); // 3-й readln; end.

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

Функции

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

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

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

function cube(value: integer) : integer; result := value * value * value; >

Здесь определена функция, имеющая параметр value типа целого числа, которое она возводит в третью степень путем троекратного умножения, и результат присваивается специальной переменной result. Таким образом, чтобы в любом месте программы вычислить значение числа в 3-й степени, достаточно написать такое выражение:

В результате выполнения этого выражения переменной x будет присвоено значение 27. Данный пример иллюстрирует использование функций в классическом случае — для явного вычисления значения переменной. Однако функции могут использоваться в выражениях и напрямую. Например, можно поставить вызов функции cube в каком-либо месте арифметического выражения подобно обычной переменной:

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

procedure TriplePrint(str: string); function PrepareStr(s: string) : string; begin result := ‘»‘+s+'»‘; end; var i: integer; begin for i := 1 to 3 do begin writeln(PrepareStr(str)); // функция использована как переменная end; end;

Как уже отмечалось, помимо специальной переменной result, в функциях можно использовать другую автоматически объявляемую переменную, имя которой соответствует имени функции. Так, для функции cube имя переменной также будет cube:

function cube(value: integer) : integer; cube := value * value * value; >

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

Рекурсия

Таким образом мы подошли к теме рекурсии — вызову подпрограммы из самой себя. Это не является ошибкой, более того, целый ряд алгоритмов решить без рекурсии вообще было бы затруднительно.

Рассмотрим вопрос рекурсии на следующем примере:

function recfunc(x: integer) : integer begin dec(x); // функция декремента, уменьшает целое на 1 if x > 5 then x := recfunc(x); result := 0; // возвращаемое значение тут не используется end;

Здесь мы объявили функцию recfunc, принимающую один аргумент, и вызывающую саму себя до тех пор, пока значение этого аргумента больше 5. Хотя на первый взгляд может показаться, что такое поведение функции похоже на обычный цикл, на самом деле все работает несколько по-иному: если вы вызовите ее со значением 8, то она выдаст вам 3 сообщения в следующей последовательности: 5, 6, 7. Иначе говоря, функция вызывала саму себя до тех пор, пока значение x было больше 5, и собственно вывод сообщений начала 3-я по уровню получившейся вложенности функция, которая и вывела первое сообщение (в данном случае им стало 5, т.е. уменьшенное на единицу 6).

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

Листинг 6.2. Рекурсия с комментариями

program recurse; <$APPTYPE CONSOLE>function recfunc(x, depth: integer) : integer; begin dec(x); if x > 5 then begin write(‘Current recursion depth is: ‘); write(depth); write(‘, current x value is: ‘); writeln(x); inc(depth); depth:=recfunc(x, depth); end else writeln(‘End of recursive calls. ‘); write(‘Current recursion depth is: ‘); write(depth); write(‘, current x value is: ‘); writeln(x); dec(depth); result := depth; end; begin recfunc(8,0); readln; end.

Исходный код находится в Demo\Part1\Recurse, там же находится и исполняемый файл recurse.exe, результат работы которого вы можете увидеть на своем экране.

Использование параметров

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

procedure Circle (square: real; var radius, length: real);

Данная процедура принимает «на обработку» одно значение — площадь (square), а возвращает через свои параметры два — радиус (radius) и длину окружности (length). Практическая ее реализация может выглядеть таким образом:

procedure Circle (square: real; var radius, length: real); begin radius := sqrt(square / pi); // функция pi возвращает значение числа ? length := pi * radius * 2; end;

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

var r,l: real; . Circle(100,r,l);

После вызова функции Circle, переменные r и l получат значения радиуса и длины окружности. Остается их вывести при помощи writeln. Исходный код программы приведен в листинге 6.3.

Листинг 6.3. Процедура с параметрами

program params; <$APPTYPE CONSOLE>procedure Circle (square: real; var radius, length: real); begin //функция sqrt извлекает корень, а функция pi возвращает значение числа ? radius := sqrt(square / pi); length := pi * radius * 2; end; var r,l: real; begin Circle(100,r,l); writeln(r); writeln(l); readln; end.

Запустив такую программу, можно убедиться, что она работает и выводит верные результаты, однако вид у них получается довольно-таки неудобочитаемый, например, длина окружности будет представлена как «3,54490770181103E+0001». Чтобы сделать вывод более удобным для восприятия, нам понадобится функция FloatToStrF. С ее помощью мы можем определить вывод числа на свое усмотрение, например:

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

writeln(‘Radius is: ‘+FloatToStrF(r,ffFixed,12,8)); writeln(‘Length is: ‘+FloatToStrF(l,ffFixed,12,8));

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

. var s,r,l: real; begin write(‘Input square: ‘); readln(s); Circle(s,r,l); writeln(‘Radius is: ‘+FloatToStrF(r,ffFixed,12,8)); writeln(‘Length is: ‘+FloatToStrF(l,ffFixed,12,8)); readln; end.

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

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

function Circle(square: real; var radius, length: real) : boolean; begin result := false; if (square

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

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

if Circle(s,r,l) then begin // вывод end else // сообщить об ошибке

Результатом проделанной работы будет программа, приведенная в листинге 6.4. Она же находится в Demo\Part1\Params.

Листинг 6.4. Функция с параметрами

program params; <$APPTYPE CONSOLE>uses sysutils; //этот модуль соджержит функцию FloatToStrF function Circle(square: real; var radius, length: real) : boolean; begin result := false; if (square

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

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

function MyBetterFunc(val1: integer; const val2: integer = 2); begin result := val1*val2; end;

Обращение же к такой функции может иметь 2 варианта: с указанием только одного аргумента (для параметра val1), или же с указанием обоих:

x := MyBetterFunc(5); // получим 10 x := MyBetterFunc(5,4); // получим 20

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

Области видимости

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

program Project1; procedure Proc1; var a: integer; begin a := 5; //верно. Локальная переменная a здесь видна end; begin a := 10; //Ошибка! Объявленная в процедуре Proc1 переменнаая здесь не видна end.

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

program Project2; var a: integer; // глобальная переменная a procedure Proc1; begin a := 5; // верно b := 10; // Ошибка! Переменая b на этот момент еще не объявлена end; var b: integer; // глобальная переменная b begin a := 10; // верно b := 5; // тоже верно. Здесь видны все г var a: integer; // глобальная переменная end.

Теперь рассмотрим такой вариант, когда у нас имеются 2 переменных с одним и тем же именем. Разумеется, компилятор еще на стадии проверки синтаксиса не допустит, чтобы в программе были объявлены одноименные переменные в рамках одного диапазона видимости (скажем, 2 глобальных переменных X, или 2 локальных переменных X в одной и той же подпрограмме). Речь в данном случае идет о том, что произойдет, если в одной и той же программе будет 2 переменных X, одна — глобальная, а другая — локальная (в какой-либо подпрограмме). Если с основным блоком программы все ясно — в нем будет присутствовать только глобальная X, то как быть с подпрограммой? В таком случае в действие вступает правило близости, т.е. какая переменная ближе (по структуре) к данному модулю, та и есть верная. Применительно к подпрограмме ближней оказывается локальная переменная X, и именно она будет задействована внутри подпрограммы.

program Project3; var X: integer; procedure Proc1; var X: integer; begin X := 5; // Здесь значение будет присвоено локальной переменной X end; begin X := 10; // Здесь же значение будет присвоено голобальной переменной X end.

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

program Project1; procedure Proc1; procedure SubProc; begin end; begin SubProc; // Верно. Вложенная процедура здесь видна. end; begin Proc1; // Верно. Процедура Proc1 объявлена в зоне глобальной видимости SubProc; // Ошибка! Процедура SubProc недоступна за пределами Proc1. end.

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

Видимость в модулях

Все то, что мы уже рассмотрели, касалось программ, умещающихся в одном единственном файле. На практике же, особенно к тому моменту, когда мы перейдем к визуальному программированию, программы будут включать в себя множество файлов. В любом случае, программа на Object Pascal будет иметь уже изученный нами файл проекта — dpr, или основной модуль программы. Все прочие файлы будут располагаться в других файлах, или модулях (units), с типичным для Pascal расширением pas. При объединении модулей в единую программу возникает вопрос видимости переменных, а так же процедур и функций в различных модулях.

Для начала вернемся к рассмотрению структуры модуля, которая имеет ряд отличий от структуры программы. Итак, в простейшем случае, модуль состоит из названия, определяемого при помощи ключевого слова unit, и 2 секций — interface и implementation. Так вот как раз первая секция, interface, и служит для определения (декларации) типов данных, переменных, функций и процедур данного модуля, которые должны быть доступны за пределами данного модуля.

Чтобы лучше в этом разобраться, создадим программу, состоящую из 2 модулей — основного (dpr) и дополнительного (pas). Для этого сначала создайте новый проект типа Console Application, а затем добавьте к нему модуль, для чего из подменю File ‘ New выберите пункт Unit. После этого сохраните проект, щелкнув по кнопке Save All (или File ‘ Save All). Обратите внимание, что первым будет предложено сохранить не файл проекта, а как раз файл дополнительного модуля. Назовем его extunit.pas, а сам проект — miltiunits (см. Demo\Part1\Visibility). При этом вы увидите, что в части uses файла проекта произошло изменение: кроме постоянно добавляемого модуля SysUtils, появился еще один модуль — extunit, т.е. код стал таким:

uses SysUtils, extunit in ‘extunit.pas’;

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

uses SysUtils, extunit;

Тем не менее, оставим код как есть, и приступим к разработке модуля extunit. В нем, в части implementation, напишем 2 процедуры — ExtProc1 и ExtProc2. Обе они будут делать одно и то же — выводить строку со своим названием. Например, для первой:

Теперь вернемся к главному модулю программы и попробуем обратиться к процедуре ExtProc1:

. begin ExtProc1; end.

Попытка компиляции или запуска такой программы приведет к ошибке компилятора «Undeclared identifier», что означает «неизвестный идентификатор». И действительно, одного лишь описания процедуры недостаточно, чтобы она была доступна вне своего модуля. Так что перейдем к редактированию extunit и в секции interface напишем строку:

Такая строка, помещенная в секцию interface, является объявлением процедуры ExtProc1, и делает ее видимой вне данного модуля. Отметим, что в секции interface допускается лишь объявлять процедуры, но не определять их (т.е. тело процедуры здесь будет неуместно). Еще одним полезным эффектом от объявления процедур является то, что таким образом можно обойти такое ограничение, как необходимость определения подпрограммы до ее вызова. Иначе говоря, поскольку в нашем файле уже есть 2 процедуры, ExtProc1и ExtProc2, причем они описаны именно в таком порядке — сначала ExtProc, а потом ExtProc2, то выведя объявление ExtProc2 в interface, мы сможем обращаться к ExtProc2 из ExtProc1, как это показано в листинге 6.5:

Листинг 6.5. Объявление процедур в модуле

unit extunit; interface procedure ExtProc1; procedure ExtProc2; implementation procedure ExtProc1; begin writeln(‘ExtProc1’); ExtProc2; // Если объявления не будет, то компилятор выдаст ошибку end; procedure ExtProc2; begin writeln(‘ExtProc2’); end; end.

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

Разумеется, все, что было сказано о процедурах, верно и для функций. Кроме того, константы и переменные, объявленные в секции interface, так же будут видны как во всем теле модуля, так и вне него. Остается лишь рассмотреть вопрос пересечения имен, т.е. когда имя переменной (константы, процедуры, функции) в текущем модуле совпадает с таковым в подключенном модуле. В этом случае вновь вступает в силу правило «кто ближе, тот и прав», т.е. будет использоваться переменная из данного модуля. Например, если в extunit мы объявим типизированную константу Z, равную 100, а в multiunits — одноименную константу, равную 200, то обратившись к Z из модуля extunit, мы получим значение 100, а из multiunits — 200.

Если же нам в multiunits непременно понадобится именно та Z, которая находится в модуле extunit, то мы все-таки можем к ней обратиться, для чего нам пригодится точечная нотация. При этом в качестве имени объекта указывают название модуля:

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

Некоторые стандартные функции

В Object Pascal, как уже отмечалось, имеются огромное количество стандартных процедур и функций, являющихся составной частью языка, и с некоторыми мы уже знакомы (например, приведенные в табл. 5.1 и 5.2 функции преобразования). Детальное описание всех имеющихся в Object Pascal процедур и функций можно получить в справочной системе Delphi, однако мы все-таки рассмотрим здесь некоторые из них, чтобы составить общее представление — см. таблицу 6.1.

Таблица 6.1. Некоторые стандартные процедуры и функции Delphi

Синтаксис Группа Модуль Описание
function Abs(X); арифметические System Возвращает абсолютное значение числа
procedure ChDir(const S: string); управления файлами System Изменяет текущий каталог
function Concat(s1 [, s2. sn]: string): string; строковые System Объединяет 2 и более строк в 1
function Copy(S; Index, Count: Integer): string; строковые System Возвращает часть строки
function Cos(X: Extended): Extended; тригонометрические System Вычисляет косинус угла
procedure Delete(var S: string; Index, Count: Integer); строковые System Удаляет часть строки
function Eof(var F): Boolean; ввод-вывод System Проверяет, достигнут ли конец файла
procedure Halt [ ( Exitcode: Integer) ]; управления System Инициирует досрочное прекращение программы
function High(X); диапазона System Возвращает максимальное значение из диапазона
procedure Insert(Source: string; var S: string; Index: Integer); строковые System Вставляет одну строку в другую
function Length(S): Integer; строковые System Возвращает длину строки или количество элементов массива
function Ln(X: Real): Real; арифметические System Возвращает натуральный логарифм числа (Ln(e) = 1)
function Low(X); диапазона System Возвращает минимальное значение из диапазона
procedure New(var P: Pointer); размещения памяти System Создает новую динамическую переменную и назначает указатель для нее
function ParamCount: Integer; командной строки System Возвращает количество параметров командной строки
function ParamStr(Index: Integer): string; командной строки System Возвращает указанный параметр из командной строки
function Pos(Substr: string; S: string): Integer; строковые System Ищет вхождение указанной подстроки в строку и возвращает порядковый номер первого совпавшего символа
procedure RmDir(const S: string); ввод-вывод System Удаляет указанный подкаталог (должен быть пустым)
function Slice(var A: array; Count: Integer): array; разные System Возвращает часть массива
function UpCase(Ch: Char): Char; символьные System Преобразует символ в верхний регистр
function LowerCase(const S: string): string; строковые SysUtils Преобразует ASCII-строку в нижний регистр
procedure Beep; разные SysUtils Инициирует системный сигнал
function CreateDir(const Dir: string): Boolean; управления файлами SysUtils Создает новый подкаталог
function CurrentYear: Word; даты и времени SysUtils Возвращает текущий год
function DeleteFile(const FileName: string): Boolean; управления файлами SysUtils Удаляет файл с диска
function ExtractFileExt(const FileName: string): string; имен файлов SysUtils Возвращает расширение файла
function FileExists(const FileName: string): Boolean; управления файлами SysUtils Проверяет файл на наличие
function IntToHex(Value: Integer; Digits: Integer): string; форматирования чисел SysUtils Возвращает целое в шестнадцатеричном представлении
function StrPCopy(Dest: PChar; const Source: string): PChar; строковые SysUtils Копирует Pascal-строку в C-строку (PChar)
function Trim(const S: string): string; строковые SysUtils Удаляет начальные и конечные пробелы в строке
function TryStrToInt(const S: string; out Value: Integer): Boolean; преобразования типов SysUtils Преобразует строку в целое
function ArcCos(const X: Extended): Extended; тригонометрические Math Вычисляет арккосинус угла
function Log2(const X: Extended): Extended; арифметические Math Возвращает логарифм по основанию 2
function Max(A,B: Integer): Integer; арифметические Math Возвращает большее из 2 чисел
function Min(A,B: Integer): Integer; арифметические Math Возвращает меньшее из 2 чисел
Илон Маск рекомендует:  Что такое код is_nan

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

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

Функции в действии

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

Но прежде, чем вносить в программу изменения, определимся с тем, что мы все-таки хотим получить в итоге. Допустим, что мы хотим сделать следующие вещи:

  1. Реализовать-таки возможность повторного прохождения игры без перезапуска программы;
  2. Добавить немного «геймплея». Иначе говоря, введем уровни сложности и подсчет очков. Новые уровни можно реализовать как повторное прохождение игры с увеличением сложности (скажем, за счет расширения диапазона загадываемых значений);
  3. В продолжение п. 2 добавить еще и таблицу рекордов, которая будет сохраняться на диске.

Поскольку часть работы уже выполнена, то для того, чтобы приступить к разработке новой версии игры (назовем ее «Угадай-ка 2.0»), мы не будем как обычно создавать новый консольный проект в Delphi, а откроем уже существующий (Ugadaika) и сохраним его под новым именем, скажем, Ugadaika2, и в новом каталоге. Таким образом, мы уже имеем часть исходного кода, отвечающую за угадывание, в частности, цикл while (см. листинг 4.5). Этот фрагмент логичнее всего выделить в отдельную процедуру, вернее даже функцию, которая будет возвращать число попыток, сделанное пользователем. Для этого создадим функцию, которая будет принимать в качестве аргумента число, которое следует угадать, а возвращаемым значением будет целое, соответствующее числу попыток. Ее объявление будет таким:

function GetAttempts(a: integer):integer;

Данная функция так же должна иметь в своем распоряжении переменную, необходимую для ввода пользователем своего варианта ответа. Еще одна переменная нужна для подсчета результата, т.е. количества попыток. В качестве первой можно было бы использовать глобальную переменную (b), однако во избежание накладок, для локального использования в функции следует использовать локальную же переменную. Что касается переменной-счетчика, то для нее как нельзя лучше подходит автоматическая переменная result. Еще одним изменением будет использование цикла repeat вместо while. Это вызвано тем, что с одной стороны, тем, что хотя бы 1 раз пользователь должен ввести число, т.е. условие можно проверять в конце цикла, а с другой мы можем избавиться от присвоения лишнего действия, а именно — присвоения заведомо ложного значения переменной b. Ну и еще одно дополнение — это второе условие выхода, а именно — ограничение на число попыток, которое мы установим при помощи константы MAXATTEMPTS:

const MAXATTEMPTS = 10;

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

Листинг 6.6. Функция GetAttempts

function GetAttempts(a: integer):integer; var b: integer; begin Result:=0; repeat inc(Result); // увеличиваем счетчик числа попыток write(#13+#10+’?:’); read(b); if (b>a) then begin write(‘Too much!’); continue; end; if (b

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

var level, score, attempt: integer; f: TextFile; s: string;

Теперь инициализируем счетчик псевдослучайных чисел (т.е. оставим randomize на месте) и инициализируем нулем значения счета и уровня:

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

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

repeat writeln(‘Level ‘+IntToStr(level)+’:’); writeln(‘From 0 to ‘+IntToStr(level*100)); attempt:=GetAttempts(random(level*100+1)); score:=score+(MAXATTEMPTS-attempt)*level; writeln(#10+’You current score is: ‘+IntToStr(score)); inc(level); until attempt>MAXATTEMPTS;

После завершения работы цикла, т.е. когда пользователь хоть раз истратит на отгадывание все 10 попыток, следует сообщить итоговый результат и сравнит его с предыдущим значением, которое следует считать из файла. Файл мы назовем records.txt, и сопоставим с переменной f:

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

if not FileExists(‘record.txt’) then begin Rewrite(f); writeln(f,’0′); // первая строка содержит число-рекорд writeln(f,’None’); // а вторая — имя последнего победителя CloseFile(f); end;

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

Reset(f); readln(f, attempt); readln(f,s); writeln(#10+’BEST SCORE: ‘+IntToStr(attempt)+’ by ‘+s); CloseFile(f);

Ну и последнее, чего нам остается — это проверить, является ли новое значение выше рекорда, и если да — то записать новый рекорд в файл, не забыв спросить имя игрока:


Вот, собственно, и все. Полный код получившейся программы можно увидеть на листинге 6.7, или же в файле проекта в каталоге Demo\Part1\Ugadaika2.

Листинг 6.7. Программа угадай-ка, окончательный вариант

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

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

Читайте также:

  1. Cущность банковского процента, его функции и роль.
  2. I. Функции времени в спутниковых технологиях.
  3. I. Экстремумы функции двух переменных
  4. II. Основные направления социально-медицинской работы с семьями детей ограниченными возможностями
  5. III. Лекционный материал по теме: ПРАВИЛА РАБОТЫ НА ЛЕКЦИИ
  6. IV. Функции
  7. IX. Лекционный материал: ОРГАНИЗАЦИЯ САМОСТОЯТЕЛЬНОЙ РАБОТЫ
  8. N В условиях интенсивной мышечной работы, при гипоксии (например, интенсивный бег на 200м в течении 30 с) распад углеводов временно протекает в анаэробных условиях
  9. N Выполняет функции гормона
  10. N Особенности структуры и функции обуславливают особенности в метаболизме клеток
  11. TCR. Функции Т-лимфоцитов
  12. VIII. Принципы работы вычислительной системы

Основные процедуры и функции:

Процедура: AssignFile(var Vf; FileName: string);Модуль: System

Описание: Процедура устанавливает ассоциативную связь между файловой переменной Vf и внешним файлом, имя которого определено параметром FileName. Все операции, производимые с файловой переменной, будут производиться со связанным с ней файлом. FileName — выражение типа string или PChar (если допускается расширенный синтаксис). Если в качестве имени файла указать пустую строку, то файловая переменная будет ассоциирована со стандартным файлом ввода (когда после AssignFile следует процедура Reset) или вывода (когда после следует процедура Rewrite).

Пример:
var Vf : file of Integer;
begin
.
AssignFile(Vf,'work.dat'); //инициализирует файловую переменную
Rewrite(Vf); //создает файл 'work.dat'
CloseFile(Vf); //закрывает файл
.
end;

Процедура: BlockRead(var Vf: file; var Buf; Count: Integer [;var AmtTransferred: Integer]); Модуль: System

Описание: Процедура читает одну или большее количество записей из открытого файла, связанного с файловой переменной Vf, в переменную Buf. Параметр Count определяет количество записей, которое необходимо прочитать из файла. В параметре AmtTransferred возвращается фактическое количество прочитанных записей, которое может быть меньше Count (например, когда размер последнего блока данных в файле меньше заданного размера записи). Максимальный размер прочитанного блока равен Count*RecSize байт. RecSize — размер записи, определенный, во время открытия файла (если размер записи не был задан, то используется значение по умолчанию — 128 байт). Параметр AmtTransferred является необязательным. Но если данный параметр опущен, а количество прочитанных записей меньше Count, то возникнет ошибка ввода/вывода (исключение EInOutError).

Пример:
var
Vf1, Vf2: file; NRead, NWrite: Integer;
Buf: array[1..1024] of Char;
begin
AssignFile(Vf1, 'read.txt');
Reset(Vf1, 1); //Устан-ет размер записи входного файла = 1
AssignFile(Vf2, 'write.txt');
Rewrite(Vf2, 1); //Устан-ет размер записи выходного файла = 1
repeat
BlockRead(Vf1, Buf, SizeOf(Buf), NRead); //читает данные
BlockWrite(Vf2, Buf, NRead, NWrite); //записывает данные
until (NRead = 0) or (NWrite <> NRead);
CloseFile(Vf1);
CloseFile(Vf2);
end;

Процедура: BlockWrite(var Vf: file; var Buf, Count: Integer [;var AmtTransferred: Integer]); Модуль: System

Описание: Процедура записывает одну или несколько записей из переменной Buf во внешний файл, связанный с файловой переменной Vf. Параметр Count определяет количество записей, которое необходимо записать в файл. В параметре AmtTransferred возвращается фактическое количество скопированных записей, которое может быть меньше Count (например, когда место на диске закончилось до окончания записи в файл). Максимальный размер записываемого блока равен Count*RecSize байт, где RecSize — размер записи, определенный, во время открытия файла или 128 байт, если размер записи не был определен. Параметр AmtTransferred является необязательным. Но если данный параметр опущен, и количество прочитанных записей будет меньше Count, то возникнет ошибка ввода/вывода (исключение EinOutError).

Пример:
var
Vf1, Vf2: file;
NRead, NWrite: Integer;
Buf: array[1..1024] of Char;
begin
AssignFile(Vf1, 'read.txt');
Reset(Vf1, 1); //Устан-ет размер записи входного файла = 1
AssignFile(Vf2, 'write.txt');
Rewrite(Vf2, 1); //Устан-ет размер записи выходного файла = 1
repeat
BlockRead(Vf1, Buf, SizeOf(Buf), NRead); //читает данные
BlockWrite(Vf2, Buf, NRead, NWrite); //записывает данные
until (NRead = 0) or (NWrite <> NRead);
CloseFile(Vf1);
CloseFile(Vf2);
end;

Процедура: CloseFile(var Vf); Модуль: System

Описание: Процедура разрывает ассоциативную связь между файловой переменной и внешним файлом, при этом, файл обновляется и закрывается. Механизм обработки ошибок ввода/вывода с помощью обработчиков исключений включается директивой компилятора <$I+>. При использовании директивы <$I->информацию об ошибках можно получить с помощью функции IOResult.

Пример:
var
Vf: file of Integer;
begin
.
AssignFile(Vf, 'work.dat'); //инициализирует файловую переменную
Rewrite(Vf); //создает файл 'work.dat'
CloseFile(Vf); //закрывает файл
.
end;

Процедура: Erase(Var Vf); Модуль: System

Описание: Удаляет файл, связанный с файловой переменной Vf. Vf — файловая переменная, ассоциированная с файлом любого типа. Перед удалением файл необходимо закрыть процедурой CloseFile.

Пример:
var
Vf: file;
begin
AssignFile(Vf, 'C:\WINDOWS\TEMP\tmpfile.tmp');
Rewrite(Vf); //создает временный файл 'tmpfile.tmp'
.
CloseFile(Vf); //закрывает файл
Erase(Vf); //удаляет файл
end;

Процедура: FindClose(var F: TSearchRec); Модуль: SysUtils

Описание: Процедура завершает последовательность вызовов функций FindFirst — FindNext и высвобождает память, выделенную при вызове функции FindFirst.

Процедура: Read(Vf, V1 [, V2, . Vn ]); Модуль: System

Описание: Процедура читает информацию из файла, ассоциированного с файловой переменной Vf, в переменную(ые) Vn.

Типизированные файлы. Читает запись (компонент) из файла в переменную. Файлы строкового типа. Читает все символы до маркера конца строки, не включая его или пока значение Eof(Vf) не будет равно True. Если размер прочитанной строки больше, чем размер строковой переменной, то строка усекается. После прочтения строки, каждый последующий вызов данной процедуры будет возвращать пустую строку, т.к. процедура Read не переводит указатель на новую строку. Если необходимо прочитать более одной записи из файла, то используйте процедуру ReadLn. Файлы символьного типа. Читает символ из файла. Если достигнут конец файла (т.е. Eof(Vf)=True), то процедура возвращает символ ‘Ctrl+Z’ (ASCII код 26).

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

Пример:
var
Vf1,Vf2: TextFile;
FileName1, FileName2: string;
C: Char;
begin
FileName1:='read.txt'; //подразумевается, что файл существует
FileName2:='write.txt';
AssignFile(Vf1, FileName1);
Reset(Vf1); //открывает файл 'read.txt'
AssignFile(Vf2, FileName2);
Rewrite(Vf2); //создает файл 'write.txt'
while not Eof(Vf1) do //повтор, пока не достигнут конец файла
begin
Read(Vf1, C); //читает символ из файла 'read.txt'
Write(Vf2, C); //записывает символ в файл 'write.txt'
end;
CloseFile(Vf2);
CloseFile(Vf1);
end;

Процедура: Rename(var Vf; NewName); Модуль: System

Описание: Процедура переименовывает файл, связанный с файловой переменной Vf. Новое имя файла указывается в параметре NewName. NewName — переменная типа string или PChar (если допускается расширенный синтаксис). После выполнения данной процедуры все операции c файловой переменной Vf будут производиться над переименованным файлом.

Процедура: Reset(var Vf: File [;RecSize: Word]); Модуль: System

Описание: Процедура открывает существующий файл и устанавливает указатель в начало файла. Vf — файловая переменная, ассоциированная с файлом любого типа при помощи процедуры AssignFile. RecSize — необязательный параметр, указывающий размер записи файла. Когда параметр RecSize опущен, размер записи принимается по умолчанию 128 байт. Если файл, связанный с файловой переменной Vf, не существует, то при вызове процедуры Reset возникнет ошибка. Если файл уже открыт, то при вызове данной процедуры он сначала закрывается, а затем снова открывается. Если с файловой переменной Vf связан текстовый файл, то он открывается только для чтения.

Процедура: Rewrite(var Vf: File [; Recsize: Word]); Модуль: System

Описание: Процедура создает новый файл и открывает его. Параметр Vf определяет файловую переменную, связанную с любым типом файлов при помощи процедуры AssignFile. RecSize — необязательный параметр, указывающий размер записи файла. Когда параметр RecSize опущен, размер записи принимается по умолчанию 128 байт. Если файл с заданным именем уже существует, то процедура удаляет старый файл и создает новый пустой файл. Если файл существует и открыт, то функция перед удалением старого файла сначала закрывает его. Если файловая переменная Vf связана с текстовым файлом, то он открывается только для записи. После вызова данной процедуры Eof(Vf)=True.

Процедура: Seek(var Vf; N: Longint); Модуль: System

Описание: Устанавливает файловый указатель в заданную позицию файла. Параметр Vf представляет собой файловую переменную, ассоциированную с типизированным или нетипизированным файлом. Для успешного выполнения процедуры файл должен быть открыт. Индекс позиции, в которую будет установлен указатель, определяется параметром N. Первая позиция в файле имеет индекс 0. Если необходимо добавить данные в конец файла, то поставить указатель в конец файла Vf можно следующим образом: Seek(Vf, FileSize(Vf)).

Процедура: Truncate(var Vf); Модуль: System

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

Процедура: Write(Vf, V1. Vn); (для типизированных файлов) Модуль: System

Описание: Процедура записывает данные в типизированный файл. Параметр Vf представляет собой файловую переменную, связанную с типизированным файлом. Тип переменных V1 . Vn должен соответствовать типу фала. При записи в файл очередного компонента, указатель текущей позиции файла передвигается на следующий компонент. Если перед вызовом данной процедуры указатель стоит в конце файла (Eof(Vf)=True), то записываемые данные будут добавлены в конец файла (размер файла соответственно увеличится).

Функция: DeleteFile(const FileName: string): Boolean; Модуль: SysUtils

Описание: Функция удаляет файл с диска. При успешном выполнении возвращает True, а если файл не существует, или не может быть удален, то — False.

Пример:
var
FileName: string;
begin
.
if DeleteFile(FileName) then
MessageDlg('Файла успешно удален', mtInformation, [mbOk], 0)
else
MessageDlg('Ошибка удаления файла', mtInformation, [mbOk], 0);
.
end;

Функция: DiskFree(Drive: Byte): Int64; Модуль: SysUtils

Описание: Функция возвращает количество свободного места на диске, указанном в параметре Drive, в байтах. Диск определяется следующим образом: 0 — текущий, 1 — ‘A’, 2 — ‘B’, 3 — ‘С’, и т.д. Если указанный диск не существует, или недоступен, то функция возвращает -1.

Функция: DiskSize(Drive: Byte): Int64; Модуль: SysUtils

Описание: Функция возвращает размер диска Drive в байтах. Диск определяется следующим образом: 0 — текущий, 1 — ‘A’, 2 — ‘B’, 3 — ‘С’, и т.д. Если указанный диск не существует, или недоступен, то функция возвращает -1.

Функция: Eof(var Vf ): Boolean; Модуль: System

Описание: Функция определяет, стоит ли указатель текущей позиции в конце файла Vf (Vf — файловая переменная). Если указатель стоит на последнем символе файла, или файл не содержит данных, то функция возвращает True, а иначе — False.

Пример:
var
Vf1,Vf2: TextFile;
FileName1, FileName2: string;
C: Char;
begin
FileName1:='read.txt'; //подразумевается, что файл существует
FileName2:='write.txt';
AssignFile(Vf1, FileName1);
Reset(Vf1); //открывает файл 'read.txt'
AssignFile(Vf2, FileName2);
Rewrite(Vf2); //создает файл 'write.txt'
while not Eof(Vf1) do //повтор, пока не достигнут конец файла
begin
Read(Vf1, C); //читает символ из файла 'read.txt'
Write(Vf2, C); //записывает символ в файл 'write.txt'
end;
CloseFile(Vf2);
CloseFile(Vf1);
end;

Функция: FileExists(const FileName: string): Boolean; Модуль: SysUtils

Описание: Функция проверяет, существует ли файл с именем FileName. Если файл существует, то функция возвращает True, иначе — False.

Функция: FileGetAttr(const FileName: string): Integer; Модуль: SysUtils

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

Константа Значение Описание
faReadOnly faHidden faSysFile faVolumeID faDirectory faArchive faAnyFile $00000001 $00000002 $00000004 $00000008 $00000010 $00000020 $00000003F Только чтение Скрытый файл Системный файл Идентификатор тома Каталог Архивный файл Произвольный файл

В случае возникновении ошибки функция возвращает -1.

Функция: FilePos(var Vf): LongInt; Модуль: System

Описание: Функция возвращает текущую позицию указателя в файле (файл должен быть предварительно открыт). Параметр Vf представляет собой файловую переменную, ассоциированную с файлом. Данная функция не может быть применена к текстовым файлам.

Пример:
var
Vf: File of Byte;
S : string;
Size, I: Integer;
begin
Randomize; AssignFile(Vf, 'work.dat');
Rewrite(Vf); //создает файл work.dat
for I:= 0 to 100 do
begin
Seek(Vf, I);
Write(Vf, I); //записывает в файл послед. чисел от 1 до 100
end;
Size:= FileSize(Vf); //определяет размер файла
Seek(Vf, random(Size)); //устанавливает указатель в произвольную позицию
MessageDlg('Позиция указателя: ' + IntToStr(FilePos(Vf)), mtInformation, [mbOk], 0);
.
CloseFile(Vf);
end;

Функция: FileSearch(const FileName, DirList: string): string; Модуль: SysUtils

Описание: Функция осуществляет поиск файла FileName в каталогах, указанных в параметре DirList. Имя файла должно быть представлено в DOS-формате. Список каталогов DirList представляет собой строку, содержащую наименования каталогов, разделенных точками с запятой (например, ‘C:\;C:\WINDOWS; C:\WINDOWS\TEMP’). Если файл найден, то функция возвращает полный путь к файлу, а иначе возвращается пустая строка.

Функция: FileSetAttr(const FileName: string): Integer; Модуль: SysUtils

Описание: Функция устанавливает атрибуты файла, имя которого передано в параметре FileName. Атрибуты перечисляются в параметре Attr с помощью оператора OR. В случае успешного выполнения функция возвращает 0, а иначе возвращается код ошибки Windows.
Значение констант атрибутов:

Константа Значение Описание
faReadOnly faHidden faSysFile faVolumeID faDirectory faArchive faAnyFile $00000001 $00000002 $00000004 $00000008 $00000010 $00000020 $00000003F Только чтение Скрытый файл Системный файл Идентификатор тома Каталог Архивный файл Произвольный файл

Пример:для файла устанавливаются атрибуты ‘Скрытый файл’ и ‘Только чтение’.
FileSetAttr('MyFile.zzz', faReadOnly or faHidden);

Функция: FileSize(var Vf): Integer; Модуль: System

Описание: Функция возвращает размер файла, связанного с файловой переменной Vf в байтах. Для файлов типа Record функция возвращает количество записей. Если файл не содержит данных, то функция возвращает 0. Файл должен быть обязательно открыт. Данная функция не применима к текстовым файлам.

Описание: Функция находит файл с набором атрибутов Attr в каталоге и по маске, определенных константой Path. Найденное имя файла записывается в переменную F. Если указанный файл найден, то функция возвращает 0, иначе возвращается код ошибки Windows. Параметр Attr — комбинация нескольких констант атрибутов файла или их значений. Константа Path представляет собой полный путь с маской файла (например, ‘C:\MYDIR\*.ini’ ). Повторный поиск файла производится с помощью функции FindNext. По окончанию поиска необходимо высвободить память, выделенную при вызове функции FindFirst, с помощью процедуры FindClose. Значение констант атрибутов:

Константа Значение Описание
faReadOnly faHidden faSysFile faVolumeID faDirectory faArchive faAnyFile $00000001 $00000002 $00000004 $00000008 $00000010 $00000020 $00000003F Только чтение Скрытый файл Системный файл Идентификатор тома Каталог Архивный файл Произвольный файл

Описание: Функция используется в цепочке FindFirst - FindNext - FindClose для повторного поиска файла. Первый поиск осуществляется с помощью функции FindFirst. Функция FindNext возвращает следующий найденный файл, удовлетворяющий условиям поиска определенным при вызове функции FindFirst. В случае успешного выполнения, функция FindNext возвращает 0, а в случае возникновения ошибки — код ошибки Windows. По окончанию поиска необходимо высвободить память с помощью функции FindClose.

Функция: IOResult: Integer; Модуль: System

Описание: Функция возвращает статус ошибки последней выполненной операции ввода/вывода. Использование данной функции возможно только при отключенной проверке ошибок директивой компилятора <$I->. При возникновении ошибки ввода/вывода, все последующие операции ввода/вывода будут игнорироваться до тех пор, пока не будет сделано обращение к функции IOResult. Вызов IOResult очищает внутренний флаг ошибки. Альтернативным способом обработки ошибок ввода/вывода является использование механизма обработки исключительных ситуаций, который включается директивой компилятора <$I+>.

Функция: RenameFile(const OldName, NewName: string): Boolean; Модуль: SysUtils

Описание: Функция переименовывает файл OldName в NewName. При успешном выполнении возвращает True, а в случае ошибки False.

Пример:
begin
if RenameFile('OLD.TXT', 'NEW.TXT') then
MessageDlg(Файл переименован!', mtInformation, [mbOk], 0)
else
ErrorMsg('Невозможно переименовать файл!');
end;

| следующая лекция ==>
Современные способы и средства тушения пожаров | Работа с текстовыми файлами

Дата добавления: 2014-01-07 ; Просмотров: 872 ; Нарушение авторских прав? ;

Нам важно ваше мнение! Был ли полезен опубликованный материал? Да | Нет

Exclude — Процедура Delphi

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

На основании личного опыта автора была составлена система методов, которые позволяют значительно усилить контроль над выполнением программы, ее сопровождением и исправлением обнаруживаемых ошибок. Статья может быть полезна как для начинающих, так и для профессиональных программистов. Однако, предполагается, что читатель хорошо знаком со средой разработки Borland Delphi и языком Object Pascal, а также таким понятием как исключение.

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

2. Процедура ASSERT

В Object Pascal введена специализированная процедура Assert, назначение которой — помощь в отладке кода и контроле над выполнением программы. Процедура является аналогом макроса ASSERT, который широко применяется практически во всех программах, написанных с использованием C и C++ и их библиотек. Синтаксис процедуры Assert (макрос имеет похожий синтаксис) описан ниже.

Процедура проверяет логическое утверждение, передаваемое первым аргументом и, если это утверждение ложно, то процедура выводит на экран диагностическое сообщение с номером строки и именем модуля, где расположен вызов этой процедуры, и сообщение пользователя, которое опционально передается вторым аргументом. В некоторых системах разработки, например (MSVC+MFC), макрос Assert принудительно завершает выполнение программы после выдачи соответствующего диагностического сообщения. В других системах (например Delphi) стандартная процедура ограничивается лишь выдачей диагностического сообщения.

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

В языках С и С++ отладочный режим компиляции задается определением (#define) соответствующей константы, обычно это _DEBUG. В Object Pascal отладочный режим включается специальной опцией компилятора. Кроме того, в С и С++ макрос ASSERT — это обычный макрос, ничем не отличающийся от множества других макросов. Макрос использует переменную компилятора __LINE__, что позволяет ему определить номер строки, в которой произошло нарушение проверки. В Object Pascal такой переменной нет, и за реализацию процедуры Assert полностью отвечает компилятор, что позволяет говорить о процедуре Assert, как об особенности компилятора и языка Object Pascal, а не как об обычной процедуре в составе библиотеки VCL.

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

  • в начале процедуры или функции для проверки правильности переданных аргументов;
  • в начале процедуры или функции для проверки правильности внутренних переменных;
  • в конце работы алгоритма для проверки правильности работы алгоритма;
  • для проверки правильности выполнения «надежных» функций, то есть тех функций, которые всегда должны выполняться успешно всегда, и их невыполнение рассматривается как фатальная ошибка программы. Хороший пример — функция CloseHandle вызываемая с верным дескриптором. Практически, можно не сомневаться в правильности выполнения этой функции, однако результат ее выполнения все-таки можно и нужно проверить. Подробнее об этом в главе «Категории ошибок».

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

Первая процедура проверяет, является ли переданная ссылка на объект непустой. Вторая процедура проверяет индекс добавляемого элемента на принадлежность к ограниченному диапазону. Третья процедура проверяет правильность выполнения алгоритма. Ясно, что при невыполнении хотя бы одного из этих условий, необходимо считать, что данная процедура выполнилась неправильно, и дальнейшее правильное выполнение всей программы не представляется возможным. Ясно также, что, так как данную процедуру (процедуру AddElement) вызываем только мы (наша программа), такое событие никогда не должно происходить, в предположении, что алгоритм правилен и аргументы, передаваемые в функцию, верные. Однако, как известно: «Человек полагает, а Бог располагает», и при невнимательном программировании в большом проекте такой тип ошибок становиться основным.

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

В настоящее время (в пятой версии Delphi и несколько более ранних версиях), процедура Assert генерирует на месте своего вызова исключение типа EAssertionFailed и дальнейшее следование этого исключения осуществляется обычным образом — вверх по стеку процедур до ближайшего обработчика исключений. Исключения от процедуры Assert обрабатываются таким же образом, как и все другие — объект TApplication ловит все исключения и показывает их тип и их сообщения на экране. Однако такой подход трудно считать логичным. Исключения от процедуры Assert коренным образом отличаются от остальных исключений. Исключения от процедуры Assert свидетельствуют о серьезных ошибках в логике работы программы и требуют особого внимания, вплоть до принудительного завершения программы с выводом особого диагностического сообщения.

Реализация процедуры Assert в Object Pascal полностью возложена на компилятор (вернее на «приближенный ко двору» модуль system.pas), что несколько затрудняет изменение логики работы. Возможны три основных варианта внесения изменений в логику работы.

  1. Установка обработчика события TApplication.OnException и обработка в нем исключения с типом EAssertionFailed. Данный способ является наиболее простым, и менее гибким. Подходит, если все что необходимо — это вывести на экран особое сообщение и принудительно завершить программу.
  2. Прямая установка обработчика процедуры Assert, путем присвоения адреса своей процедуры системной переменной AssertErrorProc. Область применения практически та же самая, что и в предыдущем случае. Однако, в этом случае, возможны и более сложные манипуляции. Например, можно написать обработчик, который не генерирует исключение, а сразу выводит сообщение и принудительно завершает программу. Пример такого обработчика приведен ниже.
  3. Написание процедуры Assert заново. Самый гибкий и удобный вариант. Например, если вас не устраивает стандартный синтаксис процедуры Assert, и вы хотите передать в процедуру дополнительные параметры (например, тип ошибки, тип генерируемого исключения, код, и т.п.). При этом возникает два особых момента связанных с тем фактом, что за процедуру Assert отвечает компилятор. Во-первых, вы не сможете управлять включением и включением вызовов процедуры Assert в программе через стандартные опции. Процедура Assert будет выполняться всегда. Единственное, что вы можете сделать — это сразу выйти из процедуры, если режим работы программы не отладочный. Во-вторых, в самой процедуре невозможно узнать номер строки, в которой произошел вызов процедуры. Тем не менее, обе этих трудности преодолимы.

Необходимость включения и выключения вызовов процедуры Assert, связанных с режимом работы программы является само собой подразумевающейся. Считается, что выключение вызовов Assert в отлаженной программе позволяет уменьшить размер программы и увеличить скорость ее работы. Однако, экономия на размере и увеличение быстродействия являются весьма малыми (если вы не включаете процедуру Assert в тело каждого цикла). Происходящее на этом фоне, молчаливое съедание ошибок в программе ставит под сомнение необходимость отключать вызовы процедуры Assert в «готовой» программе. То, что вы не нашли ошибок при разработке и отладке программы вовсе не означает, что там их нет. Ошибки могут появиться у пользователя программы, например, в условиях, в которых программа не тестировалась. Как вы о них узнаете, если отключите вызовы Assert? Конечно, лукавое отключение предупреждений может на время сохранить вашу репутацию, и пользователь может и не узнать о тех ужасах, которые происходят в недрах вашей программы. А внезапный безымянный сбой вашей программы вы можете списать на особенности работы Windows. Однако качества вашей программе это не прибавит. Честная регистрация всех ошибок намного улучшит ваши программы.

Таким образом, первая трудность решена — ее просто не нужно решать. Работайте честно, всегда оставляйте вызовы функций Assert в программе, и они помогут диагностировать ошибки. Решение второй проблемы — указание номеров строк в сообщениях описано в следующей главе. Пример же простейшей альтернативной процедуры Assert приведен ниже. Функция называется AssertMsg и принимает те же параметры, что и стандартная процедура. Конечно, список этих параметров можно расширить, так же, как и изменить логику работы. Данная же процедура генерирует исключение по адресу вызова этой процедуры, а глобальный обработчик исключений выводит сообщение и завершает программу при получении исключения с определенном типом EFatalExcept.

3. Номера строк или уникальные метки ?

В большинстве систем разработки, в сообщении, выводимом при активизации процедуры Assert, выводится три параметра: сообщение пользователя, имя исходного модуля и номер строки, в котором находился вызов процедуры. При этом основной упор при поиске ошибки делается на номер строки и имя модуля, а сообщение пользователя является малоинформативным. Однако, если вы решили оставить вызовы процедуры Assert в готовой распространяемой программе, здесь таится проблема. При разработке программы вы будете выпускать десятки и десятки версий, и естественно, что исходный код будет сильно модифицироваться, а номера линий, на которых располагаются проверочные вызовы, будут постоянно изменяться. И если вдруг ваш пользователь сообщает о том, что в вашей программе сработала проверка на линии N в исходном модуле M, вы должны задаться вопросом, какая версия программы находится у пользователя? Даже если вы сохраните все исходные тексты абсолютно всех версий, такой подход нельзя назвать удобным и ясным, он таит в себе скрытую путаницу и неразбериху, поскольку вам придется отслеживать номера строк в разных версиях программы при просмотре развития программы.

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

Что выбрать в качестве уникальных идентификаторов? Можно выбрать любое не повторяющееся число или строку. Например, последовательно передавать числа от нуля и далее с инкрементом на единицу. Или передавать уникальные строки, которые можно придумывать на ходу. Однако, это утомительное занятие — помнить последний набранный номер или строку и не повторяться. Можно написать специальный модуль для редактора в среде Delphi, который будет автоматически вводить идентификаторы. Однако, если вы будете работать над проектом на разных машинах, то возникнет проблема синхронизации счетчиков.

Существует прекрасный вариант решения этой проблемы. В среде Delphi нажмите клавиши + + и вы получите строку похожую на эту: [‘<19619100-22b0-11d4-acd0-009027350d25>‘]. Это уникальный идентификатор GUID (Global Unique IDentificator), шестнадцатибайтное уникальное значение, переведенное в строковый вид с разграничителями и заключенное в квадратные скобки. Такое значение уникально, оно зависит от времени и от номера сетевой карты. Если сетевой карты нет, то номер генерируется программно. По крайней мере, Microsoft утверждает, что такой номер никогда не повторится. Каждый раз, когда вы нажмете соответствующую комбинацию клавиш, система сгенерирует новый уникальный код. Если удалить квадратные скобки по бокам, то получиться отличный уникальный строковый идентификатор, готовый к использованию, при этом вызов процедуры AssertMsg будет выглядеть подобным образом.

В данном случае сообщение пользователя не передается — передается только уникальная метка. В самом деле, какая разница пользователю, отчего именно погибла ваша программа? Пользователь лишь должен сообщить, что ваша программа работает с ошибкой и передать информацию, которая поможет эту ошибку найти. Конечно, подобный уникальный номер занимает некоторое место в сегменте констант, но, как показывает практика, не больше 5% от всего объема программы, и в добавление, такой номер очень удобно записывать с экрана. Кроме того, он действительно никогда не повторяется! Если же вы — эконом, и вам жалко тратить 38 байт на каждый идентификатор, можете передавать в процедуру AssertMsg четырехбайтное число, которое можно получить, взяв первые восемь шестнадцатеричных цифр из строкового идентификатора — именно они изменяются чаще всего.

4. Категории ошибок

В последнее время, практически во всех развитых объектно-ориентированных языках, появилась структурная обработка исключений. Эта возможность поддерживается операционной системой и позволяет перехватывать нештатные ситуации возникающие, как в обычном, так и в защищенном режиме системы. Язык Object Pascal полностью поддерживает все возможности по обработке исключений. Использование исключений при разработке программ рекомендуется документацией и поддерживается широким использованием исключений в VCL. Типичный пример обработки исключений приведен ниже.

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

По умолчанию все исключения обрабатываются одинаково. Исключения, если они не перехвачены обработчиком пользователя, передаются в глобальный обработчик исключений TApplication.HandleException. Обработчик проверяет тип исключения, а затем выводит диагностическое сообщение, после чего выполнение программы продолжается.

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

Прежде всего, ошибки нужно разделить на две группы — фатальные ошибки и нефатальные или восстановимые ошибки. Фатальные ошибки — это ошибки «несовместимые с жизнью», после которых выполнение программы невозможно и бессмысленно. Фатальная ошибка всегда является неожиданной и подразумевается маловероятной. Например, любое срабатывание проверки Assert означает серьезное нарушение логики работы программы. Сбой при выделении памяти или ресурсов в большинстве случаев также является невосстановимым. Подавляющее большинство API функций при передаче в них правильных параметров можно отнести к «надежным» функциям, то есть таким функциям, в выполнении которых мы уверены, и невыполнение которых маловероятно, но приводит к фатальным ошибкам. Фатальные ошибки можно отнести к серьезным недостаткам либо в программе, либо в операционной системе.

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

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

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

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

Таким образом, мы пришли к пониманию того, что существуют разные группы ошибок, с разным алгоритмом их обработки. Как уже упоминалось, все ошибки в библиотеке VCL обрабатываются одинаковым образом. Изменить существующее положение вещей можно разными способами. Например, в можно анализировать все типы исключений в обработчике TApplication.OnException. Исключения таких типов как, например, EAccessViolation, EListError, EAbstractError, EArrayError, EAssertionFailed и многих других можно рассматривать как фатальные ошибки, а исключения остальных типов рассматривать как восстановимые ошибки. При этом откат при восстановимых ошибках выполнять путем локального перехвата исключения конструкцией try-except-end, обработки и дальнейшей генерации исключения инструкцией raise. Однако такой способ не является гибким, так как один и тот же тип исключения в одной операции может рассматриваться как восстановимый, а в другой — как фатальный.

Улучшенной разновидностью такого способа является способ, когда все восстановимые исключения от VCL перехватываются и обрабатываются на местах, а фатальные исключения транспортируются в глобальный обработчик TApplication.OnException. Таким образом, глобальный обработчик рассматривает любое исключение как фатальное. Перехват восстановимых исключений не занимает много места, так как и было указано раньше, подавляющее большинство операций можно и нужно рассматривать как «надежные» операции, то есть приводящие к фатальным ошибкам.

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

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

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

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

5. Тотальный контроль

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

Однако существует еще одна проблема, связанная с тем, что широко используемая библиотека VCL, а также множество других естественно не используют выше указанные принципы. Например, при выполнении следующего кода возникнет исключение от VCL с сообщением «List index out of bounds», так как мы запрашиваем на один элемент больше, чем есть в списке. Получив сообщение о такой ошибке от пользователя, вы вряд ли сможете определить место программы, где эта ошибка произошла. Поиск такой ошибки затруднен, даже если она возникла на вашем компьютере, на том, на котором вы разрабатываете программу. А если такая ошибка возникла у далекого пользователя, сложность возрастает во много раз, так как вам предстоит еще и «выбить» всю информацию об ошибке у человека далекого от Delphi в частности, и от программирования вообще.

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

Одним из успешных вариантов решения такой проблемы является помещение каждой (каждой !) процедуры в конструкцию try-except-end. При этом локальный обработчик исключения ловит возникшую ошибку и заменяет ее своей с указанием уникального идентификатора. При этом предыдущий пример может выглядеть так.

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

Получив информацию о возникшей ошибке вы можете:

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

Такая информация значительно облегчает поиск и исправление ошибок в очень большом проекте.

Все вышеперечисленное являлось лишь приблизительным рецептом и пищей для размышления. Точный вариант комплексной системы обработки ошибок приведен в прилагаемом архиве. Модуль ATSAssert.pas содержит примеры процедур и функций для обработки фатальных ошибок. Модуль ATSDialogMain.pas содержит примеры их использования.

7. Пример модуля с функциями комплексной обработки ошибок

Объявления деклараций используемых функций

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

Глобальный обработчик исключений устанавливает процедуру обработки на событие Application.OnException. Это позволяет перехватывать все исключения не пойманные конструкцией try-except-AssertInternal-end. Хотя таких непойманных исключений быть не должно, лучше все-таки поставить на них обработчик.

Если вы пишите библиотеку DLL в таком обработчике нет необходимости, так как все непойманные исключения будут обрабатывать в EXE-модуле. Основная процедура обработки ошибок

Основная процедура обработки ошибок. Формирует и выводит сообщение, записывает его в посмертный лог и закрывает программу. Если вы пишете библиотеку DLL, то для каждой библиотеки можете добавить к сообщению свой дополнительный префикс, например ‘A’, ‘B’, ‘C’ и т.д. Это поможет быстро определить в каком модуле произошла ошибка. Альтернативная процедура Assert Альтернативная процедура Assert для API-функций

Функция для тотального контроля исключений


Функция для перехвата исключений от VCL и неудачных обращений к памяти. Добаляет к тексту исключения уникальную метку и генерирует ошибку. Инициализация модуля

Создание и настройка глобального обработчика исключения на событии TApplication.OnException.

8. Пример использования системы комплексного контроля

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

Правильная обработка освобождения ресурсов через try…finally в Delphi

Есть много разных вариантов как можно использовать конструкцию try. finally для освобождения ресурсов. Многие из них работают неверно в особых ситуациях. Рассмотрим несколько вариантов подробнее.

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

Прежде всего, установим ReportMemoryLeaksOnShutdown := True в dpr файле, для того чтобы отслеживать утечки памяти.

Delphi.FireDAC. Выполнение хранимых процедур и функций

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

Класс TFDStoredProc может быть использован как designtime так и в runtime. TFDStoredProc генерирует SQL команду для вызова хранимой процедуры, базирующейся на свойствах TFDStoredProc. Перед исполнением, FireDAC отправляет значения параметров к DBMS, и после этого исполняет хранимую процедуру и получает output параметры.

Замечание. FireDAC не поддерживает параметры со значениями по умолчанию.

Настройка хранимых процедур в Design Time

Чтобы выполнить хранимую процедуру, необходимо бросить компонент TFDStoredProc на форму. Свойство TFDStoredProc.Connection будет автоматически настроено, если на форме есть FDConnection.

Опционально можно установить CatalogName, SchemaName, и PackageName или выбрать их значения из выпадающего списка. После установки StoredProcName и когда fiMeta включено в FetchOptions.Items, коллекция параметров заполняется автоматически.

Чтобы унифицировать имена параметров, можно установить ResourceOptions.UnifyParams в True. Например, это исключит префикс ‘@’ из имен параметров SQL сервера.

Настройка хранимых процедур в RunTime

Аналогично design-time можно использовать следующий код для run-time

Блог GunSmoker-а

. when altering one’s mind becomes as easy as programming a computer, what does it mean to be human.

19 апреля 2009 г.

Настройки проектов в Delphi с точки зрения поиска ошибок

О чём идёт речь

Сначала, давайте посмотрим на них: открываем Project/Options. Нас будут интересовать вкладки Compiling и Linking (в старых версиях Delphi они назывались Compiler и Linker):

На вкладке «Compiler» нас будут интересовать опции «Stack Frames», группа «Debug information», «Local Symbols» и «Symbol reference info», «I/O Checking», «Overflow checking» и «Range checking». На «Linking» — «Map file», «Debug Information» (известная в предыдущих версиях Delphi как «Include TD32 debug info») и «Include remote debug symbols».

Давайте посмотрим, за что отвечают эти опции. А затем — как их лучше бы всего расставить. При этом мы будем рассматривать такие ситуации: обычное приложение и приложение с механизмом диагностики исключений.
Кроме того, настройки проекта могут отличаться, компилируете ли вы приложение для себя или для распространения. В новых версиях Delphi появились профили настроек (Debug и Release, соответственно). Вы можете задать свой набор настроек в каждом профиле, а затем переключаться между ними. В старых Delphi есть только один профиль настроек и вам нужно менять каждую настройку вручную.

Напомним, что при смене любой из опций необходимо сделать полный Build проекту (а не просто Compile).

Что означают эти опции?

Самыми важными настройками являются группа опций «Debug information», «Local Symbols» и «Symbol reference info».

Программа представляет собой набор машинных команд. Текст программы представляет собой текстовый файл. Вопрос: как отладчик узнаёт, когда надо остановиться, если вы поставили бряк на строку в тексте? Где же соответствие между текстовым файлом и набором байт в exe-файле? Вот для такой связи и служит отладочная информация. Это, грубо говоря, набор инструкций типа: «машинные коды с 1056 по 1059 относятся к строке 234 модуля Unit1.pas». Вот с помощью такой информации и работает отладчик. Указанные выше опции отвечают за генерацию отладочной информации для ваших модулей.

Отладочная информация сохраняется вместе с кодом модуля в dcu-файле. Т.е. один и тот же Unit1.pas может быть скомпилирован как с отладочной информацией, так и без неё — в разные dcu файлы. Отладочная информация увеличивает время компиляции, размер dcu-файлов, но не влияет на размер и скорость работы полученного exe-файла (т.е. отладочная информация не подключается к exe-файлу) (*).

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

Подключение отладочной информации к приложению осуществляется несколькими способами: либо это опции проекта (а именно: «Map File», «Debug information» (Linker)/«Include TD32 Debug info» или «Include remote debug symbols»), либо это возможности всевозможных экспертов (типа EurekaLog, JCL или madExcept), которые добавляют отладочную информацию в программу в своём формате.

Итак, опции отладочной информации:

  • «Debug information» (директива <$D+>или <$D->) – это собственно и есть отладочная информация. Т.е. соответствие между текстом программы и её машинным кодом. Вы должны включить эту опцию, если хотите ставить бряки, выполнять пошаговую отладку, а также иметь стек с именами для своего кода. Часто эту опцию включают автоматически различные эксперты типа EurekaLog.
  • «Local symbols» (директива <$L+>или <$L->) – является дополнением к отладочной информации. Она отвечает за соответствие между данными в exe-файле и именами переменных. Если вы включаете эту опцию, то отладчик позволит вам просматривать и изменять переменные. Также окно «Call Stack» будет способно отражать переданные в процедуры параметры.
  • «Reference info» – это дополнительная информация для редактора кода, которая позволяет ему отображать более подробную информацию об идентификаторах. Например, где была объявлена переменная.

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

  • «Use Debug DCUs» — эта опция переключает сборку вашей программы с отладочными модулями Delphi или с обычными. Если вы внимательно посмотрите на установку Delphi, то увидите, что pas файлы из папки Source никогда не используются для компиляции — а только для отладки. Для компиляции же используются уже готовые dcu-файлы из папки Lib. Это уменьшает время компиляции. Поскольку dcu могут быть скомпилированы с отладочной информацией и без неё, то в папке Lib есть два набора dcu-файлов: обычные и отладочные. Переключая эту опцию, вы указываете, какие из них использовать. Если вы выключите эту опцию, то не сможете заходить по F7 в стандартные функции и методы Delphi (т.к. для них будет отсутствовать отладочная информация). Также при выключенной опции вы не будете видеть информацию о стандартном коде в стеке вызовов.
  • «Stack Frames» — эта опция отвечает за генерацию стековых фреймов. Если опция выключена, то стековый фрейм не генерируется без необходимости. Если она включена -то фрейм генерируется всегда. Стековые фреймы используются при построении стека вызовов по фреймам (построение методом raw-сканирование не нуждается в стековых фреймах). В обычном приложении стековые фреймы генерируются практически всегда (**).
  • «Range checking» — служит помощником в поиске проблем при работе, например, с массивами. Если её включить, то для любого кода, который работает с массивами и строками, компилятор добавляет проверочный код, который следит за правильностью индексов. Если при проверке обнаруживается, что вы вылезаете за границы массива, то будет сгенерировано исключение класса ERangeError. При этом вы можете идентифицировать ошибку обычной отладкой. Если же опция выключена, то никакого дополнительного кода в программу не добавляется. Включение опции немного увеличивает размер программы и замедляет её выполнение. Рекомендуется включать эту опцию только в отладочной версии программы.
  • «Overflow checking» — похожа на опцию «Range checking», только проверочный код добавляется для всех арифметических целочисленных операций. Если результат выполнения такой операции выходит за размерность (происходит переполнение результата), то возбуждается исключение класса EIntOverflow. Пример – к байтовой переменной, равной 255, прибавляется 2. Должно получиться 257, но это число больше того, что помещается в байте, поэтому реальный результат будет равен 1. Это и есть переполнение. Эта опция используется редко по трём причинам. Во-первых, самый разный код может рассчитывать на то, что эта опция выключена (часто это различного рода криптографические операции, подсчёт контрольной суммы и т.п., но не только). В связи с этим при включении этой опции могут начаться совершенно различные проблемы. Во-вторых, в обычных ситуациях работают с четырёхбайтовыми знаковыми величинами, и работа около границ диапазонов представления происходит редко. В-третьих, арифметические операции с целыми – достаточно частый код (в отличие от операций с массивами), и добавление дополнительной работы на каждую операцию иногда может быть заметно (в смысле производительности).
  • «I/O Checking» — эта опция используется только при работе с файлами в стиле Паскаля, которые считаются устаревшими. По-хорошему, вы не должны использовать их и, соответственно, эту опцию.

Замечу также, что эти опции можно выставлять и локально — как для целого модуля, так и для отдельной функции/процедуры (а для некоторых опций — даже для участка кода). Делается это обычными директивами компилятора, узнать которые вы можете, нажав F1 в окне настроек. Например, «Stack Frames» регулируется <$W+>и <$W->.

Кроме того, помимо настроек компилятора (Compiling) есть ещё настройки компоновщика (Linking):

  • «Map file» — включение опции заставляет линкёр Delphi создавать вместе с проектом map-файл. Различные установки опции отвечают за уровень детализации и обычно имеет смысл ставить только Off или Detailed. Map файл обычно используется всевозможными утилитами типа EurekaLog, JCL или madExcept в качестве первичного источника для создания отладочной информации в своём формате. Поэтому руками устанавливать эту опцию вам придётся крайне редко — эксперты включают её самостоятельно по необходимости.
  • «Debug Information» (Linker)/«Include TD32 debug info» — внедряет в приложение отладочную информацию для внешнего отладчика в формате TD32. Обычно эта опция включается, если вы отлаживаете проект через Attach to process и Delphi не может найти отладочную информацию. При включении этой опции размер самого приложения увеличивается в 5-10 раз (при условии, что опция «Place debug information in separate TDS file» выключена). Поэтому, если вам нужна отладочная информация в распространяемом приложении — лучше рассмотреть другие варианты (лучше всего подходит отладочная информация в специализированных форматах — EurekaLog, JCL, madExcept).
  • «Include remote debug symbols» — заставляет линкёр создать rsm-файл вместе с проектом, в который записывается информация для удалённого отладчика Delphi. Вам нужно включать эту опцию, если вы хотите выполнить удалённую отладку. Полученный rsm-файлик нужно копировать вместе с приложением на удалённую машину.

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

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

Обычное приложение без механизма диагностики исключений

Общие настройки для любых профилей

Все опции отладки («Debug information» (Compiler), «Local symbols», «Reference info») вообще на готовый модуль не влияют, т.к. отладочная информация в exe/DLL не хранится, ну и нам жить не мешают => поэтому смысла их выключать я не вижу («Use Debug DCUs» — устанавливайте по вкусу, смотря по тому, хотите вы отлаживаться в стандартных модулях или нет).

«Stack Frames» вообще включать незачем.

Генерацию map-файла выключаем.

Профиль Debug

Включаем «Range checking» и (по вкусу) «Overflow checking».

«Include TD32 debug info» — включаем только для отладки внешнего процесса.

Соответственно, «Include remote debug info» — включаем только для удалённой отладки.

Профиль Release

Выключаем «Range checking», «Overflow checking», «Include TD32 debug info» и «Include remote debug info».

Приложение с механизмом диагностики исключений (типа EurekaLog, JCL или madExcept)

Общие настройки любых профилей

Все опции отладки («Debug information» (Compiler), «Local symbols», «Reference info») держать включёнными, т.к. в противном случае не будет доступна отладочная информация. Соответственно, ваши информационные механизмы пойдут лесом.

«Stack Frames» — вообще вЫключать незачем.

Генерацию map-файла включаем, если об этом не позаботился эксперт (маловероятно).

Профиль Debug

«Use Debug DCUs» — по вкусу.
Включаем «Range checking» и (по вкусу) «Overflow checking».

«Include TD32 debug info» — включаем только для отладки внешнего процесса.

«Include remote debug info» — включаем только для удалённой отладки.

Профиль Release

Включаем «Use Debug DCUs».

Выключаем «Range checking», «Overflow checking», «Include TD32 debug info» и «Include remote debug info».

Примечание: если вы используете мало операций с индексами в своей программе (так что дополнительные проверки не замедлят её), то будет хорошей идеей всегда держать опцию «Range checking» включённой.

Что может пойти не так, если настройки будут заданы неверно?

Ну, во-первых, это невозможность отладки (например, отсутствие информации для удалённого отладчика или выключенная опция «Debug information» (Compiler)), большой размер приложения (например, случайно забыли выключить «Debug information» (Linker)/«Include TD32 debug info»), медленная работа (например, компиляция с отладочным кодом), отсутствие или неполный стек вызовов в средствах диагностики исключений (например, выключили «Debug information» (Compiler)). В очень редких и запущенных случаях переключение опций может сказаться на работоспособности программы (например, установка Stack frames может снизить максимально возможную глубину рекурсии). Ну и недочёты по мелочи.

Кстати, если вы разрабатываете компоненты, то надо учитывать, что у Delphi есть именно два набора DCU-файлов, которые отличаются настройками компиляции. Вообще говоря, простое переключение опций, ответственных за генерацию отладочной информации, никак не влияет на интерфейс и реализацию модуля. Но в общем случае код может использовать условные директивы. Поэтому может быть ситуация, когда два набора DCU файлов (скомпилированных с разными опциями) не совместимы друг с другом — потому что они использовали какую-либо директиву и содержат разный код (а вот и пример).
Поэтому вам тоже надо иметь два набора DCU-файлов: один — скомпилированный с опцией «Use Debug DCUs», другой — без. Причём, не важно включена или выключена опция «Debug information» (Compiler) в ваших настройках в обоих случаях.

Примечания:
(*) Слова «отладочная информация увеличивает время компиляции, размер dcu-файлов, но не влияет на размер и скорость работы полученного exe-файла» некоторые понимают неправильно. В частности, многие замечают, что если переключить профиль приложения с Debug на Release (или наоборот), то размер приложения изменится (незначительно или же намного — зависит от настроек проекта и его исходного кода). Позвольте, но ведь я говорю об отладочной информации в чистом виде (мы говорим про опции «Debug Information», «Local Symbols» и т.п. с вкладки «Compiling»), а вы меняете профиль компиляции целиком. Это не только смена опций отладочной информации (которые, кстати, могут даже вообще не меняться при смене профиля), а также и множество других настроек.

Например, в вашем коде может быть тьма конструкций вида <$IFDEF DEBUG>какой-то код <$ENDIF>. Разумеется, когда вы собираете программу в Release, этот код в программу не попадёт, а когда вы собираете его в Debug, то — попадёт. Потому что по умолчанию профиль Debug содержит символ условной компиляции «DEBUG». В результате размер .exe действительно получится разный. Но повлияла ли на этот размер отладочная информация? Неа. Фактически, вы собрали в разных профилях разных код — неудивительно, что он разный по размеру.

Более того, вы можете удалить из конфигурации Debug символ условной компиляции «DEBUG» — и тогда вы будете собирать один и тот же код в обоих профилях. Ну, по крайней мере, свой код. Сторонний, уже собранный код, конечно же, никак не будет затронут. Например, код RTL/VCL уже скомпилирован с фиксированными настройками и не меняется при пересборке проекта. Вон там чуть выше я упомянул, что в некоторых версиях Delphi отладочный и релизный варианты кода RTL/VCL незначительно отличаются — опять же, благодаря условной компиляции. Но никак не отладочной информации.

Кроме того, к иному коду приводит и включение/выключение опций вида Optimization, Stack Frames, Range Check Errors и др. Действительно, оптимизация может удалять код (оптимизировать ненужный) или увеличивать (вставлять inline вместо вызова), Stack Frames очевидно добавляет код (код установки фрейма), равно как и Range Check Errors (код проверки диапазонов). В результате, вы меняете профиль — вы меняете и код (при условии, что разные профили имеют разные настройки вышеупомянутых опций — что так и есть по умолчанию). Меняете код — меняете и размер. Имеет ли хоть какое-то отношение к этому изменению размера отладочная информация? Нет.

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

Также о внедрении отладочной информации можно попросить и среду. Например, вы можете включить «Include TD32 Debug Info» (эта опция называется «Debug Information» на вкладке «Linking» в последних версиях Delphi) и выключить опцию «Place debug information in separate TDS file». Тогда вся отладочная информация из .dcu файлов будет собрана в один большой файл и этот файл будет внедрён в .exe. Тогда да, отладочная информация повлияет на размер файла, но это происходит не из-за её свойств, а потому что мы явно попросили такое поведение: «добавьте отладочную инфу в мою программу».

Кстати говоря, в последних версиях Delphi здорово поменяли настройки профилей компиляции. Если раньше Release и Debug мало чем отличались, то теперь отличия существенны. Профиль Debug выключает Optimization, но включает Stack Frames (а профиль Release — делает наоборот). Профиль Debug включает отладочную информацию, а Release — отключает. Но оба профиля включают Assert-ы. Также оба профиля включают I/O checks, но выключают overflow и range. В настройках компоновщика (linking) профиль Debug включает TD32 («Debug information») и Remote debug symbols (не для всех платформ). Release, соответственно, выключает эти же опции. И оба профиля не включают Map file и отдельный файл для TD32.

(**) Например: Button1Click состоит всего из двух инструкций: «call A; ret;». Она очень короткая и не использует аргументы или локальные переменные. Поэтому, очевидно, что ей не нужен стековый фрейм. Когда опция «Stack frames» выключена, то для Button1Click стековый фрейм не создаётся (но он создаётся, если опция «Stack frames» будет включена).

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

Например, тоже очень короткая процедура B всегда имеет фрейм. Причина: использование типа String в ShowMessage. Компилятору нужно вставить неявную строковую переменную и неявный try/finally для её освобождения, поэтому процедуре нужен фрейм.

В реальных приложениях фреймы генерируются для 99% процедур. Подробнее: Фреймы на стеке.

Exclude — Процедура Delphi

Структурная обработка исключительных ситуаций

Модель исключительных ситуаций в Delphi

Синтаксис обработки исключительных ситуаций

Примеры обработки исключительных ситуаций

Вызов исключительной ситуации

Доступ к экземпляру объекта exception

Предопределенные обработчики исключительных ситуаций

Исключения, возникающие при работе с базами данных

    1. Обзор
    2. С целью поддержки структурной обработки исключительных ситуаций ( exception ) в Delphi введены новые расширения языка Pascal. В данной статье будет дано описание того, что из себя представляет такая обработка, почему она полезна, будут приведены соответствующий синтаксис Object Pascal и примеры использования исключительных ситуаций в D elphi.
    3. Структурная обработка исключительных ситуаций
    4. Структурная обработка исключительных ситуаций — это система, позволяющая программисту при возникновении ошибки (исключительной ситуации) связаться с кодом программы, подготовленным для обработки такой ошибки. Это выполняется с помощью языковых конструкций, которые как бы “охраняют” фрагмент кода программы и определяют обработчики ошибок, которые будут вызываться, если что-то пойдет не так в “охраняемом” участке кода. В данном случае понятие исключительной ситуации относится к языку и не нужно его путать с системными исключительными ситуациями (hardware exceptions), такими как General Protection Fault. Эти исключительные ситуации обычно используют прерывания и особые состояния “железа” для обработки критичной системной ошибки; исключительные ситуации в Delphi же независимы от “железа”, не используют прерываний и используются для обработки ошибочных состояний, с которыми подпрограмма не готова иметь дело. Системные исключительные ситуации, конечно, могут быть перехвачены и преобразованы в языковые исключительные ситуации, но это только одно из применений языковых исключительных ситуаций.

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

    Такая “пожарная бригада” для обработки ошибок трудоемка, требует написания большого количества кода в котором можно легко ошибиться и который трудно отлаживать.

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

    Структурная обработка исключительной ситуации замещает ручную обработку ошибок автоматической, сгенерированной компилятором системой уведомления. В приведенном выше примере, процедура A установила бы “охрану” со связанным обработчиком ошибки на фрагмент кода, в котором вызывается B. B просто вызывает C. Когда C обнаруживает ошибку, то создает ( raise ) исключительную ситуацию. Специальный код, сгенерированный компилятором и встроенный в Run-Time Library (RTL) начинает поиск обработчика данной исключительной ситуации. При поиске “защищенного” участка кода используется информация, сохраненная в стеке. В процедурах C и B нет такого участка, а в A — есть. Если один из обработчиков ошибок, которые используются в A, подходит по типу для возникшей в C исключительной ситуации, то программа переходит на его выполнение. При этом, область стека, используемая в B и C, очищается; выполнение этих процедур прекращается.

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

    Без проверки возвращаемого кода после каждого вызова подпрограммы, код программы должен быть более простым, а скомпилированный код — более быстрым. При наличии исключительных ситуаций подпрограмма B не должна содержать дополнительный код для проверки возвращаемого результата и передачи его в A. B ничего не должна делать для передачи исключительной ситуации, возникшей в C, в процедуру A — встроенная система обработки исключительных ситуаций делает всю работу.

    Данная система называется структурной, поскольку обработка ошибок определяется областью “защищенного” кода; такие области могут быть вложенными. Выполнение программы не может перейти на произвольный участок кода; выполнение программы может перейти только на обработчик исключительной ситуации активной программы.

  1. Модель исключительных ситуаций в Delphi
  2. Модель исключительных ситуаций в Object Pascal является невозобновляемой( non-resumable ). При возникновении исключительной ситуации Вы уже не сможете вернуться в точку, где она возникла, для продолжения выполнения программы (это позволяет сделать возобновляемая( resumable ) модель). Невозобновляемые исключительные ситуации разрушают стек, поскольку они сканируют его в поисках обработчика; в возобновляемой модели необходимо сохранять стек, состояние регистров процессора в точке возникновения ошибки и выполнять поиск обработчика и его выполнение в отдельном стеке. Возобновляемую систему обработки исключительных ситуаций гораздо труднее создать и применять, нежели невозобновляемую.
  3. Синтаксис обработки исключительных ситуаций

Теперь, когда мы рассмотрели, что такое исключительные ситуации, давайте дадим ясную картину, как они применяются. Новое ключевое слово, добавленное в язык Object Pascal — try . Оно используется для обозначения первой части защищенного участка кода. Существует два типа защищенных участков:

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

on Exception1 do Statement;

on Exception2 do Statement;

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

      1. Примеры обработки исключительных ситуаций
      2. Ниже приведены процедуры A,B и C, обсуждавшиеся ранее, воплощенные в новом синтаксисе Object Pascal:

      if (ErrorCondition) then

      writeln(‘Raising exception in C’);

      writeln(‘Enter A»s try block’);

      writeln(‘After B call’);

      on ESampleError do

      writeln(‘Inside A»s ESampleError handler’);

      on ESomethingElse do

      writeln(‘Inside A»s ESomethingElse handler’);

      При ErrorCondition = True программа выдаст:

      Enter A’s try block

      Raising exception in C

      Inside A’s ESampleError handler

      Возможно вас удивила декларация типа ‘ESampleError = . Описание новой объектной модели дается в других уроках. Здесь же достаточно сказать, что исключительные ситуации (exceptions) являются классами, частью новой объектной модели.

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

      Процедура A помещает часть кода в блок try..except. Первая часть этого блока содержит часть кода, аналогично конструкции begin..end . Эта часть кода завершается ключевым словом except , далее следует один или более обработчиков исключительных ситуаций on xxxx do yyyy , далее может быть включен необязательный блок else, вся конструкция заканчивается end; . В конструкции, назначающей определенную обработку для конкретной исключительной ситуации ( on xxxx do yyyy ), после резервного слова on указывается класс исключительной ситуации, а после do следует собственно код обработки данной ошибки. Если возникшая исключительная ситуация подходит по типу к указанному после on , то выполнение программы переходит сюда (на код после do ). Исключительная ситуация подходит в том случае, если она того же класса, что указан в on, либо является его потомком. Например, в случае on EFileNotFound обрабатываться будет ситуация, когда файл не найден. А в случае on EFileIO — все ошибки при работе с файлами, в том числе и предыдущая ситуация. В блоке else обрабатываются все ошибки, не обработанные до этого.

      Приведенные в примере процедуры содержат код (строка с writeln), который отображает путь выполнения программы. Когда C вызывает exception, программа сразу переходит на обработчик ошибок в процедуре A, игнорируя оставшуюся часть кода в процедурах B и C.

      После того, как найден подходящий обработчик ошибки, поиск оканчивается. После выполнения кода обработчика, программа продолжает выполняться с оператора, стоящего после слова end блока try..except (в примере — writeln(‘Exit A’)).

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

      Рассмотрим модифицированную процедуру B:

      Если C вызывает исключительную ситуацию, то программа уже не возвращается в процедуру B. А что же с теми 1000 байтами памяти, захваченными в B? Строка FreeMem(P,1000) не выполнится и Вы потеряете кусок памяти. Как это исправить? Нужно ненавязчиво включить процедуру B в процесс, например:

      writeln(‘enter NewB»s try block’);

      writeln(‘end of NewB»s try block’);

      writeln(‘inside NewB»s finally block’);

      Если в A поместить вызов NewB вместо B, то программа выведет сообщения следующим образом:

      Enter A’s try block

      enter NewB’s try block

      Raising exception in C


      inside NewB’s finally block

      Inside A’s ESampleError handler

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

      Почему вызов GetMem не помещен внутрь блока try ? Этот вызов может окончиться неудачно и вызвать exception EOutOfMemory. Если это произошло, то FreeMem попытается освободить память, которая не была распределена. Когда мы размещаем GetMem вне защищаемого участка, то предполагаем, что B сможет получить нужное количество памяти, а если нет, то более верхняя процедура получит уведомление EOutOfMemory.

      А что, если требуется в B распределить 4 области памяти по схеме все-или-ничего? Если первые две попытки удались, а третья провалилась, то как освободить захваченную область память? Можно так:

      writeln(‘enter B»s try block’);

      writeln(‘end of B»s try block’);

      writeln(‘inside B»s finally block’);

      if P <> nil then FreeMem(P, 1000);

      if Q <> nil then FreeMem(Q, 1000);

      if R <> nil then FreeMem(R, 1000);

      if S <> nil then FreeMem(S, 1000);

      Установив сперва указатели в NIL, далее можно определить, успешно ли прошел вызов GetMem.

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

    1. Вызов исключительной ситуации
    2. В процедуре C из примера мы уже могли видеть, как должна поступать программа при обнаружении состояния ошибки — она вызывает исключительную ситуацию:

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

      Почти все существующие классы исключительных ситуаций являются наследниками базового класса Exception и не содержат новых свойств или методов. Класс Exception имеет несколько конструкторов, какой из них конкретно использовать — зависит от задачи. Описание класса Exception можно найти в on-line Help.

    3. Доступ к экземпляру объекта exception
    4. До сих пор мы рассматривали механизмы защиты кода и ресурсов, логику работы программы в исключительной ситуации. Теперь нужно немного разобраться с тем, как же обрабатывать возникшую ошибку. А точнее, как получить дополнительную информацию о коде ошибки, текст сообщения и т.п.

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

      Рассмотрим модифицированную процедуру A в нашем примере:

      writeln(‘Enter A»s try block’);

      writeln(‘After B call’);

      on E: ESampleError do writeln(E.Message);

      on ESomethingElse do

      writeln(‘Inside A»s ESomethingElse handler’);

      Здесь все изменения внесены в строку

      on ESE: ESampleError do writeln(ESE.Message);

      Пример демонстрирует еще одно новшество в языке Object Pascal — создание локальной переменной. В нашем примере локальной переменной является ESE — это тот самый экземпляр класса ESampleError, который был создан в процедуре C в момент вызова исключительного состояния. Переменная ESE доступна только внутри блока do. Свойство Message объекта ESE содержит сообщение, которое было передано в конструктор Create в процедуре C.

      Есть еще один способ доступа к экземпляру exception — использовать функцию ExceptionObject:

      on ESampleError do

      writeln( ESample Error(ExceptionObject).Message);

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

      • Exception — базовый класс-предок всех обработчиков исключительных ситуаций.
      • EAbort — “ скрытое” исключение. Используйте его тогда, когда хотите прервать тот или иной процесс с условием, что пользователь программы не должен видеть сообщения об ошибке. Для повышения удобства использования в модуле SysUtils предусмотрена процедура Abort , определенная, как:

      raise EAbort.CreateRes(SOperationAborted) at ReturnAddr;

      • EComponentError — вызывается в двух ситуациях:
    5. 1) при попытке регистрации компоненты за пределами процедуры Register;

      2) когда имя компоненты не уникально или не допустимо.

      • EConvertError — происходит в случае возникновения ошибки при выполнении функций StrToInt и StrToFloat , когда конвертация строки в соответствующий числовой тип невозможна.
      • EInOutError — происходит при ошибках ввода/вывода при включенной директиве <$I+>.
      • EIntError — предок исключений, случающихся при выполнении целочисленных операций.
      • EDivByZero — вызывается в случае деления на ноль, как результат RunTime Error 200.
      • EIntOverflow — вызывается при попытке выполнения операций, приводящих к переполнению целых переменных, как результат RunTime Error 215 при включенной директиве <$Q+>.
      • ERangeError — вызывается при попытке обращения к элементам массива по индексу, выходящему за пределы массива, как результат RunTime Error 201 при включенной директиве <$R+>.
      • EInvalidCast — происходит при попытке приведения переменных одного класса к другому классу, несовместимому с первым (например, приведение переменной типа TListBox к TMemo).
      • EInvalidGraphic — вызывается при попытке передачи в LoadFromFile файла, несовместимого графического формата.
      • EInvalidGraphicOperation — вызывается при попытке выполнения операций, неприменимых для данного графического формата (например, Resize для TIcon).
      • EInvalidObject — реально нигде не используется, объявлен в Controls.pas.
      • EInvalidOperation — вызывается при попытке отображения или обращения по Windows-обработчику (handle) контрольного элемента, не имеющего владельца (например, сразу после вызова MyControl:=TListBox.Create(. ) происходит обращение к методу Refre sh).
      • EInvalidPointer — происходит при попытке освобождения уже освобожденного или еще неинициализированного указателя, при вызове Dispose(), FreeMem() или деструктора класса.
      • EListError — вызывается при обращении к элементу наследника TList по индексу, выходящему за пределы допустимых значений (например, объект TStringList содержит только 10 строк, а происходит обращение к одиннадцатому).
      • EMathError — предок исключений, случающихся при выполнении операций с плавающей точкой.
      • EInvalidOp — происходит, когда математическому сопроцессору передается ошибочная инструкция. Такое исключение не будет до конца обработано, пока Вы контролируете сопроцессор напрямую из ассемблерного кода.
      • EOverflow — происходит как результат переполнения операций с плавающей точкой при слишком больших величинах. Соответствует RunTime Error 205.
      • Underflow — происходит как результат переполнения операций с плавающей точкой при слишком малых величинах. Соответствует RunTime Error 206.
      • EZeroDivide — вызывается в результате деления на ноль.
      • EMenuError — вызывается в случае любых ошибок при работе с пунктами меню для компонент TMenu, TMenuItem, TPopupMenu и их наследников.
      • EOutlineError — вызывается в случае любых ошибок при работе с TOutLine и любыми его наследниками.
      • EOutOfMemory — происходит в случае вызовов New(), GetMem() или конструкторов классов при невозможности распределения памяти. Соответствует RunTime Error 203.
      • EOutOfResources — происходит в том случае, когда невозможно выполнение запроса на выделение или заполнение тех или иных Windows ресурсов (например таких, как обработчики — handles).
      • EParserError — вызывается когда Delphi не может произвести разбор и перевод текста описания формы в двоичный вид (часто происходит в случае исправления текста описания формы вручную в IDE Delphi).
      • EPrinter — вызывается в случае любых ошибок при работе с принтером.
      • EProcessorException — предок исключений, вызываемых в случае прерывания процессора- hardware breakpoint. Никогда не включается в DLL, может обрабатываться только в “цельном” приложении.
      • EBreakpoint — вызывается в случае останова на точке прерывания при отладке в IDE Delphi. Среда Delphi обрабатывает это исключение самостоятельно.
      • EFault — предок исключений, вызываемых в случае невозможности обработки процессором тех или иных операций.
        • EGPFault — вызывается, когда происходит “общее нарушение защиты” — General Protection Fault. Соответствует RunTime Error 216.
        • EInvalidOpCode — вызывается, когда процессор пытается выполнить недопустимые инструкции.
        • EPageFault — обычно происходит как результат ошибки менеджера памяти Windows, вследствие некоторых ошибок в коде Вашего приложения. После такого исключения рекомендуется перезапустить Windows.
        • EStackFault — происходит при ошибках работы со стеком, часто вследствие некорректных попыток доступа к стеку из фрагментов кода на ассемблере. Компиляция Ваших программ со включенной проверкой работы со стеком <$S+>помогает отследить такого рода ошибки.
      • ESingleStep — аналогично EBreakpoint, это исключение происходит при пошаговом выполнении приложения в IDE Delphi, которая сама его и обрабатывает.
      • EPropertyError — вызывается в случае ошибок в редакторах свойств, встраиваемых в IDE Delphi. Имеет большое значение для написания надежных property editors. Определен в модуле DsgnIntf.pas.
      • EResNotFound — происходит в случае тех или иных проблем, имеющих место при попытке загрузки ресурсов форм — файлов .DFM в режиме дизайнера. Часто причиной таких исключений бывает нарушение соответствия между определением класса формы и ее описанием на уровне ресурса (например,вследствие изменения порядка следования полей-ссылок на компоненты, вставленные в форму в режиме дизайнера).
      • EStreamError — предок исключений, вызываемых при работе с потоками.
      • EFCreateError — происходит в случае ошибок создания потока (например, при некорректном задании файла потока).
      • EFilerError — вызывается при попытке вторичной регистрации уже зарегистрированного класса (компоненты). Является, также, предком специализированных обработчиков исключений, возникающих при работе с классами компонент.
        • EClassNotFound — обычно происходит, когда в описании класса формы удалено поле-ссылка на компоненту, вставленную в форму в режиме дизайнера. Вызывается, в отличие от EResNotFound, в RunTime.
        • EInvalidImage — вызывается при попытке чтения файла, не являющегося ресурсом, или разрушенного файла ресурса, специализированными функциями чтения ресурсов (например, функцией ReadComponent).
        • EMethodNotFound — аналогично EClassNotFound, только при несоответствии методов, связанных с теми или иными обработчиками событий.
        • EReadError — происходит в том случае, когда невозможно прочитать значение свойства или другого набора байт из потока (в том числе ресурса).
        • EFOpenError — вызывается когда тот или иной специфированный поток не может быть открыт (например, когда поток не существует).
      • EStringListError — происходит при ошибках работы с объектом TStringList (кроме ошибок, обрабатываемых TListError).

      Delphi, обладая прекрасными средствами доступа к данным, основывающимися на интерфейсе IDAPI, реализованной в виде библиотеки Borland Database Engine (BDE), включает ряд обработчиков исключительных ситуаций для регистрации ошибок в компонентах VCL работающим с БД. Дадим краткую характеристику основным из них:

      • EDatabaseError — наследник Exception ; происходит при ошибках доступа к данным в компонентах-наследниках TDataSet. Объявлено в модуле DB . Ниже приведен пример из Delphi On-line Help, посвященный этому исключению:

      Exclude — Процедура Delphi

      A set variable is one that can contain 0, some, or all values of a set. When you exclude a set value in a set variable, you are removing from the included values in the variable.

      exclude is equivalent to the operator, as shown here :

      Exclude(CardHand, JackOfClubs);
      CardHand := CardHand — [JackOfClubs];

      For example, you can remove a playing card from a players hand — where the hand is based on a set of all playing cards in a deck.

      Обработка исключений в Delphi

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

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

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

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

      Процедуры Delphi

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

      Начнем с определения:

      Процедура Delphi – группа операторов объединенных вместе под одним именем.

      Из чего состоит процедура?

      1. Ключевое слово procedure
      2. Имя процедуры
      3. Список параметров
      4. Тело процедуры (Та самая группа операторов)

      Приведу пример процедуры:

      Этот простейший Del p hi код принимает целочисленное значение. Если это значение равно 1, 2 или 5, то выводим соответствующее сообщение. Иначе сообщаем, что введенное число не равно ни одному из списка.

      Рассмотрим как нам это использовать. Создайте новый проект и разместите на нем всего одну кнопку. По клику на неё будем вызывать MyProc c параметром 5 :

      Код программы целиком у меня получился такой:

      Теперь в двух словах расскажу для чего нужны процедуры Делфи и какие плюсы от их использования. Если мы часто повторяющиеся фрагменты кода выделим в процедуру и дадим ей информативное имя – получим следующие преимущества:

      1. Код станет короче
      2. Читаться программа будет проще
      3. Редактировать логику приложения не составит труда

      Я рекомендую Вам использовать процедуры Delphi.

      Илон Маск рекомендует:  Что такое код fbsql_field_name
Понравилась статья? Поделиться с друзьями:
Кодинг, CSS и SQL