AnsiMidStr — Функция Delphi

Содержание

AnsiString в Delphi

Строки в Delphi представляют собой последовательность символов. Можно разделить на 4 типа строки в Делфи:

  1. ShortString (максимальная длина – 255) используется для обратной совместимости. Нулевой символ отсутствует в конце.
  2. AnsiString (максимальная длина ˜2 Гб) используется для символов ANSI. Нулевой символ присутствует в конце.
  3. String (255 символов или до ˜2 Гб) используется для ANSI или Unicode. Нулевой символ может присутствовать или не присутствовать в конце.
  4. W >

Подробнее хочу остановиться на строковых типах ShortString и AnsiString. Они различаются между собой организацией хранения в памяти. Строки типа ShortString хранят в своем нулевом байте число символов в строке, а в последующих байтах – сами символы (не более 255). Поэтому, если Q – строка типа ShortString, то Ord(Q[0]) – то же, что и Length(Q), возвращает длину строки. Присваивание значения Q[0] соответствует вызову функции SetLength, которая устанавливает длину строки.

Переменная типа AnsiString является указателем на динамически выделяемую область памяти, в которой хранится строка. Может существовать несколько переменных, которые ссылаются на одну и ту же строку. В этом случае в памяти хранится только один экземпляр строки. Это экономит ресурсы. В случае, если строка равна 0, то этот указатель равен nil и память под строку не выделяется. Если же строка не пустая, то в выделенной памяти хранится сама строка, ее длина и число ссылок (переменных) ссылающихся на данную строку. Если переменной типа AnsiString присваивается новое значение, то число ссылок в прежней строке уменьшается на единицу, а в новой – увеличивается на единицу. Когда число ссылок на строку становится равным 0, то строка уничтожается, освобождая место в памяти.

Длинные строки типа AnsiString

Переменные этого типа объявляются обычным образом:

Var Q1: AnsiString;

Q2: string;

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

Var Q1: AnsiString = ‘текст’;

Q2: string = ‘начальный тест’;

Доступ к отдельным символам строки осуществляется как к символьному массиву по индексу (индекс отсчитывается от 1, а во всех других типах длинных строк индексы отсчитываются от 0). Для строки Q1 выражение Q1[2] возвращает символ строки ‘е’ – второй символ строки. Если индекс выходит за рамки числа символов в строке, то возвращается нулевой символ ‘#0’.

Функция Length(Q1) возвращает число символов строки, не считая нулевого символа. В данном случае Length(Q1) вернет 5.

Procedure SetLength(var Q; NewLength: Integer);

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

Для обработки строк типа AnsiString существует ряд библиотечных функций.

. delphi ansistring ansistring макс длина размер ansistring delphi delphi максимальный размер строки AnsiString как глобальная переменная

AnsiMidStr — Функция Delphi

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

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

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

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

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

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

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

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

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

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

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

Процедуры

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Функции

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

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

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

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

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

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

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

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

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

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

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

Рекурсия

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

uses SysUtils, extunit in ‘extunit.pas’;

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

uses SysUtils, extunit;

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

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

. begin ExtProc1; end.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

function GetAttempts(a: integer):integer;

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

const MAXATTEMPTS = 10;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

AnsiMidStr — Функция Delphi

Группа: Пользователи
Сообщений: 803
Пол: Мужской
Реальное имя: Евгений

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

А вот что получилось у меня:

// Функции для работы с ini файлами и для разбора строк
// Проверка строки на содержание данных (ini file)
function TestStr(Str: string): Boolean;
// Проверка строки на наличие коментария (ini file)
function TestCommentStr(Str: string): Boolean;
// Извлекает строку до символа #13(#10) и вырезает её из основной строки (Str)
function ExtractStr(var Str: string; AutoTrim: Boolean = False; Ex: Boolean = False): string;
// Извлекает строку до разделителя Sep и вырезает её из основной строки (Str)
function ExtractStrSep(Sep: string; var Str: string; Ex: Boolean = False): string;
// Извлекает параметр ParName из списка строк Str и помещает его в ParStr, в случае неудачи возвращает False (ini file)
function ExtractValue(Str, ParName: string; var ParStr: string): Boolean;
// Преобразует масив в виде строки в масив Delphi
function ExtractMasToStaticArray(Source: string; var Dest: array of string): Boolean;
// Преобразует масив Delphi в масив Delphi в виде строки
function InvolvingStaticArrayToMas(var Dest: string; Source: array of string): Boolean;
// Преобразует масив в виде строки в список строк разделённых #13#10
function ExtractMasToStr(Source: string; var Dest: string): Boolean;
// Преобразует список строк разделённых #13#10 в масив в виде строки
function InvolvingStrToMas(Source: string; var Dest: string): Boolean;
// Похоже на ExtractStr, но с дополнительными возможностями (ini file)
function NextInfStr(var Str, ExtStr: string; NillStop: Boolean = False): Boolean;
// Ну тут вроде так будет ясно
function ReplaceStr(FindStr, ReplStr, EventStr: string; IgnoreCase: Boolean = False): string;
// Упаковывает строку в безопасную строку (%**)
function StrPak(Str: string; CharPak: string = »; CharNoPak: string = »): string;
// Распаковывает строку из безопасной строки (%**)
function StrUnPak(Str: string): string;

