PromptForFileName — Функция Delphi

Содержание

PromptForFileName — Функция Delphi

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

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

От: ssm
Дата: 02.04.03 08:52
Оценка:

Здравствуйте, balder, Вы писали:

B>Возникла вот такая необходимость создать такой объект в ходе выполнения программы.
B>Не подскажет ли кто-нибудь как это сделать?
B>Вариант
B>
B>не работает.
B>Или может быть есть функция API, вызывающая диалог открытия файла?

на билдере, могу только предположить:

<
std::auto_ptr pod(new TOpenDialog(0));
pod->Execute();
>

От: ssm
Дата: 02.04.03 08:58
Оценка:

Здравствуйте, ssm, Вы писали:

пардонсер

ssm>на Delphi:

ssm>

ssm>
ssm>на билдере, могу только предположить:

От: balder
Дата: 02.04.03 09:18
Оценка:

Здравствуйте, ssm, Вы писали:

ssm>Здравствуйте, balder, Вы писали:

B>>Возникла вот такая необходимость создать такой объект в ходе выполнения программы.
B>>Не подскажет ли кто-нибудь как это сделать?
B>>Вариант
B>>
B>>не работает.
B>>Или может быть есть функция API, вызывающая диалог открытия файла?

ssm>на билдере, могу только предположить:

ssm>
ssm> <
ssm> std::auto_ptr pod(new TOpenDialog(0));
ssm> pod->Execute();
ssm>>

не совсем так, но по аналогии с Delphi получилось:

PromptForFileName — Функция Delphi

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

Исключения и их классы

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

При возникновении подобных ошибок в программах, созданных при помощи Delphi, автоматически создается объект — Exception. Класс Exception является базовым для ряда других классов исключений — EMathError, EInvalidOp, EZeroDivide и т.д. (названия всех классов, относящиеся к исключениям, принято начинать не с буквы T, а с буквы E). Он происходит непосредственно от класса TObject и имеет 2 свойства — Message и HelpContext, а так же 8 методов.

Свойство Message имеет тип string и содержит описание исключения. При возникновении ошибки этот текст используется в окне сообщения. Ас войство HelpContext определяет индекс раздела справочного файла, содержащего информацию об ошибке. Если значение этого свойства равно нулю, то оно будет ссылаться на раздел справки родительского объекта.

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

constructor Create(const Msg: string);

Т.е., фактически, создавая исключение, следует сразу же назначить значение его свойству Message при помощи аргумента конструктора. Другой вариант конструктора, CreateHelp, позволяет параллельно назначить значение и для второго свойства:

constructor CreateHelp(const Msg: string; AHelpContext: Integer);

Если в тексте сообщения следует привести какие-либо динамически получаемые данные, то используют вариант конструктора с суффиксом Fmt:

constructor CreateFmt(const Msg: string; const Args: array of const); constructor CreateFmtHelp (const Msg: string; const Args: array of const; AHelpContext: Integer);

При этом значения, указанные в массиве Args, будут подставлены в строку. Для этого используется функция Format, которой передаются строка и массив в качестве аргументов. Эта функция выполняет подстановку значений массива в места строки, выделенные при помощи символа %. Например, если строка выглядит как «Ошибка в функции %s», а массив определен как «[‘MyFunc’]», то результатом выполнения этой функции будет «Ошибка в функции MyFunc». Соответственно, создание подобного исключения будет выглядеть следующим образом:

constructor CreateFmt(‘Ошибка в функции %s’, [‘MyFunc’]);

Как уже было отмечено, класс Exception имеет ряд потомков, каждый из которых предназначен для обработки того или иного типа ошибок. Например, для математических ошибок определен класс EMathError. Однако этот класс сам по себе не используется, зато его потомки, среди которых отметим классы EInvalidOp, EOverflow, EZeroDivide, используются для оповещения о таких ситуациях, как неверная операция, переполнение буфера и попытка деления на 0, соответственно.

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

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

if password <> ‘password’ then raise Exception.Create(‘Неверный пароль!’);

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

ПРИМЕЧАНИЕ
С некоторыми глобальными объектами, в том числе с Application, мы ознакомимся несколько позже в этой же главе.

Если при этом ошибка возникла в основном коде программы (т.е. вызвавший ошибку код был написан в самом файле проекта dpr), то на этом выполнение программы прекратится, о чем будет выдано сообщение (рис. 10.1).

Рис. 10.1. Ошибка приложения

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

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

Для обработки исключительных ситуаций в Delphi используются специальные операторы — try…except и try…finally. Эти операторы являются своего рода ловушками для исключительных ситуаций и позволяют разработчику приложения предусмотреть код, обрабатывающий возникшие исключения. Тем самым можно на любом этапе перехватить дальнейшее всплытие ошибки.

При помощи оператора try…except выполняет перехват ошибки, как правило, с целью ее подавления. Он имеет следующий синтаксис:

try except [ on do ; ] end;

В том случае, если между except и end не писать никакого кода, то исключительная ситуация будет просто подавлена. Однако такое подавление чаще всего не является достаточным условием, поскольку оно не несет никакой информации ни пользователю, ни самой программе. Например, если так подавить ошибку с неверным паролем (а из-за подавления никакого сообщения выдано не будет), то пользователь такой программы может лишь догадываться, почему после того, как он сообщил пароль, ничего не происходит. В данном случае было бы правильным все-таки сообщить о том, что пароль введен не верно. Для этого используют вложенную секцию on…do:

try if password <> ‘password’ then raise Exception.Create(‘Неверный пароль!’); except on E: Exception do ShowMessage(E.Message); end;

На сей раз в случае возникновения исключения пользователь получит уведомление о том, что же произошло. Для этого мы создали объект E, которому автоматически присваивается значение ошибки, и использовали его для вывода информации о ней. Дальнейшее выполнение программы в данном случае будет продолжено, поскольку после окончания блока try…end исключение более не существует.

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

try if password <> ‘password’ then raise Exception.Create(‘Неверный пароль!’); except on Exception do ShowMessage(‘ОШИБКА!’); end;

Что касается блоков обработки, то их может быть несколько, каждый — для своего класса исключения:

try a:=b*c/d; except on EZeroDivide do ShowMessage(‘Делить на 0 нельзя’); on EOverflow do ShowMessage(‘Слишком большое число’); on EMathError do ShowMessage(‘Математическая ошибка’);; end;

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

try a:=b*c/d; except on EZeroDivide do ShowMessage(‘Делить на 0 нельзя’); on EOverflow do ShowMessage(‘Слишком большое число’); on EMathError do ShowMessage(‘Математическая ошибка’); else ShowMessage(‘Общая ошибка’); end;

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

try a:=b*c/d; except ShowMessage(‘Общая ошибка’); end; Важно лишь отметить, что все эти блоки выполняются только тогда, когда возникает исключительная ситуация. При этом, если после ключевого слова try расположено несколько операторов, и исключение возникает в одном из них, то все последующие выполнены не будут. Вместе с тем, случаются ситуации, когда имеется код, который следует выполнить в любом случае, без оглядки на то, что случится перед этим. В таких случаях используют другой оператор — try…finally, и требующий обязательного выполнения код помещают в часть после finally. Типичным примером использования такой конструкции можно считать уничтожение объектов или иные операции освобождения памяти, а так же закрытия файлов и т.д. Например, при работе с файлами всегда следует использовать try…finally для закрытия файла: try Rewrite(F); writeln(F,s); finally CloseFile(F); end;

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

Но оба подхода можно комбинировать. Например, в данном случае блок try…finally можно вложить в блок try…except:

try AssignFile(F); try Rewrite(F); writeln(F,s); finally CloseFile(F); end; except on E: Exception do ShowMessage(E.Message); end;

Кроме этого, в Delphi допускается вкладывать однотипные обработчики ошибок друг в друга, например, один блок try…except может быть вложен в другой.

Глобальные объекты

При создании Windows-приложений нередко возникает необходимость в управлении программой в целом как отдельным объектом. Для этих целей в Delphi предусмотрен специальный объект — Application класса TApplication, представляющий программу в целом. Его использование можно увидеть в любом файле проекта VCL-приложения. Чтобы увидеть это, достаточно создать новое приложение и открыть файл проекта, для откытия которого можно воспользоваться списком модулей, вызываемого кнопкой View Unit (можно так же через главное меню — View ‘ Units, или при помощи сочетания горячих клавиш Ctrl+F12). По умолчанию он имеет название Project1, и его стандартный код имеет вид, приведенный в листинге 10.1.

Листинг 10.1. Заготовка кода для VCL-приложения

program Project1; uses Forms, Unit1 in ‘Unit1.pas’ ; <$R *.res>begin Application.Initialize; Application.CreateForm(TForm1, Form1); Application.Run; end.

Уже по приведенному в листинге коду мы можем познакомиться с 3 основными методами этого объекта — Initialize, CreateForm и Run. Первый производит подготовительную работу, т.е. фактически, создает объект приложения. Метод CreateForm используется для создания окон приложения, а метод Run производит фактический запуск программы на выполнение. Среди других методов приложения моно отметить такие, как Minimize и Restore, служащие, соответственно, для сворачивания программы на панель задач и для ее восстановления, а так же метод BringToFront, который выводит окно на верхнюю поверхность рабочего стола. Метод Terminate используется для прекращения работы программы (он вызывается автоматически, когда закрывается главное окно приложения). Еще 4 метода — HelpCommand, HelpContext, HelpJump и HelpKeyword — предназначены для работы со справочными файлами.

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