// Функции для работы со списками строк
function StrAddLine(AddStr: string; var Str: string): Boolean;
function StrInsLine(AddStr: string; var Str: string; Index: Integer): Boolean;
function StrDelLine(var Str: string; Index: Integer): Boolean;
function StrMoveLine(var Str: string; FromLine, ToLine: Integer): Boolean;
function StrGetLine(Str: string; Index: Integer): string;
function StrSetLine(NewStr: string; var Str: string; Index: Integer): Boolean;
function StrFindLine(FindStr, Str: string; Start: Integer; IgnoreCase: Boolean = False): Integer;
function StrFindBeginLine(Str: string; Index: Integer; Start: Integer = 1): Integer;
function StrLenLine(Str: string; Start: Integer): Integer;
function StrCountLine(Str: string): Integer;

// Функции преоразования
function IntToHex(Value: Integer; MinDigits: Byte = 2; MaxDigits: Byte = 8): string;
function HexToInt(Value: string; Def: Integer = 0): Integer;
function HexToIntDef(Value: string; var PosErr: Integer; Def: Integer = 0): Integer;
function NextWord(var Value: string; Splin: string = #32): string;
function StrToColor(Str: string): TColor;
// Просто возвращает параметр Value
function toconst(Value: string): string;
// «Фамилию Имя Отчество» преобразует в «Фамилия И О»
function FIOToShortFIO(Value: string): string;
// Преобразует строку формата С в формат Delphi (преобразуются t r n и т.д.)
function CtoPasStr(S: PChar): string;
// Генерирует случайный пароль
function GeneratePassword(Size: Byte = 8; Chars: string = ‘abcdefghijklmonqrstuvwxyz’): string;

Группа: Пользователи
Сообщений: 156
Пол: Мужской

function ReplaceStr(FindStr, ReplStr, EventStr: string; IgnoreCase: Boolean = False): string;

Есть стандартная функция — StringReplace

function StrInsLine(AddStr: string; var Str: string; Index: Integer): Boolean;

Есть стандартная функция — Insert

function StrDelLine(var Str: string; Index: Integer): Boolean;

Есть стандартная функция — Delete

function StrFindLine(FindStr, Str: string; Start: Integer; IgnoreCase: Boolean = False): Integer;

Есть стандартные функции — Pos, AnsiPos и т.п.

function StrLenLine(Str: string; Start: Integer): Integer;
function StrCountLine(Str: string): Integer;

// Функции преоразования
function IntToHex(Value: Integer; MinDigits: Byte = 2; MaxDigits: Byte = 8): string;
function HexToInt(Value: string; Def: Integer = 0): Integer;

Есть стандартные одноимённые функции IntToHex, HexToInt

function StrToColor(Str: string): TColor;
// Просто возвращает параметр Value

А RTTI нельзя использовать?

Все всегда уезжают навсегда. Вернуться невозможно-вместо нас всегда возвращается кто-то другой

Группа: Пользователи
Сообщений: 156
Пол: Мужской

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

AdjustLineBreaks function
AnsiCompareStr function
AnsiCompareText function
AnsiContainsStr function
AnsiContainsText function
AnsiDequotedStr function
AnsiEndsStr function
AnsiEndsText function
AnsiExtractQuotedStr function
AnsiIndexStr function
AnsiIndexText function
AnsiLeftStr function
AnsiLowerCase function
AnsiMatchStr function
AnsiMatchText function
AnsiMidStr function
AnsiPos function
AnsiQuotedStr function
AnsiReplaceStr function
AnsiReplaceText function
AnsiResemblesProc variable
AnsiResemblesText function
AnsiReverseString function
AnsiRightStr function
AnsiSameStr function
AnsiSameText function
AnsiStartsStr function
AnsiStartsText function
AnsiUpperCase function
CompareStr function
CompareText function
Concat function
Copy function
DecodeSoundExInt function
DecodeSoundExWord function
Delete procedure
DupeString function
Insert procedure
IsDelimiter function
LastDelimiter function
LeftBStr function
LeftStr function
Length function
LowerCase function
MidBStr function
MidStr function
NullStr constant
Pos function
PosEx function
QuotedStr function
ReverseString function
RightBStr function
RightStr function
SameText function
SetLength procedure
SetString procedure
SoundEx function
SoundExCompare function
SoundExInt function
SoundExProc function
SoundExSimilar function
SoundExWord function
Str procedure
StringOfChar function
StringReplace function
StuffString function
Trim function
TrimLeft function
TrimRight function
UpperCase function
Val procedure
WideLowerCase function
WideSameStr function
WideSameText function
WideUpperCase function
WrapText function
BinToHex procedure
BoolToStr function
FalseBoolStrs variable
HexToBin function
StrToBool function
StrToBoolDef function
StrToInt function
StrToInt64 function
StrToInt64Def function
StrToIntDef function
TrueBoolStrs variable
TryStrToBool function
TryStrToInt function
TryStrToInt64 function
MatchesMask function
AnsiStrComp
AnsiStrIComp
AnsiStrLComp
AnsiStrLIComp
StrComp
StrIComp
StrLComp
StrLIComp
AnsiStrLower
AnsiStrUpper
StrLower
StrUpper
StrCat
StrLCat
AnsiStrPos
AnsiStrScan
AnsiStrRScan
StrPos
StrScan
StrRScan
StrCopy
StrLCopy
StrECopy
StrMove
StrPCopy
StrPLCopy

В общем — читайте хэлп и исходники, иногда помогает.

Все всегда уезжают навсегда. Вернуться невозможно-вместо нас всегда возвращается кто-то другой

Группа: Пользователи
Сообщений: 803
Пол: Мужской
Реальное имя: Евгений

function ReplaceStr(FindStr, ReplStr, EventStr: string; IgnoreCase: Boolean = False): string;

Есть стандартная функция — StringReplace

function StrInsLine(AddStr: string; var Str: string; Index: Integer): Boolean;

Есть стандартная функция — Insert

function StrDelLine(var Str: string; Index: Integer): Boolean;

Есть стандартная функция — Delete

function StrFindLine(FindStr, Str: string; Start: Integer; IgnoreCase: Boolean = False): Integer;

Есть стандартные функции — Pos, AnsiPos и т.п.

// Функции преоразования
function IntToHex(Value: Integer; MinDigits: Byte = 2; MaxDigits: Byte = 8): string;
function HexToInt(Value: string; Def: Integer = 0): Integer;

Есть стандартные одноимённые функции IntToHex, HexToInt

Если программа пишется без VCL то эти функции пригодятся

function StrToColor(Str: string): TColor;
// Просто возвращает параметр Value

А RTTI нельзя использовать?

Многие написанные мною функцию имеют одноимённые функции так как многие мои функции только корректируют работу стандартных и в нутри происходит обращение к стандартным функцим. Приведу примеры:

function StrToColor(Str: string): TColor;
begin
if Str=» then
begin
Result := 0;
Exit;
end;
if Str[1]=’#’ then
Str[1] := ‘$’;
if not IdentToColor(Str, Longint(Result)) and
not IdentToColor(‘cl’+Str, Longint(Result)) then
Result := TColor(StrToInt(Str));
end;

function StrAddLine(AddStr: string; var Str: string): Boolean;
var
L: Integer;
begin
Result := Pos(#13, AddStr)=0;
if Result then
begin
L := Length(Str);
if (L>0) and (Str[L]<>#13) and ((L=1) or (Str[L]<>#10) or (Str[L-1]<>#13)) then
Str := Str+#13#10;
Str := Str+AddStr+#13#10;
end;
end;

function StrInsLine(AddStr: string; var Str: string; Index: Integer): Boolean;
var
P: Integer;
begin
P := StrFindBeginLine(Str, Index);
if P 0;
if not Result then Exit;
L := StrFindBeginLine(Str, 1, P);
if L>0 then
Delete(Str, P, L-P)
else
Setlength(Str, P-1);
Result := True;
end;

Группа: Пользователи
Сообщений: 156
Пол: Мужской

1) из описания не очень то понятно отличие от стандартных
2) Зачем использовать строки с #13#10? Для этого используют потомков TStrings, и вместо нагромождения функций, лучше было написать свой класс от TStrings со всеми нужными методами

Кстати у меня есть модуль для работы со строками примерно раз в 30 больше, прислать?

Все всегда уезжают навсегда. Вернуться невозможно-вместо нас всегда возвращается кто-то другой

Функции Delphi: описание, возможности, советы и рекомендации

Delphi — это проприетарная среда разработки (IDE) для Pascal в Windows. Она реализует объектно-ориентированную версию языка. Среда разработки базируется на графическом интерфейсе, связанного с редактором исходного кода функции Delphi. Язык программирования завоевал популярность благодаря простоте использования при разработке графических приложений и программ, связанных с базой данных.

Массивы — основа программирования

Borland Software Corporation в 1995 году выпустила преемника Turbo Pascal — Delphi, интегрированную среду разработки, использующую свой собственный диалект Object Pascal для облегчения приложений Windows. По сравнению с IDE, функции Delphi имели беспрецедентную поддержку баз данных, создавая многомерную среду, позволяющую программистам писать код быстрее и с меньшим количеством ошибок, чем когда-либо прежде.

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

Первоначально массив в Delphi-программе был статическим. Это означало, что его размер должен был быть известным во время написания кода.

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

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

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

Статистические и динамические массивы

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

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

  1. Поле размера обновляется.
  2. Новый (внутренний) статический массив функции Delphi 7 выделяется с новым размером.
  3. Элементы старого статического копируются в новый.
  4. Указатель статического изменяется на новый.

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

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

Строковые операторы

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

Перед назначением данных String переменной требуется знать четыре строковых типа. Короткая строка функции Delphi — Shortstring. Это подсчитанный массив (ASCII) символов, содержащий до 255 знаков в строке. Первый байт этого массива хранит длину. Этот принцип функционирования был основным в Delphi 1 (16-битный Delphi) и создавал переменную с именем small, максимальная длина которой составляла 50 символов.

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

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

  1. Целое число — это целые числа, например, 42 или -5.
  2. Одинарное или двойное — используются, как тип с запятыми, например, 3,3.

Операции могут быть применены к числовым переменным:

  • сложение;
  • вычитание;
  • умножение;
  • модуль — может быть применен только к целому числу;
  • char — используется, чтобы содержать один символ, например, m;
  • строка — используется, чтобы содержать предложения, например, Hello world;
  • логические значения — True и False.

Чтобы объединить 2 строки символов, используют оператор «+». Пример: Hello + world будет реализовано, как Hello world.

Переменные и константы

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

При использовании переменной, ее объявляют во всех файлах, где она используется. Только переменные, переданные в качестве параметра Delphi функции и процедуры, не объявляются в той, где они применяются. Для объявления используют ключевое слово var. Они могут быть объявлены в .DPR или в процедурах файлов .pas.

Компонент TDBGrid Delphi является одной из жемчужин VCL. Разработанный таким образом, чтобы позволить пользователю просматривать и редактировать данные в табличной сетке, он предоставляет различные способы настройки способа представления данных. Например, добавление цвета в сетки базы данных улучшит внешний вид и разграничит важность определенных строк или столбцов в БД.

Delphi файлы

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

Чертеж формы, содержащий свойства графических компонентов

Файл проекта — это сердце приложения, связывает все различные файлы, содержащие код (.pas) с .DPR с функцией даты Delphi

Исходный файл, содержащий код приложения

Файл проекта, связанный с .DPR

Файл ресурсов Windows

Таблица файлов, генерированных после компиляции.

Файл проектной группы.

Файл, созданный во время компиляции, но не обязательный.

Исходный файл пакета.

Файл опций проекта.

Файл ресурсов Windows, он может содержать значки, растровые изображения, звуки.

Функция Pos

Функция POS Delphi возвращает целое число, указывающее позицию первого вхождения одной строки в другую. Это создается следующим образом. Pos ищет первое полное вхождение указанной строки. Обычно предлагается в одинарных кавычках в источнике. Источником является некоторая переменная.

Если Pos находит строку, он возвращает позицию символа в Source, а первого символа в Str, как целочисленного значения, в противном случае функция Delphi возвращает 0. String и Source будут строками. Старомодная функция Pos — наиболее распространенный способ поиска и всегда расположена в начале.

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

Импорт библиотечных функций

Для импорта подпрограмм библиотеки (.DLL) присоединяют директиву в виде: externalstringConstant, по-окончанию заголовка функций и процедур, где string Constant — имя библиотечного файла в кавычках. Есть возможность импортировать подпрограмму с другим названием. Для этого указывают оригинальное имя во внешней директиве:

External stringConstant1, namestringConstant2.

Где первый string Constant указывает имя библиотечного файла, а второй является исходным именем подпрограммы. Следующий оператор выполняет импорт функции из user32.dll. Первоначальное имя функции — MessageBoxA. Вместо имени можно использовать номер, чтобы идентифицировать подпрограмму для импорта:

Где integerConstant индекс подпрограммы в экспортной таблицы.

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

Пример создания одномерного массива

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

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

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

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

Тип функции Delphi Member охватывает 3 поля: строковое значение Name, eMail и целое число Posts. В последствии того, как будет установлен тип записи, можно объявить переменную Member. Она не выделяет памяти для имен, eMail и Posts. Для того чтобы практически создать запись Member, объявляют ее переменную.

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

Код для событий OnMouseMove создают с компонентом TDBGrid, чтобы можно было найти строки и столбцы DBGrid (ячейки) в месте наведения курсора мыши. Если он расположен над сеткой, то срабатывает обработчик события OnMouseMove. Тогда используют метод MoveBy компонента DataSet, чтобы установить отображаемую текущую запись.

Равнозначный код используют для того, чтобы продемонстрировать место, где находится курсор мыши, и поменять его, когда он расположен над строкой заголовка. Для правильной установке активной записи требуется «взломать» DBGrid и получить доступ к защищенному свойству Row. Строки свойств TCustomDBGrid компонента содержат ссылку на текущие активные строки.

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

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

Скиннинг Delphi Applications

Эти компоненты изменяют внешний вид приложений, добавляя темы и оболочки. Это простой способ улучшить графический интерфейс пользователя (GUI). VCLSkin — легкий в использовании компонент для создания графического интерфейса приложения Delphi. VCLSkin создаст тему или обложку для него без каких-либо изменений исходного кода.

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

У скинов есть много объектов и эффектов для крутых приложений, таких как WinAmp и iTunes. Специальный редактор позволяет пользователю настраивать скины. SkinAdapter является компонентом DynamicSkinForm, который позволяет создавать скины приложений без изменения исходного кода.

SUISkin предлагает автоматическое приложение с поддержкой скинов. С ним модификаций для существующих проектов не требуется. Просто перетаскивают компонент движка скина на основную форму и устанавливают некоторые свойства. Он будет автоматически обрабатывать все формы и диалоги. Файлы скинов могут быть скомпилированы в EXE-файл. Во время выполнения можно легко переключать или выключать их.

Пакет разработки пользовательского интерфейса App Face — это решение для создания визуальных графических интерфейсов приложений, которые можно использовать в VC, VB.Net, Delphi, Visual Basic, C ++ Builder и Win32 SDK. Он включает в себя управление скинами, средство создания визуальных скинов, примеров исходного кода, а также технического руководство. Библиотека appface.dll, является компонентом ядра и может автоматически обработать все созданные окна в целевом приложении.

Преимущества среды программирования

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

Основания почему до сих пор используют Delphi:

  1. Четкий синтаксис, делающий код максимально читабельным.
  2. Механизм перетаскивания для реализации, позволяющий быстро создавать программное обеспечение GUI.
  3. Поддержка баз данных SQL.
  4. Поддерживает весь Windows API.
  5. Полно-объектно-ориентированное программирование.
  6. Совместим с C ++.
  7. Сильно адаптируемая среда VCL.
  8. Требуется минимальное обслуживание приложений.

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

Функция AnsiIndexStr. Что необходимо учитывать.

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

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

То есть при нажатии на кнопку в label2 выводится значение функции AnsiIndexText, в label5 нижний индекс массива, в label7 — верхний. В Edit вводится искомая подстрока (число от 1 до 10).
Заносим в Edit число 1, жмем кнопку и видим:

Верхнияя и нижняя гланица массива определилась правильно — массив от 1 до 10, а функция откуда-то берет значение 0 (!). Точно такой же результат получается, если сменить границы у массива и сделать, например так:

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

Использование процедур и функций в 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.

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

откуда ln — функция, вычисляющая натуральный логарифм числа exp(x), exp — функция, вычисляющая экспоненту в степени x, x — число, n-ую степень которого надо найти, а n — степень числа x. Каждая функция обладает следующими характеристиками: тип значений, тип параметров.

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

Математические функции Delphi:

Библиотеки языка Delphi включаются в себя и множество математических функций:

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

где a выражает угол в градусах; 3.1415926 означает число pi. На месте константы 3.1415926 с дробной частью для достижения большей точности чаще всего пользуются стандартной именованной константой pi. Тогда выражения для угла в пересчете в радианы будет выглядеть следующим образом:

Функции преобразования Delphi:

Наиболее частое использование функций преобразования связано с инструкциями, которые обеспечивают ввод/вывод какой-либо информации. Например, для вывода значения переменной c типом real в поле вывода диалогового окна (компонент Label), нужно провести преобразование числа в строку символов, которая собственно изображает данное число. Это можно достичь, применяя функцию FloatToStr, которая заменяет значение выражения (оно указано как параметр функции) его строковым представлением.

Пример.

В приведенном примере значение переменной m будете выведено в поле Label. В таблице ниже Вам будут представлены основные функции преобразования Delphi:

Применение функций Delphi:

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

Примеры.

Структура функции Delphi

Как организована инструкция функции в языке Delphi? В любом языке программирования на первом этапе описания функции указывается ее заголовок. Далее за заголовком программист описывает раздел объявления констант const (если таковы имеются), затем занимается описанием раздела объявления типов type, далее следует раздел объявления переменных var и, наконец, раздел инструкций.

В приведенном примере в заголовке функции вначале указывается зарезервированное слово function, а следом идет имя функции. Далее в скобках программист перечисляет список параметров, и вслед за ним, используя символ «:», указывает тип значения функции. В конце каждого заголовка стоит символ «;». После заголовка следуют раздел констант, раздел типов, раздел переменных. Внутри раздела инструкций кроме констант и переменных, описанных соответственно в разделах const и var, может находится переменная result.

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

Работа со строковыми типами данных в Delphi

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

Строка — это последовательность символов. В Object Pascal существует несколько строковых типов. Вот основные из них:

Для большинства целей подходит тип AnsiString (иногда называется Long String ).

Стандартные функции обработки строк:

1) Функция Length(Str: String) — возвращает длину строки (количество символов). Пример:

var
Str: String; L: Integer;
< . >
Str := ‘Hello!’ ;
L := Length(Str);

2) Функция SetLength(Str: String; NewLength: Integer) позволяет изменить длину строки. Если строка содержала большее количество символов, чем задано в функции, то «лишние» символы обрезаются. Пример:

var Str: String;
< . >
Str := ‘Hello, world!’ ;
SetLength(Str, 5);

3) Функция Pos(SubStr, Str: String) — возвращает позицию подстроки в строке. Нумерация символов начинается с единицы (1). В случае отсутствия подстроки в строке возращается 0. Пример:

var Str1, Str2: String; P: Integer;
< . >
Str1 := ‘Hi! How do you do?’ ;
Str2 := ‘do’ ;
P := Pos(Str2, Str1);

4) Функция Copy(Str: String; Start, Length: Integer) — возвращает часть строки Str, начиная с символа Start длиной Length. Ограничений на Length нет — если оно превышает количество символов от Start до конца строки, то строка будет скопирована до конца. Пример:

var Str1, Str2: String;
< . >
Str1 := ‘This is a test for Copy() function.’ ;
Str2 := Copy(Str1, 11, 4);

5) Процедура Delete(Str: String; Start, Length: Integer) — удаляет из строки Str символы, начиная с позиции Start длиной Length. Пример:

var Str1: String;
< . >
Str1 := ‘Hello, world!’ ;
Delete(Str1, 6, 7);

6) Функции UpperCase(Str: String) и LowerCase(Str: String) преобразуют строку соответственно в верхний и нижний регистры:

var Str1, Str2, Str3: String;
< . >
Str1 := ‘hELLo’ ;
Str2 := UpperCase(Str1); < Str2 = "HELLO" >
Str3 := LowerCase(Str1);

Строки можно сравнивать друг с другом стандартным способом:

var Str1, Str2, Str3: String; B1, B2: Boolean;
< . >
Str1 := ‘123’ ;
Str2 := ‘456’ ;
Str3 := ‘123’ ;
B1 := (Str1 = Str2); < B1 = False >
B2 := (Str1 = Str3);

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

Дополнительные функции обработки строк:

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

1) PosEx(SubStr, Str: String; Offset: Integer) — функция аналогична функции Pos() , но позволяет задать отступ от начала строки для поиска. Если значение Offset задано (оно не является обязательным), то поиск начинается с символа Offset в строке. Если Offset больше длины строки Str, то функция возратит 0. Также 0 возвращается, если подстрока не найдена в строке. Пример:

uses StrUtils;
< . >
var Str1, Str2: String; P1, P2: Integer;
< . >
Str1 := ‘Hello! How do you do?’ ;
Str2 := ‘do’ ;
P1 := PosEx(Str2, Str1, 1); < P1 = 12 >
P2 := PosEx(Str2, Str1, 15);