Среди свойств приложения, прежде всего, следует отметить такие, как Title, Icon и HelpFile. Свойство Title определяет заголовок программы, т.е. то, что вы видите на панели задач. Свойство Icon определяет значок («иконку») программы. Ну а свойство HelpFile связывает приложение с файлом справочной информации. Все эти свойства можно определить как программно, написав соответствующий код, так и при помощи окна свойств проекта (Project > Options), на закладке Application (рис. 10.2).

Рис. 10.2. Установка параметров приложения в окне свойств проекта

Если установить в диалоге Project Options новые значения и нажать на кнопку OK, то внесенные изменения для свойств Title и HelpFile отобразятся в коде программы. Что касается значка программы, то он хранится в отдельном файле ресурсов (res), который присоединяется к приложению в процессе компиляции, для чего используется директива «<$R *.res>«.

Поскольку любой визуальный компонент может отображать всплывающую текстовую подсказку, то для объекта Application предусмотрен ряд свойств, управляющих видом и выводом таких подсказок. В частности, цвет определяют при помощи свойства HintColor, задержку перед появлением после наведения на компонент мышки — при помощи HintPause, а время его отображения — свойством HintHidePause.

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

Помимо Application, при запуске приложения создается еще один глобальный объект, представляющий экранную среду — Screen. При помощи этого объекта можно получить информацию о разрешение экрана, установить вид курсора мыши для приложения, или узнать количество его окон. Основные свойства класса TScreen приведены в таблице 10.1.

Таблица 10.1. Основные свойства TScreen

Свойство Тип Описание
ActiveControl TWinControl Указывает, какой элемент управления в данный момент имеет фокус ввода
ActiveForm TForm Указывает, какое окно активно в данный момент
Cursor TCursor Определяет вид указателя курсора мышки для приложения
Cursors array of HCursor Список всех курсоров, доступных для приложения
Fonts TStrings Список названий всех шрифтов, доступных для вывода на экран
FormCount Integer Указывает на число окон (форм), созданных приложением
Forms array of TForm Список всех окон, созданных приложением
Height Integer Указывает на вертикальное разрешение экрана
HintFont TFont Определяет шрифт для всплывающих подсказок
IconFont TFont Определяет шрифт для подписей к значкам в диалогах выбора файлов
MenuFont TFont Определяет шрифт для меню
Width Integer Указывает на горизонтальное разрешение экрана
WorkAreaHeight Integer Указывает на высоту рабочего стола Windows
WorkAreaLeft Integer Указывает на координаты левого угла рабочего стола
WorkAreaRect Integer Указывает на координаты прямоугольника, образующего рабочий стол
WorkAreaTop Integer Указывает на координаты верхнего угла рабочего стола
WorkAreaWidth Integer Указывает на ширину рабочего стола

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

Screen.HintFont.Color:=$00408080; // цвет шрифта Screen.HintFont.Size:=14; // размер шрифта Application.HintColor:=$0080FF80; // цвет фона Application.HintPause:=1000; // задержка перед появлением 1 секунда Application.HintH >

Если вставить этот код в dpr-файл перед обращением к методу Application.Run, то можно будет убедиться, что через секунду после наведения курсора на окно запу-щенного приложения будет появляться всплывающая подсказка с крупным коричне-вым текстом на зеленом фоне. Разумеется, при этом для окна приложения следует установить значения свойства ShowHint в true, и написать какой-либо текст для свой-ства Hint. Впрочем, это можно сделать не только через инспектор объекта в процессе разработки приложения, но и программно, поместив соответствующий код после создания формы. В результате мы получим код, приведенный в листинге 10.2.

Листинг 10.2. Использование объектов Application и Screen

program app_scr; uses Forms, Unit1 in ‘Unit1.pas’ ; <$R *.res>begin Application.Initialize; Application.CreateForm(TForm1, Form1); Form1.Hint:=’Ну и подсказочка!’; Form1.ShowHint:=true; Screen.HintFont.Color:=$00408080; Screen.HintFont.Size:=14; Application.HintColor:=$0080FF80; Application.HintPause:=1000; Application.HintH >

Здесь же можно установить и такие параметры, как заголовок программы, используя свойство Title объекта Application:

Кроме того, можно поэкспериментировать с такими свойствами объекта Screen, как Height и WorkAreaHeight, причем для вывода информации можно использовать заго-ловок главного окна:

Form1.Caption:=’Экран ‘+IntToStr(Screen.Height)+’, рабочий стол ‘+ IntToStr(Screen.WorkAreaHeight);

В данном случае в строку Uses потребуется дописать модуль SysUtils, поскольку ис-пользованная здесь функция IntToStr расположена именно в этом модуле. Оконча-тельный вариант программы можно найти в каталоге Demo\Part2\Global.

Работа с INI-файлами

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

Имя файла, ассоциированного с объектом типа TIniFile, задается непосредственно при создании экземпляра этого класса, в конструкторе Create:

var MyIni: TIniFile; . TIniFile.Create(‘myfile.ini’);

Впоследствии можно узнать, какой файл ассоциирован с данным объектом при по-мощи его свойства FileName, однако изменить его уже не получится. Вместе с тем, у TIniFile имеется свыше 20 методов, при помощи которых можно считывать, прове-рять и изменять содержимое INI-файла. Все они приведены в таблице 10.2.

Таблица 10.2. Методы класса TIniFile

Метод Принимаемые параметры Описание
DeleteKey const Section, Ident: String Удаляет указанный ключ из INI файла
EraseSection const Section: String Удаляет содержимое указанной секции в INI файле
ReadSection const Section: String; Strings: TStrings Считывает имена всех ключей в указанной секции и заносит их в список строк
ReadSections Strings: TStrings Считывает названия всех секций в файле и заносит их в список строк
ReadSectionValues const Section: String; Strings: TStrings Считывает все значения в указанной секции и заносит их в список строк
ReadString const Section, Ident, Default: String Считывает и возвращает значение-строку из указанного ключа
WriteString const Section, Ident, Value: String Записывает значение-строку в указанный ключ
ReadBool const Section, Ident: String; Default: Boolean Считывает и возвращает булево значение из указанного ключа
ReadDate const Section, Ident: String; Default: TDateTime Считывает и возвращает значение-дату из указанного ключа
ReadDateTime const Section, Ident: String; Default: TDateTime Считывает и возвращает значение-дату и время из указанного ключа
ReadFloat const Section, Ident: String; Default: Double Считывает и возвращает значение-вещественное число из указанного ключа
ReadInteger const Section, Ident: String; Default: Longint Считывает и возвращает значение-целое число из указанного ключа
ReadTime const Section, Ident: String; Default: TDateTime Считывает и возвращает значение-время из указанного ключа
SectionExists const Section: String Проверяет INI файл на наличие указанной секции
WriteBool const Section, Ident: String; Value: Boolean Записывает булево значение в указанный ключ
WriteDate const Section, Ident: String; Value: TDateTime Записывает значение-дату в указанный ключ
WriteDateTime const Section, Ident: String; Value: TDateTime Записывает значение-дату и время в указанный ключ
WriteFloat const Section, Ident: String; Value: Double Записывает значение-вещественное число в указанный ключ
WriteInteger const Section, Ident: String; Value: Longint Записывает значение-целое в указанный ключ
WriteTime const Section, Ident: String; Value: TDateTime Записывает значение-время в указанный ключ
ValueExists const Section, Ident: String Проверяет INI файл на наличие указанного ключа в определенной секции

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

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

Листинг 10.3. Название листинга

program myini; <$APPTYPE CONSOLE>uses SysUtils, IniFiles; var ans: Char; fn: string; begin write(‘Load data from an INI file? [Y/N]’); readln(ans); if (ans=’Y’) or (ans=’y’) then begin write(‘Please input file name: ‘); readln(fn); fn:=’c:\’+fn+’.ini’; if FileExists(fn) then begin ShowData(fn); end else begin writeln(‘File not found and will be created.’); FillData(fn); end; end else begin write(‘Please input file name to save data: ‘); readln(fn); fn:=’c:\’+fn+’.ini’; FillData(fn); end; readln(fn); end.

Прежде всего, наша программа интересуется, хочет ли пользователь просмотреть информацию из уже существующего файла, или нет, и если хочет, то запрашивает имя файла. Здесь мы подразумеваем, что пользователь будет вводить только имя файла, без пути и расширения, которые добавляются автоматически. Затем стандартная функция FileExists проверяет получившийся файл на существование, после чего либо выводит его содержимое при помощи процедуры ShowDate (которую нам еще предстоит создать), либо выводит сообщение о том, что файл не найден, но будет создан. После этого программа обращается к процедуре FillData, которая так же будет нами написана для ввода информации и сохранения ее в INI-файле. Эта же функция будет вызвана и в том случае, если пользователь изначально откажется от вывода информации, в таком случае программа предварительно запросит имя файла для дальнейшего сохранения.

Теперь, когда основа программы готова, можно определиться, какие данные мы хотим хранить, и какой для этого понадобится формат файла. Допустим, мы хотим сохранить информацию 2-х категорий: персональную и рабочую. В таком случае наш INI файл будет состоять из 2 секций, скажем, Userdata и Jobdata. В первой секции сохраним имя (Name) и возраст (Age), а во второй — должность (Title) и оклад (Salary). Процедура, отвечающая за вывод информации, получится достаточно простой — в ней достаточно создать INI-файл с указанным именем и последовательно считывать информацию, попутно выводя ее на экран. Например, для строкового значения мы получим следующий код:

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

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

write(‘Name: ‘); readln(s); IniF.WriteString(‘Userdata’,’Name’,s);

Подобный код потребуется выполнить для каждого поля данных, при этом нам понадобятся 3 различных переменных для хранения данных 3 типов (дважды — строк, и по разу целое и вещественное числа). Предварительно следует не забыть создать переменную типа TIniFile, и вывести пояснительный текст, а к завершению работы процедуры освободить память, занимаемую более не нужной переменной. Последнее условие следует выполнить и в процедуре ShowData. В итоге мы получим код, приведенный в листинге 10.4.

Листинг 10.4. Процедуры сохранения и считывания INI-файлов

procedure FillData(fn: string); var IniF: TIniFile; s: string; i: integer; f: double; begin IniF:=TIniFile.Create(fn); writeln(‘Please fill a form. ‘); write(‘Name: ‘); readln(s); IniF.WriteString(‘Userdata’,’Name’,s); write(‘Age: ‘); readln(i); IniF.WriteInteger(‘Userdata’,’Age’,i); write(‘Position: ‘); readln(s); IniF.WriteString(‘Jobdata’,’Title’,s); write(‘Salary: ‘); readln(f); IniF.WriteFloat(‘Jobdata’,’Salary’,f); IniF.Free; end; procedure ShowData(fn: string); var IniF: TIniFile; begin IniF:=TIniFile.Create(fn); writeln(‘Name. ‘+IniF.ReadString(‘Userdata’,’Name’,’Anonymous’)); writeln(‘Age. ‘+IntToStr(IniF.ReadInteger(‘Userdata’,’Age’,0))); writeln(‘Position.. ‘+IniF.ReadString(‘Jobdata’,’Title’,’Unemployed’)); writeln(‘Salary. ‘+FloatToStrF(IniF.ReadFloat(‘Jobdata’,’Salary’,0.00),ffFixed,6,2)); IniF.Free; end;

С полным исходным кодом программы можно ознакомиться в примере, расположенном в каталоге Demo\Part2\IniFiles.

Работа с реестром Windows

Файлы INI и класс TIniFiles — достаточно удобный способ хранения различной настроечной информации. Тем не менее, начиная с Windows 95, появилось централизованное хранилище для настроек системы и всех установленных программ — реестр (Registry). При разработке приложений в Delphi удобнее всего работать с реестром, используя класс TRegistry. Чтобы включить объявление этого класса, следует указать модуль registry в списке uses.

Реестр Windows имеет несколько ключевых разделов, в чем можно убедиться, открыв имеющуюся в Windows программу редактирования реестра (regedit). В частности это разделы HKEY_CLASSES_ROOT, HKEY_CURRENT_USER, HKEY_USERS, HKEY_LOCAL_MACHINE и HKEY_CURRENT_CONFIG. Чтобы приступить к работе с реестром из программы, требуется указать один из разделов. Делается это при помощи свойства RootKey:

var Reg: TRegistry; . Reg:=TRegistry.Create; Reg.RootKey:=HKEY_CURRENT_USER;

Далее в ход идут методы класса TRegistry. В частности, за выбор раздела реестра, из которого надо будет считывать данные, используется метод OpenKeyReadOnly. В качестве аргумента ему передается адрес раздела реестра, например:

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

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

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

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

Что касается записи и считывания значений, то, подобно классу TIniFile, для TRegistry определен ряд методов для взаимодействия с данными различных типов, причем для реестра к типам Boolean, String, Double, Integer и даты-времени, добавляется еще и Currency. Соответственно, мы имеем 8 пар методов для этих целей.

Для примера рассмотрим приложение, состоящее из единственного окна, которое будет «запоминать» свои размеры и расположение на экране. Для этого создадим новое VCL-приложение (File ‘ New ‘ Application), щелкнем сначала по его форме (Form1), а затем — по окну инспектора объекта (Object Inspector). В нем выберем закладку Events (события), найдем событие OnClose и дважды щелкнем по строке напротив. В результате мы получим заготовку для процедуры TForm1.FormClose, в которую нам надо будет добавить объявление переменной для реестра:

var Reg: TRegistry; Затем в теле функции напишем следующие строки: Reg:=TRegistry.Create; Reg.RootKey:=HKEY_CURRENT_USER; Reg.OpenKey(‘\SOFTWARE\MySoft\TestApp’,true); Reg.WriteInteger(‘left’,Form1.Left); Reg.WriteInteger(‘top’,Form1.Top); Reg.WriteInteger(‘height’,Form1.Height); Reg.WriteInteger(‘width’,Form1.Width); Reg.Free;

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

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

if Reg.OpenKeyReadOnly(‘\SOFTWARE\MySoft\TestApp’) then begin . end;

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

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

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

Листинг 10.5. Сохранение координат и размеров окна в реестре

unit Unit1; interface uses Windows, Forms, Registry; type TForm1 = ,Form1.Width); Reg.Free; end; end.

С исходным кодом приложения так же можно ознакомится, посмотрев его в каталоге Demo\Part2\Registry.

Процедуры и функции стандартных диалогов

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

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

ShowMessage(‘Формат диска C: завершен’);

Кроме самой процедуры ShowMessage, имеются 2 других варианта — ShowMessagePos и ShowMessageFmt. Первый позволяет вывести диалоговое окно в определенном месте, что достигается путем указания координат по горизонтали и вертикали:

ShowMessagePos(‘Формат диска C: завершен’,100,200);

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

ShowMessageFmt(‘Формат диска %s завершен’,[‘C:’]);

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

function MessageDlg(const Msg: string; DlgType: TMsgDlgType; Buttons: TMsgDlgButtons; HelpCtx: Longint): Word;

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

  • mtWarning — диалог типа «предупреждение», имеет заголовок «Warning» и рисунок, изображающий восклицательный знак на фоне желтого треугольника;
  • mtError — диалог типа «ошибка», имеет заголовок «Error» и изображение косого креста в красном круге;
  • mtInformation — диалог типа «информация», имеет заголовок «Information» и значок со стилизованной буквой «i» в синих тонах;
  • mtConfirmation — диалог типа «подтверждение», имеет заголовок «Confirm» и рисунок с зеленым вопросительным знаком;
  • mtCustom — диалог произвольного типа, имеет заголовок, соответствующий имени выполняемого файла и не содержит изображения.

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

Следующий параметр, имеющий перечисляемый тип TMsgDlgButtons, позволяет указать, какие кнопки должны быть расположены на диалоговом окне. Всего предусмотрено 11 вариантов кнопок, среди них предусмотрены такие, как OK, Cancel, Yes, No и т.д. При этом каждая такая кнопка (кроме Help), будучи нажатой пользователем, закрывает окно, а функция возвращает значение, соответствующее нажатой кнопке. Все варианты кнопок и возвращаемые ими значения, приведены в таблице 10.3.

Таблица 10.3. Варианты кнопок и значения, возвращаемые при их нажатии

Значение Описание Возвращаемый результат
mbYes Кнопка с надписью «Yes» (да) mrYes
mbNo Кнопка с надписью «No» (нет) mrNo
mbOK Кнопка с надписью «OK» mrOk
mbCancel Кнопка с надписью «Cancel» (отмена) mrCancel
mbAbort Кнопка с надписью «Abort» (прервать) mrAbort
mbRetry Кнопка с надписью «Retry» (повторить) mrRetry
mbIgnore Кнопка с надписью «Ignore» (игнорировать) meIgnore
mbAll Кнопка с надписью «All» (все) mrAll
mbNoToAll Кнопка с надписью «No to All» (нет для всех) mrNoToAll
mbYesToAll Кнопка с надписью «Yes to All» (да для всех) mrYesToAll
mbHelp Кнопка с надписью «Help» (справка)

Следует оговориться, что все возвращаемые значения, на самом деле, являются целыми числами, что видно по определению функции. Но поскольку запомнить, что, к примеру, возвращаемое значение для OK — это 1, а для Yes — 6, весьма проблематично, то на практике вместо них используются константы, которые как раз и были приведены в таблице 10.3.

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

MessageDlg(‘Ошибка чтения с диска. Продолжить?’, mtError, [mbRetry, mbAbort], 0);

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

if MessageDlg(‘Форматировать диск C:?’,mtConfirmation,[mbYes,mbNo],0) = mrYes then FormatDriveCProc();

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

case MessageDlg(‘Файл изменен. Сохранить перед выходом?’, mtWarning, [mbYes, mbNo, mbCancel], 0) of mrYes: begin SaveFileProc(); Close; end; mrNo: Close; mrCancel: exit; end;

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

MessageDlgPos(‘Заменить это вхождение?’, mtConfirmation, [mbYes, mbNo], 0, X, Y);

Все рассмотренные нами подпрограммы применяются для вывода сообщений. Что касается ввода, то для этих целей, как уже отмечалось, используют функции InputBox и InputQuery. Обе они выводят окно, позволяющее пользователю ввести какое-либо значение — число или строку. Различие между ними состоит лишь в том, что InputBox возвращает непосредственно результат (в виде строки), а InputQuery — истину или ложь, в зависимости от того, нажмет пользователь OK или Cancel. При этом само значение возвращается в качестве одного из параметров. В итоге мы имеем следующий синтаксис для этих функций:

function InputBox(const ACaption, APrompt, ADefault: string): string; function InputQuery(const ACaption, APrompt: string; var Value: string): Boolean;

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

UserName := InputBox(‘Запрос’,’Введите ваше имя’,’анонимно’);

В данном случае последний параметр функции будет использован в качестве значения по умолчанию (рис. 10.3).

Рис. 10.3. Диалоговое окно функции InputBox

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

if InputQurey(‘Курс доллара ‘,’Введите новый курс’,NewCur) then UpdatePrc();

Помимо приведенных здесь процедур и функций, в VCL имеется ряд иных подпрограмм, использующих диалоговые окна, включая такие, как диалог выбора каталога или файла. Но поскольку их использование сопряжено с некоторыми неудобствами, в частности, им приходится передавать большое число параметров, то на практике для тех же целей чаще используют компоненты. Например, функция PromptForFileName используется для вывода диалога сохранения или открытия файла. Но более типичным (и удобным!) вариантом обращения к таким диалогам является использование таких стандартных компонент VCL, как TOpenDialog и TSaveDialog, с которыми мы познакомимся в следующей части этой книги.

Обработка сообщений и Windows API

Как ни широк охват VCL, иногда все-таки возникает потребность в обращении к функциям Windows напрямую. Например, для того же самого вывода окна с текстовым сообщением можно использовать собственную функцию Windows API — MessageBox:

MessageBox(0, ‘Текст сообщения’, ‘Заголовок’, MB_OK);

Необходимость использования функций Windows API может быть вызвана, например, соображениями компактности исполняемого файла: использование диалогов Delphi автоматически подразумевает использование целого рада модулей, необходимых для оконного интерфейса. Если же в самой программе такие модули (например, forms) не задействуются, то их включение в исполняемый код только ради диалога не является хорошей идеей.

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

ПРИМЕЧАНИЕ
Еще одной темой, важной для дальнейшего изучения программирования в Windows вообще и в среде Delphi в частности, является концепция событийного программирования. Дело в том, что хотя ОС Windows, в отличие от Delphi, и не является объектной средой, подход к организации взаимодействия приложений (как с пользователем, так и с системой), основан на одном и том же, а именно — на событиях.

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

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

Хотя детальное ознакомления с работой Windows API явно не вписывается в рамки данной книги (не забываем, что Delphi была создана как раз для того, чтобы скрыть сложную и неуклюжую API Windows), отметим все-таки некоторые связанные с ней аспекты. Прежде всего, это касается типов данных. Хотя ранние версии Windows были написаны на Pascal, со временем Microsoft перешла на использование C и C++, поэтому типы данных в представлении Windows несколько отличаются от таковых в Delphi. Прежде всего, это касается строк: при работе с Windows напрямую следует использовать не обычные, а C-строки. В Object Pascal для этого предусмотрен специальный тип данных — PChar, а так же функции для преобразования строк одного вида в другой. Так, для преобразования Pascal-строк в C-строки используют функцию StrPCopy, а для обратного преобразования — функцию StrPas.

var a: PChar; s: string; . s:=’Строка’; new(a); // для С-строк следует предварительно выделять память StrPCopy(a,s); // содержимое Pascal-строки s скопировано в C-строку a s:=StrPas(a);

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

СОВЕТ
В поставку Delphi включена документация по Windows API. Ссылки на файлы вы найдете в разделе MS SDK Help Files, вложенном в раздел Help программной группы Delphi в меню кнопки пуск. Наибольший интерес с точки зрения изучения функций API представляет собой файл Win32 Programmer’s reference.

Что касается VCL, то в Delphi все же имеется специальный компонент, который может отлавливать все сообщения, адресуемые приложению. Для этого существует компонент AppEvents, который принимает все сообщения, адресованные объекту Application. Среди событий, отслеживаемых компонентом AppEvents, выделим OnMessage — именно это событие происходит, когда приложение получает сообщение от Windows или иной программы. Кроме того, ряд компонент, на самом деле, являются оболочкой для вызова тех или иных функций Windows. Впрочем, о компонентах Delphi будет рассказано в следующей части этой книги.

Функции delphi

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

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

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

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

Давайте разберем как определить функцию.

Итак, в начале идет ключевое слово function, затем имя функции. Далее в круглых скобках список параметров. Также необходимо указать тип возвращаемого результата. При необходимости можно определить локальные переменные. Между операторных скобок (begin..end;) необходимо записать требуемые инструкции.

В каждой функции Delphi автоматически создает переменную с именем result, переменная имеет тот же тип, что и возвращаемое значение функции. С помощью этой переменной мы и будем возвращать значения. (Есть еще одна возможность вернуть значение, её я продемонстрирую на примере).

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

Разберем применение функций Делфи на простом примере.

Создайте новое приложение и на форме разместите три кнопки (Button).

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

Сама же функция будет иметь следующий вид:

Название – square, параметр всего один – x типа Double, результат тоже будет Double.

Делфи позволяет возвращать значения через переменную, название которой совпадает с названием функции Delphi. В нашем случае это выглядит так: square:=x*x;(закомментированный код).

Теперь посмотрим как можно использовать написанный код. Напишем обработчик события Onclickдля каждой из кнопок.

  • Для первой кнопки — ShowMessage(FloatToStr(square(1)));
  • Для второй — ShowMessage(FloatToStr(square(2)));
  • Для третей — ShowMessage(FloatToStr(square(3)));

У меня получился следующий Unit

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

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

Компоненты Delphi для работы с файлами

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

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

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

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

Компонент Страница Описание
OpenDialog «Открыть файл» Dialogs Предназначен для создания окна диалога «Открыть файл».
SaveDialog «Сохранить файл» Dialogs Предназначен для создания окна диалога «Сохранить файл как».
OpenPictureDialog «Открыть рисунок» Dialogs Предназначен для создания окна диалога «Открыть рисунок», открывающего графический файл. Начиная с Delphi 3.
SavePictureDialog «Сохранить рисунок» Dialogs Предназначен для создания окна диалога «Сохранить рисунок» — сохранение изображения в графическом файле. Начиная с Delphi 3.
FontDialog «Шрифты» Dialogs Предназначен для создания окна диалога «Шрифты» — выбор атрибутов шрифта.
ColorDialog «Цвет» Dialogs Предназначен для создания окна диалога «Цвет» — выбор цвета.
PrintDialog «Печать» Dialogs Предназначен для создания окна диалога «Печать».
PrinterSetupDialog «Установка принтера» Dialogs Предназначен для создания окна диалога «Установка принтера».
FindDialog «Найти» Dialogs Предназначен для создания окна диалога «Найти» — контекстный поиск в тексте.
ReplaceDialog «Заменить» Dialogs Предназначен для создания окна диалога «Заменить» — контекстная замена фрагментов текста.
FileListBox (список файлов) Win3.1 Отображает список всех файлов каталога.
DirectoryListBox (структура каталогов) Win3.1 Отображает структуру каталогов диска.
DriveComboBox (список дисков) Win3.1 Выпадающий список доступных дисков.
FilterComboBox (список фильтров) Win3.1 Выпадающий список фильтров для поиска файлов.
DirectoryOutline (дерево каталогов) Samples Пример компонента, используемого для отображения структуры каталогов выбранного диска.

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

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

Основной метод, которым производится обращение к любому диалогу, — Execute. Эта функция открывает диалоговое окно и, если пользователь произвел в нем какой-то выбор, то функция возвращает true. При этом в свойствах компонента-диалога запоминается выбор пользователя, который можно прочитать и использовать в дальнейших операциях. Если же пользователь в диалоге нажал кнопку Отмена или клавишу Esc, то функция Execute возвращает false. Поэтому стандартное обращение к диалогу имеет вид:

if .Execute then ;

Компоненты OpenDialog — диалог «Открыть файл» и SaveDialog — диалог «Сохранить файл как. », пожалуй, используются чаще всего, в большинстве приложений.

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

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

После выхода из окна редактирования фильтров заданные вами шаблоны появятся в свойстве Filter в виде строки вида:

текстовые (*.txt, *.doc)|*.txt; *.doc|все файлы|*.*

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

Свойство FilterIndex определяет номер фильтра, который будет по умолчанию показан пользователю в момент открытия диалога. Например, значение FilterIndex = 1 задает по умолчанию первый фильтр.

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

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

Свойство Title позволяет вам задать заголовок диалогового окна. Если это свойство не задано, окно открывается с заголовком, определенным в системе. Но вы можете задать и свой заголовок, подсказывающий пользователю ожидаемые действия. Например, «Укажите имя открываемого файла».

Свойство Options определяет условия выбора файла. Множество опций, которые вы можете установить программно или во время проектирования, включает:

ofAllowMultiSelect Позволяет пользователю выбирать несколько файлов
ofCreatePrompt В случае, если пользователь написал имя несуществующего файла, появляется замечание и запрос, надо ли создать файл с заданным именем
ofEnableIncludeNotify Разрешает посылать в диалог сообщения
ofEnableSizing Разрешает пользователю изменять размер диалогового окна
ofExtensionDifferent Этот флаг, который можно прочитать после выполнения диалога, показывает, что расширение файла, выбранного пользователем, отличается от DefaultExt
ofFileMustExist В случае, если пользователь написал имя несуществующего файла, появляется сообщение об ошибке
ofHideReadOnly Удаляет из диалога индикатор Открыть только для чтения
ofNoChangeDir После щелчка пользователя на кнопке OK восстанавливает текущий каталог, независимо от того, какой каталог был открыт при поиске файла
ofNoDereferenceLinks Запрещает переназначать клавиши быстрого доступа в диалоговом окне
ofNoLongNames Отображаются только не более 8 символов имени и трех символов расширения
ofNoNetworkButton Убирает из диалогового окна кнопку поиска в сети. Действует только если флаг ofOldStyleDialog включен
ofNoReadOnlyReturn Если пользователь выбрал файл только для чтения, то генерируется сообщение об ошибке
ofNoTestFileCreate Запрещает выбор в сети защищенных файлов и не доступных дисков при сохранении файла
ofNoValidate Не позволяет писать в именах файлов неразрешенные символы, но не мешает выбирать файлы с неразрешенными символами
ofOldStyleDialog Создает диалог выбора файла в старом стиле (см. рис. 8.4)
ofOverwritePrompt В случае, если при сохранении файла пользователь написал имя существующего файла, появляется замечание, что файл с таким именем существует, и запрашивается желание пользователя переписать существующий файл
ofPathMustExist Генерирует сообщение об ошибке, если пользователь указал в имени файла несуществующий каталог
ofReadOnly По умолчанию устанавливает индикатор Открыть только для чтения при открытии диалога
ofShareAware Игнорирует ошибки нарушения условий коллективного доступа и разрешает, несмотря на них, производить выбор файла
ofShowHelp Отображает в диалоговом окне кнопку Справка

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

Если вы разрешаете с помощью опции ofAllowMultiSelect множественный выбор файлов, то список выбранных файлов можно прочитать в свойстве Files типа TStrings.

В приведенной таблице даны опции, используемые в 32-разрядных версиях Delphi. В Delphi 1 диалоговое окно имеет вид, представленный на рис. 8.4. Аналогичный вид имеет диалог и в 32-разрядных версиях Delphi при включении опции ofOldStyleDialog.

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

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

Теперь приведем примеры использования диалогов OpenDialog и SaveDialog. Пусть ваше приложение включает окно редактирования Memo1, в которое по команде меню Открыть вы хотите загружать текстовый файл, а после каких-то изменений, сделанных пользователем, — сохранять по команде Сохранить текст в том же файле, а по команде Сохранить как. — в файле с другим именем.

Введите на форму компоненты — диалоги OpenDialog и SaveDialog. Предположим, что вы оставили их имена по умолчанию — OpenDialog1 и SaveDialog1. Поскольку после чтения файла вам надо запомнить его имя, чтобы знать под каким именем потом его сохранять, вы можете определить для этого имени переменную, назвав ее, например, FName:

var FName: string;

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

if OpenDialog1.Execute then begin FName := OpenDialog1.FileName; Memo1.Lines.LoadFromFile(FName); end;

Этот оператор вызывает диалог, проверяет, выбрал ли пользователь файл (если выбрал, то функция Execute возвращает true), после чего имя выбранного файла (OpenDialog1.FileName) сохраняется в переменной FName и файл загружается в текст Memo1 методом LoadFromFile.

Обработка команды Сохранить выполняется оператором

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

Обработка команды Сохранить как. выполняется операторами:

SaveDialog1.FileName := FName;if SaveDialog1.Execute then begin FName := SaveDialog1.FileName; Memo1.Lines.SaveToFile(FName); end;

Первый из этих операторов присваивает свойству FileName компонента SaveDialog1 запомненное имя файла. Это имя по умолчанию будет предложено пользователю при открытии диалога Сохранить как. Следующий оператор открывает диалог и, если пользователь выбрал в нем файл, запоминает новое имя файла и сохраняет в файле с этим именем текст компонента Memo1.

Мы рассмотрели диалоги открытия и сохранения файлов произвольного типа. Начиная с Delphi 3 в библиотеке имеются специализированные диалоги открытия и закрытия графических файлов: OpenPictureDialog и SavePictureDialog. Диалоговые окна, открываемые этими файлами. От окон, открываемых компонентами OpenDialog и SaveDialog, они отличаются удобной возможностью просматривать изображения в процессе выбора файла.

Свойства компонентов OpenPictureDialog и SavePictureDialog ничем не отличаются от свойств компонентов OpenDialog и SaveDialog. Единственное отличие — заданное значение по умолчанию свойства Filter в OpenPictureDialog и SavePictureDialog. В этих компонентах заданы следующие фильтры:

All (*.jpg; *.jpeg; *.bmp; *.ico; *.emf; *.wmf) *.jpg; *.jpeg; *.bmp; *.ico; *.emf; *.wmf
JPEG Image File (*.jpg) *.jpg
JPEG Image File (*.jpeg) *.jpeg
Bitmaps (*.bmp) *.bmp
Icons (*.ico) *.ico
Enhanced Metafiles (*.emf) *.emf
Metafiles (*.wmf) *.wmf

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

Компонент FontDialog вызывает диалоговое окно выбора атрибутов шрифта. В нем пользователь может выбрать имя шрифта, его стиль (начертание), размер и другие атрибуты.

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

Свойства MaxFontSize и MinFontSize устанавливают ограничения на максимальный и минимальный размеры шрифта. Если значения этих свойств равны 0 (по умолчанию), то никакие ограничения на размер не накладываются. Если же значения свойств заданы (обычно это целесообразно делать исходя из размеров компонента приложения, для которого выбирается шрифт), то в списке Размер диалогового окна появляются только размеры, укладывающиеся в заданный диапазон. При попытке пользователя задать недопустимый размер ему будет выдано предупреждение вида «Размер должен лежать в интервале . » и выбор пользователя отменится. Свойства MaxFontSize и MinFontSize действуют только при включенной опции fdLimitSize (см. ниже).

Свойство Device определяет, из какого списка возможных шрифтов будет предложен выбор в диалоговом окне: fdScreen — из списка экрана (по умолчанию), fdPrinter — из списка принтера, fdBoth — из обоих.

Свойство Options содержит множество опций:

fdAnsiOnly Отображать только множество шрифтов символов Windows, не отображать шрифтов со специальными символами
fdApplyButton Отображать в диалоге кнопку Применить независимо от того, предусмотрен ли обработчик события OnApply
fdEffects Отображать в диалоге индикаторы специальных эффектов (подчеркивание и др.) и список Цвет
fdFixedPitchOnly Отображать только шрифты с постоянной шириной символов
fdForceFontExist Позволять пользователю выбирать шрифты только из списка, запрещать ему вводить другие имена
fdLimitSize Разрешить использовать свойства MaxFontSize и MinFontSize, ограничивающие размеры шрифта
fdNoFaceSel Открывать диалоговое окно без предварительно установленного имени шрифта
fdNoOEMFonts Удалять из списка шрифтов шрифты OEM
fdScalableOnly Отображать только масштабируемые шрифты, удалять из списка не масштабируемые (шрифты bitmap)
fdNoSimulations Отображать только шрифты и их начертания, напрямую поддерживаемые файлами, не отображая шрифты, в которых жирный стиль и курсив синтезируется
fdNoSizeSel Открывать диалоговое окно без предварительно установленного размера шрифта
fdNoStyleSel Открывать диалоговое окно без предварительно установленного начертания шрифта
fdNoVectorFonts Удалять из списка векторные шрифты (типа Roman или Script для Windows 1.0)
fdShowHelp Отображать в диалоговом окне кнопку Справка
fdTrueTypeOnly Предлагать в списке только шрифты TrueType
fdWysiwyg Предлагать в списке только шрифты, доступные и для экрана, и для принтера, удаляя из него аппаратно зависимые шрифты

По умолчанию все эти опции, кроме fdEffects, отключены.

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

Приведем примеры применения компонента FontDialog. Пусть ваше приложение включает окно редактирования Memo1, шрифт в котором пользователь может выбирать командой меню Шрифт. Вы ввели в приложение компонент FontDialog, имя которого по умолчанию FontDialog1. Тогда обработчик команды Шрифт может иметь вид:

if FontDialog1.Execute then Memo1.Font.Assign(FontDialog1.Font);

Приведенный оператор вызывает диалог выбора атрибутов шрифта и, если пользователь произвел выбор, то значения всех выбранных атрибутов, содержащиеся в свойстве FontDialog1.Font, присваиваются атрибутам окна редактирования, содержащимся в свойстве Memo1.Font. Шрифт в окне редактирования немедленно изменится.

Если вы установите в компоненте FontDialog1 опцию fdApplyButton, то можете написать обработчик события OnApply:

Тогда пользователь может наблюдать изменения в окне Memo1, нажимая в диалоговом окне кнопку Применить и не прерывая диалога. Это очень удобно, так как позволяет пользователю правильно подобрать атрибуты шрифта.

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

if FontDialog1.Execute then RichEdit1.SelAttributes.Assign(FontDialog1.Font);

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

if FontDialog1.Execute then Font.Assign(FontDialog1.Font);

В этом операторе свойство Font без ссылки на компонент подразумевает шрифт формы.

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

Основное свойство компонента ColorDialog — Color. Это свойство соответствует тому цвету, который выбрал в диалоге пользователь. Если при вызове диалога желательно установить некоторое начальное приближение цвета, это можно сделать, установив Color предварительно во время проектирования или программно. Свойство CustomColors типа TStrings позволяет задать заказные цвета дополнительной палитры. Каждый цвет определяется строкой вида

Имена цветов задаются от ColorA (первый цвет) до ColorP (шестнадцатый, последний). Например, строка

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