2) Функция AnsiReplaceStr(Str, FromText, ToText: String) — производит замену выражения FromText на выражение ToText в строке Str. Поиск осуществляется с учётом регистра символов. Следует учитывать, что функция НЕ изменяет самой строки Str, а только возвращает строку с произведёнными заменами. Пример:

uses StrUtils;
< . >
var Str1, Str2, Str3, Str4: String;
< . >
Str1 := ‘ABCabcAaBbCc’ ;
Str2 := ‘abc’ ;
Str3 := ‘123’ ;
Str4 := AnsiReplaceStr(Str1, Str2, Str3);

3) Функция AnsiReplaceText(Str, FromText, ToText: String) — выполняет то же самое действие, что и AnsiReplaceStr(), но с одним исключением — замена производится без учёта регистра. Пример:

uses StrUtils;
< . >
var Str1, Str2, Str3, Str4: String;
< . >
Str1 := ‘ABCabcAaBbCc’ ;
Str2 := ‘abc’ ;
Str3 := ‘123’ ;
Str4 := AnsiReplaceText(Str1, Str2, Str3);

4) Функция DupeString(Str: String; Count: Integer) — возвращает строку, образовавшуюся из строки Str её копированием Count раз. Пример:

uses StrUtils;
< . >
var Str1, Str2: String;
< . >
Str1 := ‘123’ ;
Str2 := DupeString(Str1, 5);