Свойство Options содержит множество следующих опций:

cdFullOpen Отображать сразу при открытии диалогового окна панель определения заказных цветов
cdPreventFullOpen Запретить появление в диалоговом окне кнопки Определить цвет, так что пользователь не сможет определять новые цвета
cdShowHelp Добавить в диалоговое окно кнопку Справка
cdSolidColor Указать Windows использовать сплошной цвет, ближайший к выбранному (это обедняет палитру)
cdAnyColor Разрешать пользователю выбирать любые не сплошные цвета (такие цвета могут быть не ровными)

По умолчанию все опции выключены.

Приведем пример применения компонента ColorDialog. Если вы хотите, чтобы пользователь мог задать цвет какого-то объекта, например, цвет фона компонента Memo1, то это можно реализовать оператором

if ColorDialog1.Execute then Memo1.Color := ColorDialog1.Color;

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

Компонент PrintDialog не осуществляет печать. Он только позволяет пользователю задать атрибуты печати. А сама печать должна осуществляться программно с помощью объекта Printer или иным путем.

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

PrintRange Показывает выбранную пользователем радиокнопку из группы Печатать: prAllPages — выбрана кнопка Все страницы, prSelection — выбрана кнопка Страницы с . по . prPageNums — выбрана кнопка Страницы
FromPage Показывает установленную пользователем начальную страницу в окне Страницы с . по .
ToPage Показывает установленную пользователем конечную страницу в окне Страницы с . по .
PrintToFile Показывает, выбран ли пользователем индикатор Печать в файл
Copies Показывает установленное пользователем число копий
Collate Показывает, выбран ли пользователем индикатор Разобрать

Перед вызовом диалога желательно определить, сколько страниц в печатаемом тексте, и задать параметры MaxPage и MinPage — максимальный и минимальный номера страниц. В противном случае пользователю в диалоговом окне не будет доступна кнопка Страницы с . по . Кроме того следует определить множество опций в свойстве Options:

poDisablePrintToFile Запретить доступ к индикатору Печать в файл. Эта опция работает только при включенной опции poPrintToFile
poHelp Отображать в диалоговом окне кнопку Справка. Опция может не работать для некоторых версий Windows 95/98
poPageNums Сделать доступной радиокнопку Страницы, позволяющую пользователю задавать диапазон печатаемых страниц
poPrintToFile Отображать в диалоговом окне кнопку Печать в файл
poSelection Сделать доступной кнопку Выделение, позволяющую пользователю печатать только выделенный текст
poWarning Выдавать замечания, если пользователь пытается послать задачу на неустановленный принтер

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

Компоненты FindDialog и ReplaceDialog, вызывающие диалоги поиска и замены фрагментов текста, очень похожи и имеют одинаковые свойства, кроме одного, задающего заменяющий текст в компоненте ReplaceDialog. Такое сходство не удивительно, поскольку ReplaceDialog — производный класс от FindDialog.

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

FindText Текст, заданный пользователем для поиска или замены. Программно может быть установлен как начальное значение, предлагаемое пользователю
ReplaceText Только в компоненте ReplaceDialog — текст, который должен заменять FindText
Position Позиция левого верхнего угла диалогового окна, заданная типом TPoint — записью, содержащей поля X (экранная координата по горизонтали) и Y (экранная координата по вертикали)
Left Координата левого края диалогового окна, то же, что Position.X
Top Координата верхнего края диалогового окна, то же, что Position.Y
Options Множество опций

Последний параметр Options — может содержать следующие свойства:

frDisableMatchCase Делает недоступным индикатор С учетом регистра в диалоговом окне
frDisableUpDown Делает недоступными в диалоговом окне кнопки Вверх и Вниз группы Направление, определяющие направление поиска
frDisableWholeWord Делает недоступным индикатор Только слово целиком в диалоговом окне
frDown Выбирает кнопку Вниз группы Направление при открытии диалогового окна. Если эта опция не установлена, то выбирается кнопка Вверх
frFindNext Эта опция включается автоматически, когда пользователь в диалоговом окне щелкает на кнопке Найти далее, и выключается при закрытии диалога
frHideMatchCase Удаляет индикатор С учетом регистра из диалогового окна
frHideWholeWord Удаляет индикатор Только слово целиком из диалогового окна
frHideUpDown Удаляет кнопки Вверх и Вниз из диалогового окна
frMatchCase Этот флаг включается и выключается, если пользователь включает и выключает опцию С учетом регистра в диалоговом окне. Можно установить эту опцию по умолчанию во время проектирования, чтобы при открытии диалога она была включена
frReplace Применяется только для ReplaceDialog. Этот флаг устанавливается системой, чтобы показать, что текущее (и только текущее) найденное значение FindText должно быть заменено значением ReplaceText
frReplaceAll Применяется только для ReplaceDialog. Этот флаг устанавливается системой, чтобы показать, что все найденные значения FindText должны быть заменены значениями ReplaceText
frShowHelp Задает отображение кнопки Справка в диалоговом окне
frWholeWord Этот флаг включается и выключается, если пользователь включает и выключает опцию Только слово целиком в диалоговом окне. Можно установить эту опцию по умолчанию во время проектирования, чтобы при открытии диалога она была включена

Сами по себе компоненты FindDialog и ReplaceDialog не осуществляют ни поиска, ни замены. Они только обеспечивают интерфейс с пользователем. А поиск и замену надо осуществлять программно. Для этого можно пользоваться событием OnFind, происходящим, когда пользователь нажал в диалоге кнопку Найти далее, и событием OnReplace, возникающим, если пользователь нажал кнопку Заменить или Заменить все. В событии OnReplace узнать, какую именно кнопку нажал пользователь, можно но значениям флагов frReplace и frReplaceAll.

Поиск заданного фрагмента легко проводить, пользуясь функцией Object Pascal Pos, которая определена в модуле System следующим образом:

function Pos(Substr: string; S: string): Byte;

где S — строка, в которой ищется фрагмент текста, a Substr — искомый фрагмент. Функция возвращает позицию первого символа первого вхождения искомого фрагмента в строку. Если Substr в S не найден, возвращается 0.

Для организации поиска нам потребуется еще две функции: Сору и AnsiLowerCase. Первая из них определена как:

function Copy(S: string; Index, Count: Integer): string;

Она возвращает фрагмент строки S, начинающийся с позиции Index и содержащий число символов, не превышающее Count. Функция AnsiLowerCase, определенная как

function AnsiLowerCase(const S: string): string;

возвращает строку символов S, переведенную в нижний регистр.

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

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

var SPos: integer;procedure TForm1.MFindClick(Sender: TObject);begin SPos := Memo1.SelStart; with FindDialog1 do begin <начальное значение текста поиска — текст, выделенный в Memo1> FindText := Memo1.SelText; Position := Point(Form1.Left, Form1.Top + Memo1.Top + Memo1.Height); <удаление из диалога кнопок «Вверх», «Вниз»,«Только слово целиком»> Options := Options + [frH >= Spos then begin Memo1.SelLength := Length(FindText); SPos := Memo1.SelStart + Memo1.SelLength + 1; end else if MessageDlg( ‘Текст «‘+FindText+'» не найден. Продолжать диалог?’, mtConfirmation, mbYesNoCancel, 0) <> mrYes then CloseDialog; end; Memo1.SetFocus;end;

В программе вводится переменная SPos, сохраняющая позицию, начиная с которой надо проводить поиск.

Процедура MFindClick вызывает диалог, процедура FindDialog1Find обеспечивает поиск с учетом или без учета регистра в зависимости от флага frMatchCase. После нахождения очередного вхождения искомого текста этот текст выделяется в окне Memo1 и управление передается этому окну редактирования. Затем при нажатии пользователем в диалоговом окне кнопки Найти далее, поиск продолжается в оставшейся части текста. Если искомый текст не найден, делается запрос пользователю о продолжении диалога. Если пользователь не ответил на этот запрос положительно, то диалог закрывается методом CloseDialog.

В дополнение к приведенному тексту полезно в обработчики событий OnClick и OnKeyUp компонента Memo1 ввести операторы

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

При реализации команды Заменить приведенные выше процедуры можно оставить теми же самыми, заменив в них FindDialog1 на ReplaceDialog1. Дополнительно можно написать процедуру обработки события OnReplace компонента ReplaceDialog1:

procedure TForm1.ReplaceDialog1Replace(Sender: TObject);begin if Memo1.SelText <> » then Memo1.SelText := ReplaceDialog1.ReplaceText; if frReplaceAll in ReplaceDialog1.Options then ReplaceDialog1Find(Self);end;

Этот код производит замену выделенного текста и, если пользователь нажал кнопку Заменить все, то продолжается поиск вызовом уже имеющейся процедуры поиска ReplaceDialog1Find * . Если же пользователь нажал кнопку Заменить, то производится только одна замена и для продолжения поиска пользователь должен нажать кнопку Найти далее.

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

| следующая лекция ==>
Пожарная профилактика при проектировании и строительстве зданий | Процесс планирования состоит из

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

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

Использование процедур и функций в Delphi

Скобки

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

Возможность перегрузки

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

procedure Test (I: integer); overload;
procedure Test (S: string); overload;
procedure Test (D: double); overload;

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

Передача параметров

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

Передача параметров по значению

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

procedure Test(s: string);

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

Однако это не относится к объектам. Например, если в функцию передается переменная (а точнее экземпляр объекта) TStringList, то в данном случае произойдет передача по ссылке (даже если это не указано явно). Этот способ передачи является у большинства самым излюбленным, но в тоже время является и самым не практичным, т.к. для выполнения метода выделяется дополнительная память для создания точной копией передаваемой переменой. Для решения этой проблемы следует использовать один из способов описанных ниже.

Передача параметров по ссылке

Pascal позволяет также передавать параметры в функции или процедуры по ссылке — такие параметры называются параметрами-переменными. Передача параметра по ссылке означает, что функция или процедура сможет изменить полученные значения параметров. Для передачи параметров по ссылке используется ключевое слово var, помещаемое в список параметров вызываемой процедуры или функции.

procedure ChangeMe(var x: longint);
begin
x := 2; // Параметр х изменен вызванной процедурой
end;

Вместо создания копии переменной x, ключевое слово var требует передачи адреса самой переменной x, что позволяет процедуре непосредственно изменять ее значение.

Передача параметров констант

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

procedure Test(const s: string );

Передача открытых массивов

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

function AddEmUp(A: array of integer): integer;

В открытом массиве можно передавать переменные, константы или выражения из констант.

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

Object Pascal также поддерживает тип array of const, который позволяет передавать в одном массиве данные различных типов. Синтаксис объявления функций или процедур, использующих такой массив для получения параметров, следующий:

procedure WhatHaveIGot( A: array of const );

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

procedure WhatHaveIGot( [‘Text’, 10, 5.5, @WhatHaveIGot, 3.14, true, ‘c’] );

При передаче функции или процедуре массива констант все передаваемые параметры компилятор неявно конвертирует в тип TVarRec. Тип данных TVarRec объявлен в модуле System следующим образом:

PVarRec = ^TVarRec;
TVarRec = record
case Byte of
vtInteger: (VInteger: Integer; VType: Byte);
vtBoolean: (VBoolean: Boolean);
vtChar: (VChar: Char);
vtExtended: (VExtended: PExtended);
vtString: (VString: PShortString);
vtPointer: (VPointer: Pointer);
vtPChar: (VPChar: PChar);
vtObject: (VObject: TObject);
vtClass: (VClass: TClass);
vtWideChar: (VWideChar: WideChar);
vtPWideChar: (VPWideChar: PWideChar);
vtAnsiString: (VAnsiString: Pointer);
vtCurrency: (VCurrency: PCurrency);
vtVariant: (VVariant: PVariant);
vtInterface: (VInterface: Pointer);
vtWideString: (VWideString: Pointer);
vtInt64: (VInt64: PInt64);
end;

Поле VType определяет тип содержащихся в данном экземпляре записи TVarRec данных и может принимать одно приведенных значений.

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

procedure WhatHaveIGot( A: array of const );
var
i: integer;
TypeStr: string;
begin
for i := Low(A) to High(A) do
begin
case A[i].VType of
vtInteger : TypeStr := ‘Integer’;
vtBoolean : TypeStr := ‘Boolean’;
vtChar : TypeStr := ‘Char’;
vtExtended : TypeStr := ‘Extended’;
vtString : TypeStr := ‘String’;
vtPointer : TypeStr := ‘Pointer’;
vtPChar : TypeStr := ‘PChar’;
vtObject : TypeStr := ‘Object’;
vt ;
vtW ;
vtPW ;
vtAnsiString : TypeStr := ‘AnsiString’;
vtCurrency : TypeStr := ‘Currency’;
vtVariant : TypeStr := ‘Variant’;
vtInterface : TypeStr := ‘Interface’;
vtW ;
vtInt64 : TypeStr := ‘Int64’;
end;
ShowMessage( Format( ‘Array item %d is a %s’, [i, TypeStr] ) );
end;
end;

Значения параметров по умолчанию

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

procedure HasDefVal( s: string; i: integer = 0 );

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

procedure HasDefVal( ‘Hello’, 26 );

Во втором случае можно задать только значение параметра s, а для параметра i использовать значение, установленное по умолчанию:

procedure HasDefVal( ‘Hello’ );

При использовании значении параметров по умолчанию следует помнить о нескольких приведенных ниже правилах:

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

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

function Add( I1, I2: integer ): integer;
begin
Result := I1 + I2;
end;

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

function Add( I1, I2: integer; I3: integer = 0 ): integer;
begin
Result := I1 + I2 + I3;
end;

Директива

Директива <$X->запрещает вызов функций как процедур (с игнорированием возвращаемого результата). По умолчанию этот режим включен (<$X+>). Так вот, запомните, использование переменной Result недопустимо при сброшенном флажке опции Extended Syntax, расположенном во вкладке Compiler диалогового окна Project Options, или при указании директивы компилятора <$X->.

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

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

Применение перечисляемых типов Delphi.

Конечно этот пост не вызовет особого интереса у «акул шоубиза Delphi-кодинга», но блог ведь читают и те кто только пробуют разобраться в Delphi и создать что-то свое. Поэтому, думаю, что для таких людей пост «Применение перечисляемых типов Delphi» поможет сделать их приложения более…профессиональными что-ли :).
Не так давно, вдохновленный переводами Александра Божко статей о новом RTTI Delphi 2010 я решил засунуть свою лень поглубже..в портмоне и начать наконец-то разбираться с тем, что такое RTTI, как использовать и т.д. Вообще тема RTTI достаточно обширна и интересна, но сегодня речь пойдет о применении возможностей RunTime Type Information при работе с перечисляемым типом данных. А чтобы не останавливаться на голой теории, рассмотрим применим наши новые знания на практическом примере.

Итак, что такое RTTI.
Runtime Type Information или сокрашенно RTTI (информация о типах времени исполнения) —это данные, генерируемые компилятором Delphi об объектах программы. RTTI представляет собой возможность языка, обеспечивающее приложение информацией об объектах (имя, размер экземпляра, указатели на класс-предок, имя класса и т. д.) и о простых типах во время работы программы. Delphi, например, использует RTTI для доступа к значениям свойств компонент, сохраняемых и считываемых из dfm-файлов и отображения их в Object Inspector.
Основополагающие определения типов, основные функции и процедуры для работы с runtime информацией находятся в модуле TypInfo. Этот модуль содержит две фундаментальные структуры для работы с RTTI — TTypeInfo и TTypeData (типы указателей на них — PTypeInfo и PTypeData соответственно). Попробуем использовать их на конкретном примере.
Допустим, нам необходимо сформировать строку-запрос к тому же Google, чтобы получить доступ к API. Что мы можем почерпнуть из документации по ClientLogin?
1. Это то, что такие параметры как AccountType и Service могут принимать вполне конкретные значения, которые можно представить в виде двух перечисляемых типов данных:

2. Ответ сервера также может содержать ограниченное количество значений (кодов) ошибок и 1 значение («Ok») при успешной аутентификации. Следовательно получим ещё один тип данных:

Теперь, когда все перечисляемые типы данных определены, возникает простой вопрос «Что дальше?». Как бы мы поступили, например, при формировании строки запроса, если б абсолютно ничего не знали про RTTI и модуль TypInfo в частности?
Как минимум, мы бы организовали, что-то наподобие этого:

Примерно то же самое и в отношении TServices. Будет ли этот код работать? Конечно будет…куда он нафиг денется. Но ведь можно сделать и по другому.
В модуле TypInfo определен следующий метод:

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

Мы получим сообщение, содержащее строку «HOSTED». Теперь применив этот метод, мы можем сократить код представленный выше всего до одной строки:

Или, если Вы используете какой-то шаблон для формирования строки, то так:

Функция LoadFromFile в Delphi.

Отсутствие вариантов – тоже вариант, но самый худший.

17.02.05 17:48 Ответ на сообщение Функция LoadFromFile в Delphi. пользователя Deft

Отсутствие вариантов – тоже вариант, но самый худший.

17.02.05 17:56 Ответ на сообщение Функция LoadFromFile в Delphi. пользователя Deft

Осторожнее с травой!
Если хапнешь много дряни
Увезут тебя с собой
Злые инопланетяне

17.02.05 18:08 Ответ на сообщение Re: Функция LoadFromFile в Delphi. пользователя craxx

Отсутствие вариантов – тоже вариант, но самый худший.

17.02.05 20:45 Ответ на сообщение Функция LoadFromFile в Delphi. пользователя Deft

17.02.05 21:09 Ответ на сообщение Re: Функция LoadFromFile в Delphi. пользователя Господин Уэф!

В ответ на: Но осмелюсь предположить. Если Delphi5 то могут быть глюки компилятора или еще Бог знает чего.

Отсутствие вариантов – тоже вариант, но самый худший.

17.02.05 23:40 Ответ на сообщение Re: Функция LoadFromFile в Delphi. пользователя Господин Уэф!

Отсутствие вариантов – тоже вариант, но самый худший.

18.02.05 08:46 Ответ на сообщение Re: Функция LoadFromFile в Delphi. пользователя Deft

18.02.05 08:50 Ответ на сообщение Re: Функция LoadFromFile в Delphi. пользователя Deft

Наверное ручками берешь и переносишь.
Вот что нашел в справке:

Каждый модуль в общем случае имеет структуру:

interface // Открытый интерфейс модуля

implementation // Реализация модуля

18.02.05 09:54 Ответ на сообщение Re: Функция LoadFromFile в Delphi. пользователя Deft

Осторожнее с травой!
Если хапнешь много дряни
Увезут тебя с собой
Злые инопланетяне

18.02.05 11:01 Ответ на сообщение Re: Функция LoadFromFile в Delphi. пользователя craxx

Отсутствие вариантов – тоже вариант, но самый худший.

18.02.05 13:11 Ответ на сообщение Re: Функция LoadFromFile в Delphi. пользователя Deft

Осторожнее с травой!
Если хапнешь много дряни
Увезут тебя с собой
Злые инопланетяне

18.02.05 13:50 Ответ на сообщение Re: Функция LoadFromFile в Delphi. пользователя craxx

Отсутствие вариантов – тоже вариант, но самый худший.

22.02.05 16:16 Ответ на сообщение Re: Функция LoadFromFile в Delphi. пользователя Deft

нельзя так делать.
Form1 — глобальная переменная. Она может быть
1. не инициализирована вообще (если отключено автосоздание форм проекта)
2. проинициализирована не тем экземпляром.

И вообще — слишком много действий.

procedure TForm1.FormCreate(Sender: TObject);
var
FileName: String;
begin
FileName := ExtractFileName(Application.Exename) + ‘profile.dat’;
if FileExists(FileName) then
ListBox.Items.LoadFromFile(FileName);
end;

Исправлено пользователем DmitryWP (22.02.05 16:22)

PromptForFileName — Функция Delphi

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

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

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

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

Функция Delphi также позволяет выполнить всё перечисленное, но дополнительно возвращает результат в присвоенном ей самой значении. То есть вызов функции может присутствовать в выражении справа от оператора присваивания. Таким образом, функция — более универсальный объект!

Описание подпрограммы состоит из ключевого слова procedure или function, за которым следует имя подпрограммы со списком параметров, заключённых в скобки. В случае функции далее ставится двоеточие и указывается тип возвращаемого значения. Обычная точка с запятой далее — обязательна! Сам код подпрограммы заключается в «логические скобки» begin/end. Для функции необходимо в коде присвоить переменной с именем функции или специальной зарезервированной переменной Result (предпочтительно) возвращаемое функцией значение. Примеры:

function Имя_функции(параметры): тип_результата;
begin
Код функции;
Result:= результат;
end;

procedure Имя_процедуры(параметры);
begin
Код процедуры;
end;

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

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

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

Теперь пример. Напишем программу суммирования двух чисел. Она будет состоять из Формы, на которой будет кнопка (компонент Button), по нажатию на которую будет выполняться наша подпрограмма, и двух строк ввода (компоненты Edit), куда будем вводить операнды. Начнём с процедуры.

var
Form1: TForm1;
A, B, Summa: Integer;
procedure Sum(A, B: Integer);

procedure TForm1.Button1Click(Sender: TObject);
begin
A:=StrToInt(Edit1.Text);
B:=StrToInt(Edit2.Text);
Sum(A, B);
Caption:=IntToStr(Summa);
end;

procedure Sum(A, B: Integer);
begin
Summa:=A+B;
end;

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

var
Form1: TForm1;
A, B, Summa: Integer;
function Sum(A, B: Integer): Integer;

procedure TForm1.Button1Click(Sender: TObject);
begin
A:=StrToInt(Edit1.Text);
B:=StrToInt(Edit2.Text);
Summa:=Sum(A, B); // На мой взгляд, сейчас более понятно, откуда что берётся
Caption:=IntToStr(Summa);
end;

function Sum(A, B: Integer): Integer;
begin
Result:=A+B;
end;

Есть особенности в использовании в качестве параметров больших по объёму структур данных, например, массивов, состоящих из нескольких тысяч (и больше) элементов. При передаче в подпрограмму данных большого объёма могут быть большие расходы ресурсов и времени системы. Поэтому используется передача не самих значений элементов (передача «по значению», как в предыдущих примерах), а ссылки на имя переменной или константы (передача «по имени»). Достигается это вставкой перед теми параметрами, которые мы хотим передать по имени, ключевого слова var.

function Sum(A, B: Integer; var Arr: array[1..1000000] of Integer): Integer;

Если взглянуть на описание нашей подпрограммы и описание обработчика нажатия кнопки (это тоже подпрограмма!), который был создан Delphi, то видим, что перед именем обработчика (Button1Click) стоит TForm1. Как мы знаем, в Delphi точкой разделяется объект и его атрибуты (свойства и методы). Таким образом, Delphi создаёт Button1Click как метод объекта Form1. Причём, буква T перед объектом говорит о том, что Button1Click не просто метод объекта, а метод класса объекта. Не будем этим пока заморачиваться, а просто будем поступать также. Описав свою процедуру или функцию как метод класса TForm1, мы получаем возможность использовать в ней объекты класса без указания его имени, что гораздо удобнее. То есть, если мы используем в нашей подпрограмме какие-либо компоненты, размещённые на Форме (например, Button1), то мы пишем

Button1.W >
а не
Form1.Button1.W >

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

Описав подпрограмму как метод класса, её описание мы должны поместить туда же, куда их помещает описание класса TForm1. Смотрите сами, где находится описание процедуры Button1Click. Для этого, поставив курсор внутрь подпрограммы Button1Click, нажмите CTRL+Shift и кнопку управления курсором «Вверх» или «Вниз» одновременно. Произойдёт переход к описанию подпрограммы (чтобы вернуться обратно, повторите это действие ещё раз). Ставьте описание своей подпрограммы рядом, с новой строки. Обратите внимание, что TForm1 уже не пишется.

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

Пример. Вычисление факториала

Вычисление факториала — классическая в программировании задача на использование рекурсии. Факториал числа N — результат перемножения всех чисел от 1 до N (обозначается N!):

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

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

Функции delphi

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

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

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

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

Давайте разберем как определить функцию.

Итак, в начале идет ключевое слово function, затем имя функции. Далее в круглых скобках список параметров. Также необходимо указать тип возвращаемого результата. При необходимости можно определить локальные переменные. Между операторных скобок (begin..end;) необходимо записать требуемые инструкции.

В каждой функции Delphi автоматически создает переменную с именем result, переменная имеет тот же тип, что и возвращаемое значение функции. С помощью этой переменной мы и будем возвращать значения. (Есть еще одна возможность вернуть значение, её я продемонстрирую на примере).

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

Разберем применение функций Делфи на простом примере.

Создайте новое приложение и на форме разместите три кнопки (Button).

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

Сама же функция будет иметь следующий вид:

Название – square, параметр всего один – x типа Double, результат тоже будет Double.

Делфи позволяет возвращать значения через переменную, название которой совпадает с названием функции Delphi. В нашем случае это выглядит так: square:=x*x;(закомментированный код).

Теперь посмотрим как можно использовать написанный код. Напишем обработчик события Onclickдля каждой из кнопок.

  • Для первой кнопки — ShowMessage(FloatToStr(square(1)));
  • Для второй — ShowMessage(FloatToStr(square(2)));
  • Для третей — ShowMessage(FloatToStr(square(3)));

У меня получился следующий Unit

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

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

how is Topendialog() and PromptForFileName() different in delphi?

In both of them you are give choices to choose files and add filters. Though I understand how both of their returntypes are different but how can they be used differently.?

See also questions close to this topic

I need to assign value to linear, but then when I check it the result is wrong. The expression 1/exp( 2.30258509299 * (abs(dB)/20) ) result is 0,063095734448 (which is correct value) but the linear is -3,6854775808e+4863 and n is 1,805186914e-307 .

What am I doing wrong and how to get the correct value?

Notice: For evaluation of the expression I used debuger «Evaluate/Modify» command.

I dropped a TMemo and a regular TStyleBook on a Form. I edited the custom style for the TMemo by adding a TRectangle to background so TMemo now has a different background color, and changed the TMemo.StyleLookup property to the actual StyleName , but at runtime the TMemo can not get focus.

What I am missing?

I am trying to create a COM object in Delphi and use it in a C# WPF project.

I have created a new DLL project in Delphi 10.3, using File -> New -> Other, then Delphi -> Windows -> ActiveX Library. I have created the following IDL in the GUI editor for my *.ridl file:

In Design view, I hit Refresh Implementation, Register Type Library, and Save As Type Library File. It says registration of the ActiveX Server was successful. I hit Build on my project. No errors or issues.

I added the following unit to implement the interface:

I rebuilt my project, no errors so far. I went and hit Run -> ActiveX Server -> Register. It was successful.

I would expect it to have a registered the COM object on my system now, or am I wrong? In my WPF C# project, when I try to Add Reference. , it does not show up under COM -> Type Libraries. Am I missing something?

i’m using a user identifying system to not repeat any users but upon identifying a clash delphi completely freezes

i have waited minutes on end but it doesn’t seem to fix anything

When I delete data using Delete, they still remain in the dbf table but are marked as deleted

How to delete data from a table physically

I am using Asynchrounous ADO queries in my Delphi 2010 app. The user can request cancellation of a query, or it may fail due to an error. This is the code I am using to cancel the query:

I am using the ADOConnection ExecuteComplete to show the cancellation (or other error) to the user:

I now want to be able to re-use the query after it has been amended, but when I re-run it I get the same error message. Is there a way I can reset the query (including the SQL.Text) and running it again?

A program running on computer «A» wants to download a file «F» in map «M» from computer «B». I use the following preparaions:

As computer «B» wants authorization I get the Windows-Security-dialog. I want to avoid this by giving the correct username and password automatically. I guess there is something in the API of this dialog that could help here but I have not found anything.

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