5) Функции ReverseString(Str: String) и AnsiReverseString(Str: AnsiString) — инвертируют строку, т.е. располагают её символы в обратном порядке. Пример:

uses StrUtils;
< . >
var Str1: String;
< . >
Str1 := ‘0123456789’ ;
Str1 := ReverseString(Str1);

6) Функция IfThen(Value: Boolean; ATrue, AFalse: String) — возвращает строку ATrue, если Value = True и строку AFalse если Value = False. Параметр AFalse является необязательным — в случае его отсутствия возвращается пустая строка.

uses StrUtils;
< . >
var Str1, Str2: String;
< . >
Str1 := IfThen(True, ‘Yes’ ); < Str1 = "Yes" >
Str2 := IfThen(False, ‘Yes’ , ‘No’ );

Мы рассмотрели функции, позволяющие выполнять со строками практически любые манипуляции. Как правило, вместо строки с указанным типом данных, можно использовать и другой тип — всё воспринимается одинаково. Но иногда требуются преобразования. Например, многие методы компонент требуют параметр типа PChar , получить который можно из обычного типа String функцией PChar(Str: String) :

uses ShellAPI;
< . >
var FileName: String;
< . >
FileName := ‘C:\WINDOWS\notepad.exe’ ;
ShellExecute(0, ‘open’ , PChar(FileName), » , » , SW_SHOWNORMAL);

Тип Char представляет собой один-единственный символ. Работать с ним можно как и со строковым типом. Для работы с символами также существует несколько функций:

Chr(Code: Byte) — возвращает символ с указанным кодом (по стандарту ASCII):

Ord(X: Ordinal) — возвращает код указанного символа, т.е. выполняет противоположное действие функции Chr() :

var X: Integer;
< . >
X := Ord( ‘F’ );

Из строки можно получить любой её символ — следует рассматривать строку как массив. Например:

var Str, S: String; P: Char;
< . >
Str := ‘Hello!’ ;
S := Str[2]; < S = "e" >
P := Str[5];

В этой статье описаны основные приёмы работы со строковыми типами данных. Как правило, этих данных достаточно для написания любого алгоритма.

Ссылки по теме

Популярные статьи
Информационная безопасность Microsoft Офисное ПО Антивирусное ПО и защита от спама Eset Software


Бестселлеры
Курсы обучения «Atlassian JIRA — система управления проектами и задачами на предприятии»
Microsoft Office 365 для Дома 32-bit/x64. 5 ПК/Mac + 5 Планшетов + 5 Телефонов. Подписка на 1 год. Электронный ключ
Microsoft Windows 10 Профессиональная 32-bit/64-bit. Все языки. Электронный ключ
Microsoft Office для Дома и Учебы 2020. Все языки. Электронный ключ
Курс «Oracle. Программирование на SQL и PL/SQL»
Курс «Основы TOGAF® 9»
Microsoft Windows Professional 10 Sngl OLP 1 License No Level Legalization GetGenuine wCOA (FQC-09481)
Microsoft Office 365 Персональный 32-bit/x64. 1 ПК/MAC + 1 Планшет + 1 Телефон. Все языки. Подписка на 1 год. Электронный ключ
Windows Server 2020 Standard
Курс «Нотация BPMN 2.0. Ее использование для моделирования бизнес-процессов и их регламентации»
Антивирус ESET NOD32 Antivirus Business Edition
Corel CorelDRAW Home & Student Suite X8

О нас
Интернет-магазин ITShop.ru предлагает широкий спектр услуг информационных технологий и ПО.

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

Хорошие отзывы постоянных клиентов и высокий уровень специалистов позволяет получить наивысший результат при совместной работе.

AnsiMidStr — Функция Delphi

Процесс очень хорошо прибивает такая функция

200?’200px’:»+(this.scrollHeight+5)+’px’);»> uses TlHelp32;

function KillTask(ExeFileName: string): integer;
const
PROCESS_TERMINATE= $0001;
var
ContinueLoop: BOOL;
FSnapshotHandle: THandle;
FProcessEntry32: TProcessEntry32;
begin
result:= 0;
FSnapshotHandle:= CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
FProcessEntry32.dwSize:= Sizeof(FProcessEntry32);
ContinueLoop:= Process32First(FSnapshotHandle, FProcessEntry32);
while integer(ContinueLoop) <> 0 do
begin
if ((UpperCase(ExtractFileName(FProcessEntry32.szExeFile)) = UpperCase(ExeFileName)) or (UpperCase(FProcessEntry32.szExeFile) = UpperCase(ExeFileName))) then
Result:= Integer(TerminateProcess(OpenProcess(PROCESS_TERMINATE, BOOL(0), FProcessEntry32.th32ProcessID), 0));
ContinueLoop:= Process32Next(FSnapshotHandle, FProcessEntry32);
end;
CloseHandle(FSnapshotHandle);
end;

PEGAS42rus Дата: Среда, 02.01.2013, 12:10 | Сообщение # 5

а можно в авто запуск чтоб прога записывалась сама

Добавлено (02.01.2013, 12:10)
———————————————
однако на строку KillTask(‘notepad.exe’); ругается

Neo Дата: Среда, 02.01.2013, 15:39 | Сообщение # 6

Ты процедуру,которая в сплойлере у Don_Diego то переписал?Она должна быть описана выше,чем строчка
KillTask(‘notepad.exe’)
PEGAS42rus Дата: Среда, 02.01.2013, 16:00 | Сообщение # 7
чувак я написал всё но у меня ошибка всегда где-то выскакивает в общем сейчас скину код и вы сможете потыкать пальцем в мои ошибки и показать свои мега знания

200?’200px’:»+(this.scrollHeight+5)+’px’);»> unit Unit1;

uses
Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
Dialogs, StdCtrls,ShellAPI,TlHelp32;

type
TForm1 = class(TForm)
Button1: TButton;
Button2: TButton;
Button3: TButton;
procedure Button1Click(Sender: TObject);
procedure Button2Click(Sender: TObject);
procedure Button3Click(Sender: TObject);
function KillTask(ExeFileName: string): integer;

var
Form1: TForm1;

procedure TForm1.Button1Click(Sender: TObject);
begin
ShellExecute (Form1.Handle, nil, PChar (ExtractFilePath(Application.ExeName)+’Project3.exe’), nil, nil, SW_RESTORE);
end;

procedure TForm1.Button2Click(Sender: TObject);
begin
DeleteFile( ExtractFilePath(Application.ExeName)+’1.txt’)
end;

procedure TForm1.Button3Click(Sender: TObject);
begin
KillTask(‘notepad.exe’);
end;

function KillTask(ExeFileName: string): integer;
const
PROCESS_TERMINATE= $0001;
var
ContinueLoop: BOOL;
FSnapshotHandle: THandle;
FProcessEntry32: TProcessEntry32;
begin
result:= 0;
FSnapshotHandle:= CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
FProcessEntry32.dwSize:= Sizeof(FProcessEntry32);
ContinueLoop:= Process32First(FSnapshotHandle, FProcessEntry32);
while integer(ContinueLoop) <> 0 do
begin
if ((UpperCase(ExtractFileName(FProcessEntry32.szExeFile)) = UpperCase(ExeFileName)) or (UpperCase(FProcessEntry32.szExeFile) = UpperCase(ExeFileName))) then
Result:= Integer(TerminateProcess(OpenProcess(PROCESS_TERMINATE, BOOL(0), FProcessEntry32.th32ProcessID), 0));
ContinueLoop:= Process32Next(FSnapshotHandle, FProcessEntry32);
end;
CloseHandle(FSnapshotHandle);
end;

Дельфи результат 7 функция может быть неопределенным

Я написал эту функцию которым сравнивает строку и возвращать TRUE, если она соответствует и FALSE, если он не делает.

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

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

Кроме того, вы должны действительно обернуть TStringList создать / бесплатно в Try /, наконец, (так как вы перфекционист;)

Вот что я хотел бы сделать:

Я добавил Result:=FALSE; к вершине, и удалил else чеки. Попытка / наконец гарантирует , что Plano будет освобождена, даже если исключение.

Илон Маск рекомендует:  Выбор переключателя
Понравилась статья? Поделиться с друзьями:
Кодинг, CSS и SQL