Const — Ключевое слово Delphi


Содержание

Const — Ключевое слово Delphi

От Delphi 4 к Delphi 5
Программный модуль Delphi состоит из раздела interface (интерфейс) и раздела implementation (реализации).

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

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

Константы (постоянные величины), или константные выражения, – это имена для фиксированных значений, на которые происходит ссылка в программах. Константа дает возможность обращаться к этим значениям по имени. Значение их не меняется в течение выполнения вашего приложения.

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

Синтаксис объявления констант следующий:


Const
ИмяКонстанты1=значение константы;
ИмяКонстанты2=константное выражение;

ИмяКонстантыN=значение константы;

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

Примеры объявления констант:

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

Примеры константных выражений:

Имеются предопределенные константы: True — истина, False — ложь, Nil — нулевой указатель.

Константное выражение может использовать константы, ранее объявленные именованные константы, арифметические операции, значения переменных типов, конструкторы множеств, а также следующие встроенные функции: Abs, Addr, ArcTan, Chr, Cos, Exp, Frac, Hi, High, Int, Lenght, Ln, Lo, Low, Odd, Ord, Pi, Pred, Round, Sin, SizeOf, Sqr, Sqrt, Succ, Swap, Trunc.

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

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

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

Имеется такой вид констант, как строки ресурсов. Они включаются в проект с помощью ключевого слова resourcestring вместо const.

Пример строки ресурсов:


resourcestring
ThisGoodText=’
Это хороший текст ‘;
Константы записи.

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

TPoint=record
X, Y: Single;
end;
TVector=array[0..1] of TPoint;
TMonth=(Jan, Feb, Mar, Apr, May, Jun, Jul, Aug, Sep, Oct, Nov, Dec);
TDate=record
D: 1..31;
M: TMonth;
Y: 1900..1999;
end;
const
Origin: TPoint=(X: 0.0; Y: 0.0);
Line: TVector=((X: -3.1; Y: 1.5), (X: 5.8; Y: 3.0));
SomeDay: TDate=(D: 2; M: Dec; Y: 1960);

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


const Digits: array[0..9] of Char=(‘0’, ‘1’, ‘2’, ‘3’, ‘4’, ‘5’, ‘6’, ‘7’, ‘8’, ‘9’);

объявляется типизированная константа, с именем «цифры», которая содержит массив символов.

Более удобно это объявление можно представить как:


const Digits: array[0..9] of Char=’0123456789′;

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


type TCube=array[0..1, 0..1, 0..1] of Integer;
const Maze: TCube=(((0, 1), (2, 3)), ((4, 5), (6,7)));

Переменная – это именованный тип данных заранее определенного типа. С точки зрения технических подробностей, это область памяти, определенная программистом, где можно сохранять значения. Тип переменной определяет виды значений, которые вы можете там хранить.

Переменная имеет следующие характеристики.


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


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

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

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

Синтаксис объявления имеет вид:

Блок объявлений переменных начинает ключевое слово var.

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

Пример объявления переменных:


var
Summa: Integer;
Divident,
Divisor: Real;
BinaryNamber: Byte;
SurmameOfAuthor: String;

Переменные можно разделить на локальные и на глобальные.


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

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

Глобальные переменные можно инициализировать в их объявлениях, т.е. задавать им начальные значения.

Пример инициализации глобальной переменной:

Локальные переменные инициализировать нельзя.

Можно создавать динамические переменные, выделяя для них место в динамически распределяемой области памяти heap (куча), с использованием процедур GetMem и New. Освобождение памяти производится процедурами FreeMem и Dispose. Можно также использовать для динамических переменных функции ReallocMem, Initialize, StrAlloc, StrDispose.

Типы данных в Object Pascal можно разделить на предопределенные (встроенные) типы данных и типы данных, определяемые пользователем.


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


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

Язык программирования Object Pascal определяет ряд типов данных, называемых стандартными типами данных. К ним относятся следующие типы: целые, действительные или вещественные, символы, строки, указатели, булевы, variant.

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

Это слово начинает раздел объявления типов, синтаксис объявления которых следующий:


type <
Когда один идентификатор типа объявлен, используем другой идентификатор типа, без определения типа, оба обозначают тот же тип >
T1=Integer;
T2=T1;
T3=Integer;
T4=T2;
type TMyString=string;
Объявление типа можно использовать для создания псевдонима встроенного типа >
type TMyInteger=type Integer; <
Для того чтобы создавать четкий тип, повторите слово type в описании >
type MyString=string[10]; <
определение переменных для введенного пользователем типа >
var
S1: MyString;
S2: MyString;

Целые типы данных.

Целые типы данных используются для представления целых чисел. Они относятся к целым порядковым типам.

Целые числа состоят только из цифр и знака «+» или «-«. Если знак опущен и число не равно 0, то оно рассматривается как положительное, например:

Ниже приведены значения, которые определены для Delphi 5.

Тип Byte, диапазон значений 0 255, размер 1 байт.

Тип Word, диапазон значений 0 65535, размер 2 байта.

Тип Longword, диапазон значений 0 4294967295, размер 4 байта

Тип ShortInt, диапазон значений -128 127, размер 1 байт.

Тип SmallInt, диапазон значений -32768 32767, размер 2 байта.

Тип Cardinal, диапазон значений 0 4294967295, размер 4 байта.

Тип Integer, диапазон значений -2147483648 2147483647, размер 4 байта.

Тип LongInt, диапазон значений -2147483648 2147483647, размер 4 байта.

Тип Int64, диапазон значений -2 63 (2 63 – 1), размер 8 байт.

Родовыми типами (т.е. обеспечивающими максимальную производительность) среди перечисленных выше являются Integer и Cardinal . В настоящий момент тип Integer эквивалентен типу LongInt, но в последующих версиях это может быть изменено.

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

Попытка увеличения значения переменной, уже имеющей максимальное для данного типа значение, приведет к циклическому переходу на минимальное значение. Это произойдет, если не включена директива проверки диапазона целочисленных значений и не установлена опция Range Checking в окне опций проекта. Иначе в процессе выполнения будет генерироваться исключение с сообщением «Range check error».

Рассмотрим пример использования целых типов в приложениях.

В данном примере объявляется четыре целые переменные Minute, Hour, Day, Year. После ключевого слова begin производится инициализация переменной Minute со значением 60, столько секунд содержится в минуте. Следующая строка вычисляет, сколько секунд содержится в часе, переменная Hour присваивается результат вычисления Minute * 60, т.е. увеличивается в 60 раз значение, хранящееся в переменной Minute. Результат помещается в переменную Hour, и так далее .

Булевы типы данных.

Переменные булевых типов данных представляют логические значения, например, true (истина) и false (ложь). Булевы типы относятся к целым порядковым типам. Ниже приведены основные булевы типы для Delphi 5 . Столь большое число одинаковых по смыслу типов связано с желанием обеспечить совместимость Delphi с другими системами. Предпочтительнее всегда использовать тип Boolean, кроме обращений к каким-нибудь процедурам, явным образом требующим другой тип.

Тип Boolean — булева величина в один байт.


Тип ByteBool — булева величина в один байт.

Тип WordBool — булева величина в одно слово.

Тип LongBool — булевая величина в два слова.

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

Рассмотрим пример использования булевых переменных.


var
Cell, Cell1: Boolean;
Result: Boolean;
begin
Cell:=True;
Cell1:=not Cell;
Result:=Cell and Cell1;
end;

В данном примере объявляется три переменные булевого типа. Переменные Cell и Cell1 объявлены вместе. Переменная Result объявлена отдельно. В первой строке после ключевого слова begin переменной Cell присвоено значение True. Во второй строке переменной Cell1 присвоено значение логически противоположное тому, которое имеет переменная Cell. Выражение not Cell значит: возьмите значение Cell и проинвертируйте его, т.е. сделайте отрицание. Следующая строка Result:=Cell and Cell1 означает: возьмите значение Cell и объедините его со значением Cell1, используя логический оператор and. Результат этого выражения присвойте значению Result.

Действительные типы данных.

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

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

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

Форма с фиксированной точкой совпадает с обычной записью чисел: 299 <точка в конце числа опущена>, 3.14

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

Тип Real 48, диапазон значений 2.9*10 –39 1.7*10 38 , число значащих разрядов 11–12, размер 6 байт.

Тип Real, диапазон значений 5.0*10 -324 1.7*10 308 , число значащих разрядов 15–16, размер 8 байт.

Тип Single, диапазон значений 1.5*10 -45 3.4*10 38 , число значащих разрядов 7–8, размер 4 байта.

Тип Double, диапазон значений 5.0*10 -324 1.7*10 308 , число значащих разрядов 15–16, размер 8 байт.

Тип Extended, диапазон значений 3.6*10 -4932 1.1*10 4392 , число значащих разрядов 19–20, размер 10 байт.

Тип Comp, диапазон значений, -2 63 2 62 , число значащих разрядов 19–20, размер 8 байт.

Тип Currency, диапазон значений -922337203685477.5808 922337203685477.5807, число значащих разрядов 19–20, размер 8 байт.

Родовым (т.е. обеспечивающим максимальную производительность) является тип Real, который в настоящий момент эквивалентен типу Double, но в последующих версиях это может быть изменено.

Наименьшую производительность обеспечивает тип Real48, сохраняемый только для обратной совместимости с более ранними версиями языка.

Рассмотрим пример использования действительных (вещественных) чисел.


const
DefaultDaily=300.00;
var
Form1: TForm1;
implementation
<$R *.DFM>
procedure TForm1.Button1Click(Sender: TObject);
var
Hour: Real;
Day, Month: Single;
Annually: Double;
begin
Day :=DefaultDaily;
Hour :=Day/8;
Month:=Day*20;
Annually:=Month*12;
end;
end.

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

Объявлены четыре переменные действительного типа Real, Single, Double.

Символьные типы данных.

Символьные типы предназначены для хранения одного символа. Они относятся к целым порядковым типам. Ниже приведены значения символьных типов данных. Наличие двух разных типов — ANSIChar и WideChar связано с двумя различными множествами символов: ANSI, каждый символ которого занимает 1 байт, и Unicode, каждый символ которого занимает 2 байта. Первые 256 символов в этих множествах одинаковы и соответствуют символам ASCII от 0 до 255.

Тип ANSIChar, размер 1 байт, хранит один символ ANSI.

Тип WideChar, размер 2 байта, один символ Unicode.

Тип Char, размер 1 байт, хранит один символ. Сейчас эквивалентен ANSIChar . В будущих версиях Delphi, может быть, будет эквивалентен WideChar .

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

Для символьного типа предопределена функция Chr, возвращающая символ любого целого значения в пределах AnsiChar или WideChar. Например, Chr (65) возвращает букву «A». Поскольку символьные типы относятся к порядковым типам, для них предопределены такие функции и процедуры, как Ord, Pred, Succ, Inc, Dec и др. Функция Ord, возвращающая номер символа, противоположна по смыслу функции Chr . Т.е. Ord (Chr(65)) вернет 65, а Chr (Ord(‘A’)) вернет символ «A».

Рассмотрим пример использования символов в приложении.

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

В программе объявлены две символьные переменные, Tetta и Etta. Переменной Tetta присвоено значение f. Переменной Etta присвоено значение F.

Тип данных строки.

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

Тип ShortString, максимальная длина 255, используется для обратной совместимости.
Тип AnsiString, максимальная длина 2 31 (2 Гб) символов ANSI .
Тип String, максимальная длина или 255, или до 2 Гб символов ANSI или Unicode .
Тип WideString, максимальная длина 2 30 (1 Гб) символов Unicode, используется в серверах COM и интерфейсах.

Родовым является тип String, который имеет разный смысл в зависимости от директивы компилятора $H. Если включена директива (она включена по умолчанию), то String интерпретируется компилятором как тип AnsiString — длинная строка с нулевым символом в конце. Если же включить директиву <$H->, то String интерпретируется компилятором как тип ShortString — короткая строка без нулевого символа в конце. Если в объявлении типа после ключевого слова String следует число символов в квадратных скобках (например, String[4]), то, независимо от директив компилятора, тип трактуется как строка без нулевого символа в конце с указанным числом символов.

Рассмотрим пример использования строк в приложении.

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

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


var
SurName,
Name,
PatronymicName: String[15];
Buffer: String [45];
begin
SurName:=’Skuratow’;
Name :=’Wladimir’;
PatronymicName:=’Petrowich’;
Buffer:=Surname + Name + PatronymicName;
end;

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

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

Поместите компонент Image со страницы Additional на форму. Центральное свойство этого компонента, которое может содержать изображение, — свойство Picture. Д ля того чтобы поместить изображение на форму, необходимо произвести двойной щелчок по компоненту Image или щелкнуть по кнопке с тремя точками справа от свойства Picture на странице Properties инспектора объекта. Откроется диалоговое окно Picture Editor, позволяющее загрузить в свойство Picture какой-нибудь графический файл. Для загрузки изображения щелкните по кнопке Load. Откроется диалоговое окно Load Picture (рисунок 1) . При перемещении по открытым графическим файлам в правом окне отображаются содержащиеся в них картинки, а над ним — цифры, характеризующие размер картинки (рисунок 2). Как видите, в Delphi 5 появилось удобное загрузочное окно, позволяющее предварительно просмотреть изображения картинок. Графические файлы в Delphi 4 расположены в каталоге Program Files \ Common Files \ Borland Shared. Графические файлы в Delphi 5 расположены в каталоге Program Files \ Common Files \ Borland \ Borland Shared. Можно использовать изображения из каталога Program Files \ Microsoft Office \ Clipart \ Popular.

Изображение после загрузки в ваше приложение сохраняется в нем. И у вас есть возможность поставлять ваше приложение без отдельно расположенного графического файла.

Вы можете создать рисунок самостоятельно, используя уже имеющиеся рисунки, например с использованием редактора Word . Редактор Word предлагает воспользоваться рисунками, которые уже созданы. Но просто вставленный рисунок может не удовлетворять вас по своему виду, цвету или по наличию или отсутствию отдельных элементов. Редактор Word предлагает вам преобразовывать рисунки к виду, которые могут быть очень далеки от их оригиналов, причем в лучшую сторону. Чтобы использовать имеющиеся рисунки, необходимо запустить текстовый редактор Word. В строке главного меню Microsoft Word выберите кнопку Вставка, щелкните по ней, из раскрывшегося меню выберите Рисунок и далее Картинки. Щелкните по команде Картинки. Раскроется диалоговое окно Microsoft Clip Gallery 3.0 (рисунок 3). Из предложенного раздела Графика выберите подраздел Хозяйство. Активизируйте, например, рисунок Часы и щелкните по кнопке Вставить. После этого рисунок Часы импортируется в ваш документ на место, указанное курсором (рисунок 4).

Ваше первое преобразование может быть сразу сведено, возможно, к уменьшению его размера. Произведите выделение рисунка: подведите курсор к значкам, выделяющим данный рисунок. И в момент превращения курсора в двойную стрелку, нажмите левую кнопку мыши и, изменяя положения мыши на коврике, измените размер вашего рисунка. На импортируемом рисунке часы показывают 7 часов 52 минуты, измените время, показываемое часами, на 9 часов. Измените положение часов в текстовом документе и цвет. Для этого подведите курсор к меню Microsoft Word, щелкните правой кнопкой мыши и из раскрывшегося меню выберите команду Рисование . Над панелью задач появится панель Рисование. Подведите маркер к рисунку Часы, и после того как он превратится в четырехстороннюю стрелку, щелкните кнопкой для выделения нашего рисунка. Не снимая выделения, нажмите кнопку Действия. В раскрывшемся меню выберите команду Разгруппировать. Данную процедуру повторите несколько раз, пока команда Разгруппировать не перестанет быть активной. Для данного рисунка необходимо 8 раз проделать данную процедуру, после чего рисунок будет разбит на отдельные составные части, с которыми вы и будете работать дальше.

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

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

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

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

Рассмотрим свойства компонента Image.

Если вы установите свойство AutoSize в True, то размер компонента Image будет автоматически подгоняться под размер помещенной картинки. Если свойство AutoSize установлено в False, то изображение может не поместиться в компонент, или наоборот, размер компонента может быть больше размера картинки.

Свойство Center указывает, нужно ли центрировать изображение в границах компонента. Игнорируется, если свойство AutoSize равно True или если свойство Stretch равно True и изображение не является пиктограммой (ICO).

Свойство Stretch позволяет подгонять не компонент под размер рисунка, а рисунок под размер компонента. Для этого установите свойство AutoSize в False, растяните или сожмите размер компонента Image и установите Stretch в True. Вы увидите, что рисунок займет всю площадь компонента, но здесь возможно искажение рисунка. Поэтому устанавливать размеры Image точно пропорционально размеру рисунка может иметь смысл только для изображений не подверженных искажениям (узоры, линии). Свойство Stretch не распространяется на пиктограммы, которые не изменяют своих размеров.

Илон Маск рекомендует:  Извлечение информации из таблиц

Свойство Transparent (прозрачность). Если свойство установлено в True, то изображение в Image становится прозрачным. Данное свойство можно использовать для наложения изображений друг на друга. Чтобы это увидеть, поместите два компонента Image на форму, загрузите в них картинки. Передвиньте компоненты друг на друга, установите для верхнего компонента Image свойство Transparent равное True. Вы увидите, верхняя картинка перестала заслонять нижнюю картинку (рисунок 6). Вы можете поэкспериментировать с данным свойством, возможно, получите оригинальные совмещенные изображения для вашего приложения.

  1. Марко Канту. Delphi 2 для Windows 95/NT. Москва. ООО «Малип». 1997 г.
  2. Джон Матчо. Дэвид Р. Фолкнер. Delphi. Москва. БИНОМ. 1995 г.
  3. Эндрю Возневич. Delphi. Освой самостоятельно. Москва. Восточная книжная компания. 1996 г.
  4. В.В.Фаронов. Delphi 5. Учебный курс. Москва. Издательство Нолидж. 2000 г.
  5. А. Я. Архангельский. Программирование в Delphi 5. Москва. ЗАО «Издательство Бином». 2000 г.

Владимир Скуратов

DelphiComponent.ru — бесплатно видеоуроки по Delphi, статьи, исходники

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

— Константин, что в переводе с греческого значит „постоянный“!

Стандартное представление главного героя

Сердце красавицы склонно к измене И к перемене, как ветер мая.

Дж. Верди. Риголетто

Константы — это параметры (объекты) программы, которые не могут из­менять своё значение в ходе выполнения программы.

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

Точно так же из любых символов мы можем составить символьные (один любой символ) и строковые константы (любое количество любых симво­лов, в том числе и ни одного). Такие константы заключаются в одинарные (не двойные!) кавычки:

’G’ ’R’ ’7’ ’Ж’ ’Э’ — символьные константы

’’ — пустая строка, в которой нет ни одного символа

’Delphi’ ’G’ ’Constant’ ’Строковая константа’ — строковые кон­станты


Строковые и символьные константы можно соединять знаком +:

’Delphi’ + ’ — ’ + ’ это наш выбор! ’

Значением этого выражения будет строка «Delphi- это наш выбор!»

’205’ ’14.007’ ’2 + 2’ — тоже строковые константы! Их значени­ями являются именно строки, а не числа, поэтому значение выражение ‘2 + 2’ вовсе не 4!

Если в строковой константе имеется одиночная кавычка, то её следует по­вторить дважды.

Кроме того, существуют логические константы True(соответствует зна­чению истина), False(ложь), а также константа nil (0, используется как значение указателей).

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

Именованные константы

Именованные константы описываются в разделе объявления констант модуля или подпрограммы. Он начинается зарезервированным словом const , за которым следуют объявления констант, состоящие из имени, зна­ка равенства и значения константы. Завершается объявление точкой с за­пятой:

Здесь значение — это константа или константное выражение.

Именованные константы получают своё значение при объявлении и потом изменить его не могут.

Константы принято описывать раньше переменных, так как в их объявле­ниях часто эти константы используются.

Разделов объявления констант и переменных может быть сколько угодно:

Вы должны были обратить внимание на то, что тип констант разный, но нигде не указан. Тогда каким же образом компилятор определяет его? — По виду константы или константного выражения! Действительные числа должны быть записаны с десятичной точкой или в научной нотации. Все остальные числа считаются целыми (десятичными и 16-ричными). Сим­вольные (один символ) и строковые (любое количество символов) кон­станты должны быть заключены в одиночные кавычки. Логические долж­ны иметь значение TRUE или FALSE .

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

Пусть нам нужно написать программу, играющую в шашки. Доска имеет 8 вертикалей и 8 горизонталей. Если эти числа использовать в исходном ко­де, то эти восьмёрки невозможно будет отличить от других восьмёрок, ко­торые тоже могут оказаться в коде. Да и вообще число 8 никак не указыва­ет на то, что это число вертикалей на шахматной доске. Пусть, несмотря на это, нам удалось написать шашечную программу. Но — аппетит приходит во время еды: мы решили взяться за 100-клеточные шашки, а там доска по­больше: 10 горизонталей и столько же вертикалей. Придётся просматри­вать (и очень внимательно!) весь код и исправлять восьмёрки на десятки.

Конечно, лучше сразу объявить две константы:

Их же следует использовать и в коде программы, тогда при переходе от русских шашек к международным достаточно будет изменить только 2 числа в самом начале программы, где их отыскать совсем нетрудно:

Надеюсь, вы даже и не подумали, что после этого программа суме­ет играть в международные шашки! Речь идёт только о размере доски, алгоритм игры изменится до неузнаваемости, но это уже ваша забота.

Переменные

Переменные — это параметры (объекты) программы, которые могут из­менять своё значение в ходе выполнения программы.

Физически переменная представляет собой область памяти (её размер за­висит от типа переменной; в этих ячейках памяти хранится значение пе­ременной), связанную с её идентификатором.

Как и все другие объекты программы, до первого использования перемен­ные должны быть объявлены. Переменные описываются в разделе объяв­ления переменных модуля или подпрограммы. Он начинается зарезерви­рованным словом var (от слова variable — переменная), за которым следуют объявления переменных.

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

Переменные одного типа можно перечислять через запятую с последую­щим указанием их общего типа.

Типом переменной может быть:

  • стандартный тип Delphi (integer, single, char. );
  • ранее определённый пользователем тип:
  • непосредственно вводимый при объявлении тип:

Хорошенько запомните: после объявления переменной её значение не определено. При выполнении программы для каждой переменной выделя­ется память, но в этих ячейках может оказаться всё что угодно, поэтому значение переменной будет меняться от одного запуска программы к дру­гому. Это может привести к ошибкам: в некоторых случаях программа бу­дет работать правильно, в других нет. Это значит, что все переменные должны быть инициализированы, то есть им должно быть присвоено ка­кое-либо значение (конечно, не при объявлении):

Никогда не используйте неинициализированные переменные!

Впрочем, Delphi следит за вами! После отладочного запуска программы проверяйте содержимое окна сообщений

В третьей строке компилятор предупреждает (такое легкомысленное от­ношение к переменным ошибкой не считается, но использовать её не сле­дует!), что вы забыли задать значение переменной s .

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

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

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

Параметры функций, процедур

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

Типы параметров процедуры и функции Delphi.

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

  1. Значения
  2. Константы
  3. Переменные
  4. Выходные параметры

Параметр — значение

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

Параметр – константа

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

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

Параметр – переменные

Если мы хотим изменить какую-либо переменную в ходе выполнения процедуры/функции Delphi, то нам нужно в объявлении, перед именем добавить ключевое слово var. Приведу пример:

Смотрите. Мы описали первую функцию MyF и, изменяя в её теле переменную i, мы будем изменять переменную, которую передали как параметр. Такой способ передачи параметра называется передачей параметра по ссылке. Сейчас все станет ясно. Для этого разберем процедуру pr. Мы задаем переменной x значение ноль, выводим его, чтобы убедиться в этом. Далее мы эту переменную передаем в функцию MyF, где в результате наш x увеличивается на единицу. Это произошло именно благодаря тому, что параметр функции MyF объявлен с ключевым словом var.

Выходные параметры

В Delphi есть тип параметра функции, который используется только для вывода значения. Объявляется такой тип при помощи директивы Out. Данная директива может использоваться только в функциях. Использование выходных параметров очень напоминает использование var, разница в том, что значение не может быть изменено подпрограммой. Выходное значение в Delphi используется для возврата дополнительных переменных из функции. Нужно это тогда, когда одной переменной Result не обойтись.

Const — Ключевое слово Delphi

Школа программирования Delphi

Портал DelphiSchool является бесплатным проектом, обеспечивающим пользователям быстрый и легкий доступ к урокам программирования на Delphi. Сайт позволяет научиться программировать на Делфи любому, кто хочеть писать свои программы, игры, Android приложения, программы для MAC OC или IOS. Кроме уроков Delphi и статей Delphi, на сайте доступны также и видеоуроки. Практически к каждому уроку, пользователю доступен исходник, изучив который, он сможет наглядно посмотреть как работает та или иная программа, написанная на Делфи. Кроме того мы постараемся прилагать к каждому материалу (статье, уроку, видеоуроку) файлы Delphi, которые будут помогать изучить предоставленный материал.

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

Const как поменять значение через Edit Delphi XE

Как сделать, чтобы параметры LAT , RUS , LengthLAT , LengthRUS , LengthNUM и MAX_NUMBER принимали значения с Edit ?

2 ответа 2

Почему именно константа, а не глобальная переменная?
Но если хочется именно константу изменять, то можно использовать директиву <$WRITEABLECONST ON/OFF>:

Посмотрите справку по этой директиве.

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

Программирование на языке Delphi. Глава 2. Основы языка Delphi. Часть 3

Оглавление


Программные модули


Структура модуля

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

После слова unit записывается имя модуля . Оно должно совпадать с именем файла, в котором находится исходный текст модуля. Например, если файл называется MathLib.pas, то модуль должен иметь имя MathLib. Заголовок модуля формируется автоматически при сохранении файла на диске, поэтому его не следует изменять вручную. Чтобы дать модулю другой заголовок, просто сохраните его на диске под другим именем.

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

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

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

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

Если модуль не нуждается в инициализации и завершении, блоки initialization и finalization можно опустить.


В качестве упражнения давайте создадим модуль и подключим его к основной программе (для этого сначала запустите среду Delphi):


    Выберите в главном меню команду File / New. , в появившемся диалоговом окне активизируйте значок с подписью Unit и щелкните на кнопке OK (рисунок 6).

Рисунок 6. Окно среды Delphi для создания нового модуля

Вы увидите, что среда Delphi создаст в редакторе кода новую страницу с текстом нового модуля Unit1 (рисунок 7):

Рисунок 7. Текст нового модуля в редакторе кода

  • Сохраните модуль под именем MathLib, выбрав в меню команду File / Save (рисунок 8):
  • Рисунок 8. Окно сохранения модуля

    Заметьте, что основная программа Console изменилась: в списке подключаемых модулей появилось имя модуля MathLib (рисунок 9). После слова in среда Delphi автоматически помещает имя файла, в котором находится модуль. Для стандартных модулей, таких как SysUtils, это не нужно, поскольку их местонахождение хорошо известно.

    Рисунок 9. Текст программы Console в окне редактора

    Теперь перейдем к содержимому модуля. Давайте объявим в нем константу Pi и две функции: Power — вычисление степени числа, и Average — вычисление среднего арифметического двух чисел:

    Вот как могла бы выглядеть программа, использующая модуль Math:

    После компиляции и запуска программы вы увидите на экране три числа (рисунок 10):

    Рисунок 10. Результат работы программы Console

    Стандартные модули языка Delphi

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

    К системным модулям относятся System, SysUtils, ShareMem, Math. В них содержатся наиболее часто используемые в программах типы данных, константы, переменные, процедуры и функции. Модуль System — это сердце среды Delphi; содержащиеся в нем подпрограммы обеспечивают работу всех остальных модулей системы. Модуль System подсоединяется автоматически к каждой программе и его не надо указывать в операторе uses .

    Модули визуальных компонентов (VCL — Visual Component Library) используются для визуальной разработки полнофункциональных GUI-приложений — приложений с графическим пользовательским интерфейсом (Graphical User Interface). Эти модули в совокупности представляют собой высокоуровневую объектно-ориентированную библиотеку со всевозможными элементами пользовательского интерфейса: кнопками, надписями, меню, панелями и т.д. Кроме того, модули этой библиотеки содержат простые и эффективные средства доступа к базам данных. Данные модули подключаются автоматически при помещении компонентов на форму, поэтому вам об этом заботиться не надо. Их список слишком велик, поэтому мы его не приводим.

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

    Исходные тексты стандартных модулей среды Delphi находятся в каталоге Delphi/Source.

    Область действия идентификаторов

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

    • каждый идентификатор должен быть описан перед тем, как он будет использован;
    • областью действия идентификатора является блок, в котором он описан;
    • все идентификаторы в блоке должны быть уникальными, т.е. не повторяться;
    • один и тот же идентификатор может быть по-разному определен в каждом отдельном блоке, при этом блоки могут быть вложенными;
    • если один и тот же идентификатор определен в нескольких вложенных блоках, то в пределах вложенного блока действует вложенное описание;
    • все глобальные описания подключенного модуля видны программе (подключающему модулю), как если бы они были сделаны в точке подключения;
    • если подключаются несколько модулей, в которых по-разному определен один и тот же идентификатор, то определение, сделанное в последнем подключенном модуле перекрывает все остальные;
    • если один и тот же идентификатор определен и в подключенном модуле, и в программе (подключающем модуле), то первый игнорируется, а используется идентификатор, определенный в программе (подключающем модуле). Доступ к идентификатору подключенного модуля возможен с помощью уточненного имени. Уточненное имя формируется из имени модуля и записанного через точку идентификатора. Например, чтобы в предыдущем примере получить доступ к стандартному значению числа ?, нужно записать System.Pi.

    Строки


    Строковые значения

    Строка — это последовательность символов. При программировании строковые значения заключаются в апострофы, например:

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

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

    Строка, которая не содержит символов, называется пустой:

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

    Строковые переменные

    Строковая переменная объявляется с помощью зарезервированного слова string или с помощью идентификатора типа данных AnsiString, например:

    Строку можно считать бесконечной, хотя на самом деле ее длина ограничена 2 ГБ. В зависимости от присваиваемого значения строка увеличивается и сокращается динамически. Это удобство обеспечивается тем, что физически строковая переменная хранит не сами символы, а адрес символов строки в области динамически распределяемой памяти (о динамически распределяемой памяти мы расскажем ниже). При создании строки всегда инициализируются пустым значением (»). Управление динамической памятью при операциях со строками выполняется автоматически с помощью стандартных библиотек языка Delphi.

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

    Символы строки индексируются от 1 до N+1, где N — реальная длина строки. Символ с индексом N+1 всегда равен нулю (#0). Для получения длины следует использовать функцию Length , а для изменения длины — процедуру SetLength (см. ниже).

    Для того чтобы в программе обратиться к отдельному символу строки, нужно сразу за идентификатором строковой переменной или константы в квадратных скобках записать его номер. Например, FriendName[1] возвращает значение ‘A’, а FriendName[4] — ‘x’. Символы, получаемые в результате индексирования строки, принадлежат типу Char.

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

    Строки в формате Unicode

    Для поддержки работы со строками формата Unicode в язык Delphi имеется строковый тип данных WideString. Работа со строками типа WideString почти не отличается от работы со строками типа AnsiString; существуют лишь два отличия.

    Первое отличие состоит в представлении символов. В строках типа WideString каждый символ кодируется не одним байтом, а двумя. Соответственно элементы строки WideString — это символы типа WideChar, тогда как элементы строки AnsiString — это символы типа AnsiChar.

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

    Короткие строки

    Короткая строка объявляется с помощью идентификатора типа ShortString или зарезервированного слова string , за которым следует заключенное в квадратные скобки значение максимально допустимой длины, например:

    Короткая строка может иметь длину от 1 до 255 символов. Предопределенный тип данных ShortString эквивалентен объявлению string [255].

    Реальная длина строки может быть меньше или равна той, что указана при ее объявлении. Например, максимальная длина строки Friend в примере выше составляет 30 символов, а ее реальная длина — 9 символов. Реальную длину строки можно узнать с помощью встроенной функции Length . Например, значение Length(Friend) будет равно 9 (количество букв в слове Alexander).

    Все символы в строке типа ShortString пронумерованы от 0 до N, где N — максимальная длина, указанная при объявлении. Символ с номером 0 — это служебный байт, в нем содержится реальная длина короткой строки. Значащие символы нумеруются от 1. Очевидно, что в памяти строка занимает на 1 байт больше, чем ее максимальная длина. Поэтому значение SizeOf(Friend) будет равно 31.

    Обратиться к отдельному символу можно так же, как и к символу обычной строки. Например, выражения FriendName[1] и FriendName[9] возвращают соответственно символы ‘A’ и ‘r’. Значения FriendName[10] .. FriendName[30] будут случайными, так как при объявлении типизированной константы FriendName символы с номерами от 10 до 30 не были инициализированы. Символы, получаемые в результате индексирования короткой строки, принадлежат типу Char.

    Поскольку существует два типа строк: обычные (длинные) строки и короткие строки, возникает закономерный вопрос, можно ли их совмещать. Да, можно! Короткие и длинные строки могут одновременно использоваться в одном выражении, поскольку компилятор языка Delphi автоматически генерирует код, преобразующий их тип. Более того, можно выполнять явные преобразования строк с помощью конструкций вида ShortString(S) и AnsiString(S).

    Операции над строками

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

    Операция сцепления (+) применяется для сцепления нескольких строк в одну строку.

    Выражение


    Результат


    ‘Object’ + ‘ Pascal’ ‘Object Pascal’

    Операции отношения (=, <>, >, =, ‘ABCDE’ True ‘Office’ = ‘Office’ True ‘USIS’ > ‘US’ True

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

    Объявление строки


    Выражение


    Значение строки


    Name: string[6]; Name := ‘Mark Twain’; ‘Mark T’

    Допускается смешение в одном выражении операндов строкового и символьного типа, например при сцеплении строки и символа.

    Строковые ресурсы

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

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

    Использование строковых ресурсов ничем не отличается от использования строковых констант:

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

    Форматы кодирования символов

    Существуют различные форматы кодирования символов. Отдельный символ строки может быть представлен в памяти одним байтом (стандарт Ansi), двумя байтам (стандарт Unicode) и даже четырьмя байтами (стандарт UCS-4 — Unicode). Строка «Wirth» (фамилия автора языка Pascal — прародителя языка Delphi) будет представлена в указанных форматах следующим образом (рисунок 11):

    Рисунок 11. Форматы кодирования символов

    Существует также формат кодирования MBCS (Multibyte Character Set), согласно которому символы одной строки кодируются разным количеством байт (одним или двумя байтами в зависимости от алфавита). Например, буквы латинского алфавита кодируются одним байтом, а иероглифы японского алфавита — двумя. При этом латинские буквы и японские иероглифы могут встречаться в одной и той же строке.

    Стандартные процедуры и функции для работы со строками

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

    • Concat (S1, S2, . , Sn): string — возвращает строку, полученную в результате сцепления строк S1, S2, . Sn. По своей работе функция Concat аналогична операции сцепления (+).
    • Copy (S: string, Index, Count: Integer): string — выделяет из строки S подстроку длиной Count символов, начиная с позиции Index.
    • Delete (var S: string, Index, Count: Integer) — удаляет Count символов из строки S, начиная с позиции Index.
    • Insert (Source: string; var S: string, Index: Integer) — вставляет строку Source в строку S, начиная с позиции Index.
    • Length (S: string): Integer — возвращает реальную длину строки S в символах.
    • SetLength (var S: string; NewLength: Integer) — устанавливает для строки S новую длину NewLength.


    Выражение


    Значение S


    S := Concat(‘Object ‘, ‘Pascal’);‘Object Pascal’S:= Copy(‘Debugger’, 3, 3);‘bug’S := ‘Compile’; Delete(S, 1, 3);‘pile’S := ‘Faction’; Insert(‘r’, S, 2)‘Fraction’

    • Pos (Substr, S: string): Byte — обнаруживает первое появление подстроки Substr в строке S. Возвращает номер той позиции, где находится первый символ подстроки Substr. Если в S подстроки Substr не найдено, результат равен 0.

    Выражение


    Результат


    Pos(‘rat’, ‘grated’)2Pos(‘sh’, ‘champagne’)

    • Str (X [: Width [: Decimals] ], var S: string) — преобразует числовое значение величины X в строку S. Необязательные параметры Width и Decimals являются целочисленными выражениями. Значение Width задает ширину поля результирующей строки. Значение Decimals используется с вещественными числами и задает количество символов в дробной части.

    Выражение


    Значение S


    Str(-200, S);‘-200’Str(200 : 4, S);‘ 200’Str(1.5E+02 : 4, S);‘ 150’

    • Val (S: string, var V; var Code: Integer) — преобразует строку S в величину целого или вещественного типа и помещает результат в переменную V. Если во время операции преобразования ошибки не обнаружено, значение переменной Code равно нулю; если ошибка обнаружена (строка содержит недопустимые символы), Code содержит номер позиции первого ошибочного символа, а значение V не определено.

    Выражение


    Значение V


    Значение Code


    Val(‘100’, V, Code); 100 Val(‘2.5E+01’, V, Code); 25.0 Val(‘2.5A+01’, V, Code); 4

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

    • AdjustLineBreaks (const S: string): string — возвращает копию строки S, в которой все мягкие переносы строк (одиночные символы #13 или #10) заменены жесткими переносами строк (последовательность символов #13#10).
    • AnsiCompareStr (const S1, S2: string): Integer — сравнивает две строки, делая различие между заглавными и строчными буквами; учитывает местный язык. Возвращаемое значение меньше нуля, если S1 S2.
    • AnsiCompareText (const S1, S2: string): Integer — сравнивает две строки, не делая различий между заглавными и строчными буквами; учитывает местный язык. Возвращаемое значение меньше нуля, если S1 S2.
    • AnsiDequotedStr (const S: string; Quote: Char): string — удаляет специальный символ, заданный параметром Quote, из начала и конца строки и заменяет парные спецсимволы на одиночные; если специальный символ отсутствует в начале или конце строки, то функция возвращает исходную строку без изменений.
    • AnsiExtractQuotedStr (var Src: PChar; Quote: Char): string — делает то же, что и функция AnsiDequotedStr, но результат возвращается вместо исходной строки, которая имеет тип PChar.
    • AnsiLowerCase (const S: string): string — преобразует заглавные буквы строки S к строчным буквам с учетом местного языка.
    • AnsiPos (const Substr, S: string): Integer — выполняет те же действия, что и функция Pos, но в отличие от нее поддерживает работу с многобайтовой MBCS-кодировкой.
    • AnsiQuotedStr (const S: string; Quote: Char): string — преобразует строку, заменяя все вхождения специального символа, заданного параметром Quote, на парные спецсимволы, а также помещает специальный символ в начало и конец строки. Поддерживает работу с MBCS-кодировкой.
    • AnsiSameCaption (const Text1, Text2: string): Boolean — сравнивает две строки, не делая различие между заглавными и строчными буквами, а также не учитывая символ ‘&’; учитывает местный язык.
    • AnsiSameStr (const S1, S2: string): Boolean — сравнивает строки, делая различие между строчными и заглавными буквами; учитывает местный язык.
    • AnsiSameText (const S1, S2: string): Boolean — сравнивает строки, не делая различие между строчными и заглавными буквами; учитывает местный язык.
    • AnsiUpperCase (const S: string): string — преобразует все строчные буквы в заглавные; учитывает местный язык.
    • CompareStr (const S1, S2: string): Integer — выполняет сравнение двух строк, делая различие между строчными и заглавными буквами; не учитывает местный язык. Возвращаемое значение меньше нуля, если S1 S2.
    • CompareText (const S1, S2: string): Integer — выполняет сравнение двух строк, не делая различий между строчными и заглавными буквами; не учитывает местный язык. Возвращаемое значение меньше нуля, если S1 S2.
    • DateTimeToStr (const DateTime: TDateTime): string — преобразует значение даты и времени в строку.
    • DateTimeToString (var Result: string; const Format: string; DateTime: TDateTime) — преобразует значение даты и времени в строку, выполняя при этом форматирование в соответствии со значением строки Format. Управляющие символы строки Format подробно описаны в справочнике по среде Delphi.
    • DateToStr (const DateTime: TDateTime): string — преобразует числовое значение даты в строку.
    • Format (const Format: string; const Args: array of const): string — форматирует строку в соответствии с шаблоном Format, заменяя управляющие символы шаблона на значения элементов открытого массива Args. Управляющие символы подробно описаны в справочнике по среде Delphi.
    • FormatDateTime (const Format: string; DateTime: TDateTime): string — преобразует значение даты и времени в строку, выполняя при этом форматирование в соответствии со значением строки Format. Управляющие символы строки Format подробно описаны в справочнике по среде Delphi.
    • BoolToStr (B: Boolean; UseBoolStrs: Boolean = False): string — преобразует булевское значение в строку. Если параметр UseBoolStrs имеет значение False, то результатом работы функции является одно из значений ‘0’ или ‘-1’. Если же параметр UseBoolStrs имеет значение True, то результатом работы является одно из значений ‘FALSE’ или ‘TRUE’ (программист может задать другие значения; о том, как это сделать, читайте в справочнике по системе Delphi).
    • IntToHex (Value: Integer; Digits: Integer): string — возвращает шестнадцатиричное представление целого числа Value. Параметр Digits задает количество цифр результирующей строки.
    • IntToStr (Value: Integer): string — преобразует целое число Value в строку.
    • IsDelimiter (const Delimiters, S: string; Index: Integer): Boolean — проверяет, является ли символ S[Index] одним из символов строки Delimiters. Функция поддерживает работу с многобайтовой MBCS-кодировкой.
    • IsValidIdent (const Ident: string): Boolean — возвращает True, если строка Ident является правильным идентификатором языка Delphi.
    • LastDelimiter (const Delimiters, S: string): Integer — возвращает индекс последнего вхождения одного из символов строки Delimiters в строку S.
    • LowerCase (const S: string): string — преобразует все заглавные буквы строки S к строчным; не учитывает местный язык (в преобразовании участвуют лишь символы в диапазоне от ‘A’ до ‘Z’).
    • QuotedStr (const S: string): string — преобразует исходную строку в строку, взятую в одиночные кавычки; внутри строки символы кавычки дублируются.
    • SameText (const S1, S2: string): Boolean — сравнивает строки, не делая различие между строчными и заглавными буквами; учитывает местный язык.
    • SetString (var S: string; Buffer: PChar; Len: Integer) — копирует строку с типом PChar в строку с типом string. Длина копируемой строки задается параметром Len.
    • StringOfChar (Ch: Char; Count: Integer): string — возвращает строку, в которой повторяется один и тот же символ. Количество повторений задается параметром Count.
    • StringToGUID (const S: string): TGUID — преобразует строковое представление глобального уникального идентификатора в стандартный тип TGUID.
    • StrToBool (const S: string): Boolean — преобразует строку в булевское значение.
    • StrToBoolDef (const S: string; const Default: Boolean): Boolean — преобразует строку в булевское значение. В случае невозможности преобразования, функция возвращает значение, переданное через параметр Default.
    • StrToDate (const S: string): TDateTime — преобразует строку со значением даты в числовой формат даты и времени.
    • StrToDateDef (const S: string; const Default: TDateTime): TDateTime — преобразует строку со значением даты в числовой формат даты и времени. В случае невозможности преобразования, функция возвращает значение, переданное через параметр Default.
    • StrToDateTime (const S: string): TDateTime — преобразует строку в числовое значение даты и времени.
    • StrToDateTimeDef (const S: string; const Default: TDateTime): TDateTime — преобразует строку в числовое значение даты и времени. В случае невозможности преобразования, функция возвращает значение, переданное через параметр Default.
    • StrToInt (const S: string): Integer — преобразует строку в целое число. Если строка не может быть преобразована в целое число, функция генерирует исключительную ситуацию класса EConvertError (обработка исключительных ситуаций рассматривается в главе 4).
    • StrToIntDef (const S: string; Default: Integer): Integer — преобразует строку в целое число. Если строка не может быть преобразована в целое число, функция возвращает значение, заданное параметром Default.
    • StrToInt64 (const S: string): Int64 — 64-битный аналог функции StrToInt — преобразует строку в 64-битное целое число. Если строка не может быть преобразована в 64-битное число, функция генерирует исключительную ситуацию класса EConvertError (обработка исключительных ситуаций рассматривается в главе 4).
    • StrToInt64Def (const S: string; const Default: Int64): Int64 — 64-битный аналог функции StrToIntDef — преобразует строку в 64-битное целое число. Если строка не может быть преобразована в 64-битное число, функция возвращает значение, заданное параметром Default.
    • StrToTime (const S: string): TDateTime — преобразует строку в числовой формат времени. Если строка не может быть преобразована в числовой формат времени, функция генерирует исключительную ситуацию класса EConvertError (обработка исключительных ситуаций рассматривается в главе 4).
    • StrToTimeDef (const S: string; const Default: TDateTime): TDateTime — преобразует строку в числовой формат времени. В случае ошибки преобразования, функция возвращает значение, заданное параметром Default.
    • TimeToStr (Time: TDateTime): string — преобразует числовое значение времени в строку.
    • Trim (const S: string): string — возвращает часть строки S без лидирующих и завершающих пробелов и управляющих символов.
    • Trim (const S: WideString): WideString — Unicode-аналог функции Trim — возвращает часть строки S без лидирующих и завершающих пробелов и управляющих символов.
    • TrimLeft (const S: string): string — возвращает часть строки S без лидирующих пробелов и управляющих символов.
    • TrimLeft const S: WideString): WideString — Unicode-аналог функции TrimLeft — возвращает часть строки S без лидирующих пробелов и управляющих символов.
    • TrimRight (const S: string): string — возвращает часть строки S без завершающих пробелов и управляющих символов.
    • TrimRight (const S: WideString): WideString — Unicode-аналог функции TrimRight — возвращает часть строки S без завершающих пробелов и управляющих символов.
    • UpperCase (const S: string): string — преобразует все строчные буквы строки S в заглавные; не учитывает местный язык (в преобразовании участвуют лишь символы в диапазоне от ‘a’ до ‘z’).
    • WideFormat (const Format: WideString; const Args: array of const): WideString — Unicode-аналог функции Format, учитывающий символы местного языка, — форматирует строку в соответствии с шаблоном Format, заменяя управляющие символы в шаблоне на значения элементов открытого массива Args. Управляющие символы подробно описаны в справочнике по системе Delphi.
    • WideFmtStr (var Result: WideString; const Format: WideString; const Args: array of const) — аналог функции WideFormat. Отличие в том, что WideFmtStr возвращает результат через параметр Result, а не как значение функции.
    • WideLowerCase const S: WideString): WideString — Unicode-аналог функции LowerCase (учитывает местный язык) — преобразует все заглавные буквы строки S к строчным буквам.
    • WideSameCaption (const Text1, Text2: WideString): Boolean — Unicode-аналог функции AnsiSameCaption — сравнивает две строки, не делая различие между строчными и заглавными буквами, а также не учитывая символ ‘&’; учитывает местный язык.
    • WideSameStr (const S1, S2: WideString): Boolean — Unicode-аналог стандартной операции сравнения строк — сравнивает две строки, делая различие между строчными и заглавными буквами.
    • WideSameText (const S1, S2: WideString): Boolean — Unicode-аналог функции SameText (учитывает местный язык) — сравнивает строки, не делая различие между строчными и заглавными буквами.
    • WideUpperCase (const S: WideString): WideString — Unicode-аналог функции UpperCase (учитывает местный язык) — преобразует все строчные буквы строки S в заглавные.
    • WrapText (const Line: string; MaxCol: Integer = 45): string — разбивает текст Line на строки, вставляя символы переноса строки. Максимальная длина отдельной строки задается параметром MaxCol.
    • WrapText (const Line, BreakStr: string; const BreakChars: TSysCharSet; MaxCol: Integer): string — более мощный аналог предыдущей функции — разбивает текст Line на строки, вставляя символы переноса строки.
    • AnsiToUtf8 (const S: string): UTF8String — перекодирует строку в формат UTF8.
    • PUCS4Chars (const S: UCS4String): PUCS4Char — возвращает указатель на первый символ строки формата UCS-4 для работы со строкой, как с последовательностью символов, заканчивающейся символом с кодом нуль.
    • StringToWideChar (const Source: string; Dest: PWideChar; DestSize: Integer): PWideChar — преобразует стандартную строку к последовательности Unicode-символов, завершающейся символом с кодом нуль.
    • UCS4StringToWideString (const S: UCS4String): WideString — преобразует строку формата UCS-4 к строке формата Unicode.
    • Utf8Decode (const S: UTF8String): WideString — преобразует строку формата UTF-8 к строке формата Unicode.
    • Utf8Encode (const WS: WideString): UTF8String — преобразует строку формата Unicode к строке формата UTF-8.
    • Utf8ToAnsi (const S: UTF8String): string — преобразует строку формата UTF-8 к стандратной строке.
    • WideCharLenToString (Source: PWideChar; SourceLen: Integer): string — преобразует строку формата Unicode к стандартной строке. Длина исходной строки задается параметром SourceLen.
    • WideCharLenToStrVar (Source: PWideChar; SourceLen: Integer; var Dest: string) — аналог предыдущей функции — преобразует строку формата Unicode к стандартной строке. Длина исходной строки задается параметром SourceLen, а результат возвращается через параметр Dest.
    • WideCharToString (Source: PWideChar): string — преобразует последовательность Unicode-символов, завершающуюся символом с кодом нуль, к стандартной строке.
    • WideCharToStrVar (Source: PWideChar; var Dest: string) — аналог предыдущей функции — преобразует последовательность Unicode-символов, завершающуюся символом с кодом нуль, к стандартной строке. Результат возвращается через параметр Dest.
    • WideStringToUCS4String (const S: WideString): UCS4String — преобразует строку формата Unicode к строке формата UCS-4.

    Массивы


    Объявление массива

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

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

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

    Массив может быть определен и без описания типа:

    Чтобы получить доступ к отдельному элементу массива, нужно в квадратных скобках указать его индекс, например

    Объявленные выше массивы являются одномерными, так как имеют только один индекс. Одномерные массивы обычно используются для представления линейной последовательности элементов. Если при описании массива задано два индекса, массив называется двумерным , если n индексов — n-мерным . Двумерные массивы используются для представления таблицы, а n-мерные — для представления пространств. Вот пример объявления таблицы, состоящей из 5 колонок и 20 строк:

    То же самое можно записать в более компактном виде:

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

    или в более компактной записи

    Эти два способа индексации эквивалентны.

    Работа с массивами

    Массивы в целом участвуют только в операциях присваивания. При этом все элементы одного массива копируются в другой. Например, если объявлены два массива A и B,

    то допустим следующий оператор:

    Оба массива-операнда в левой и правой части оператора присваивания должны быть не просто идентичны по структуре, а описаны с одним и тем же типом, иначе компилятор сообщит об ошибке. Именно поэтому все массивы рекомендуется описывать в секции type .

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

    Для массивов определены две встроенные функции — Low и High. Они получают в качестве своего аргумента имя массива. Функция Low возвращает нижнюю, а High — верхнюю границу этого массива. Например, Low(A) вернет значение 1, а High(A) — 5. Функции Low и High чаще всего используются для указания начального и конечного значений в операторе цикла for . Поэтому вычисление суммы элементов массива A лучше переписать так:

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

    требуются два вложенных цикла for и две целые переменные Col и Row для параметров этих циклов:

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

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

    Функция Average принимает в качестве параметра массив известной размерности. Требование фиксированного размера для массива-параметра часто является чрезмерно сдерживающим фактором. Процедура для нахождения среднего значения должна быть способна работать с массивами произвольной длины. Для этой цели в язык Delphi введены открытые массивы-параметры. Такие массивы были заимствованы разработчиками языка Delphi из языка Modula-2. Открытый массив-параметр описывается с помощью словосочетания array of , при этом границы массива опускаются:

    Внутри подпрограммы Average нижняя граница открытого массива A равна нулю (Low(A) = 0), а вот значение верхней границы (High(A)) неизвестно и выясняется только на этапе выполнения программы.

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

    Вот пример использования функции Average:

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

    И еще одно важное замечание по поводу открытых массивов. Некоторые библиотечные подпрограммы языка Delphi принимают параметры типа array of const — открытые массивы констант . Массив, передаваемый в качестве такого параметра, обязательно конструируется в момент вызова подпрограммы и может состоять из элементов различных типов (!). Физически он состоит из записей типа TVarRec , кодирующих тип и значение элементов массива (записи рассматриваются ниже). Открытый массив констант позволяет эмулировать подпрограммы с переменным количеством разнотипных параметров и используется, например, в функции Format для форматирования строки (см. выше).

    Уплотнение структурных данных в памяти

    С целью экономии памяти, занимаемой массивами и другими структурными данными, вы можете предварять описание типа зарезервированным словом packed , например:

    Ключевое слово packed указывает компилятору, что элементы структурного типа должны храниться плотно прижатыми друг к другу, даже если это замедляет к ним доступ. Если структурный тип данных описан без ключевого слова packed , компилятор выравнивает его элементы на 2- и 4-байтовых границах, чтобы ускорить к ним доступ.

    Заметим, что ключевое слово packed применимо к любому структурному типу данных, т.е. массиву, множеству, записи, файлу, классу, ссылке на класс.

    Множества


    Объявление множества

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

    Для описания множественного типа используется словосочетание set of , после которого записывается базовый тип множества:

    Теперь можно объявить переменную множественного типа:

    Можно объявить множество и без предварительного описания типа:

    В выражениях значения элементов множества указываются в квадратных скобках: [2, 3, 5, 7], [1..9], [‘A’, ‘B’, ‘C’]. Если множество не имеет элементов, оно называется пустым и обозначается как [ ]. Пример инициализации множеств:

    Количество элементов множества называется мощностью . Мощность множества в языке Delphi не может превышать 256.

    Операции над множествами

    При работе с множествами допускается использование операций отношения (=, <>, >=, in .

    Операции сравнения (=, <>). Два множества считаются равными, если они состоят из одних и тех же элементов. Порядок следования элементов в сравниваемых множествах значения не имеет. Два множества A и B считаются не равными, если они отличаются по мощности или по значению хотя бы одного элемента.

    Выражение


    Результат


    [1, 2] <> [1, 2, 3] True [1, 2] = [1, 2, 2] True [1, 2, 3] = [3, 2, 1] True [1, 2, 3] = [1..3] True

    Операции принадлежности (>=, = B равно True, если все элементы множества B содержатся в множестве A. Выражение A = [1, 2] True [1, 2] in . Используется для проверки принадлежности элемента указанному множеству. Обычно применяется в условных операторах.

    Выражение


    Результат


    5 in [1..9] True 5 in [1..4, 6..9] False

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

    можно заменить более коротким:

    Операцию in иногда пытаются записать с отрицанием: X not in S. Такая запись является ошибочной, так как две операции следуют подряд. Правильная запись имеет вид: not (X in S).

    Объединение множеств (+) . Объединением двух множеств является третье множество, содержащее элементы обоих множеств.

    Выражение


    Результат


    [ ] + [1, 2] [1, 2] [1, 2] + [2, 3, 4] [1, 2, 3, 4]

    Пересечение множеств (*) . Пересечение двух множеств — это третье множество, которое содержит элементы, входящие одновременно в оба множества.


    Выражение


    Результат


    [ ] * [1, 2] [ ] [1, 2] * [2, 3, 4] [2]

    Разность множеств (-) . Разностью двух множеств является третье множество, которое содержит элементы первого множества, не входящие во второе множество.

    Выражение


    Результат


    [1, 2, 3] — [2, 3] [1] [1, 2, 3] — [ ] [1, 2, 3]

    В язык Delphi введены две стандартные процедуры Include и Exclude, которые предназначены для работы с множествами.

    Процедура Include (S, I) включает в множество S элемент I. Она дублирует операцию + (плюс) с той лишь разницей, что при каждом обращении включает только один элемент и делает это более эффективно.

    Процедура Exclude (S, I) исключает из множества S элемент I. Она дублирует операцию — (минус) с той лишь разницей, что при каждом обращении исключает только один элемент и делает это более эффективно.

    Выражение


    Результат


    S := [1, 3]; [1, 3] Include(S, 2); [1, 2, 3] Exclude(S, 3) [1, 2]

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

    Записи


    Объявление записи

    Запись — это составной тип данных, состоящий из фиксированного числа элементов одного или нескольких типов. Описание типа записи начинается словом record и заканчивается словом end . Между ними заключен список элементов, называемых полями , с указанием идентификаторов полей и типа каждого поля:

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

    Чтобы получить в программе реальную запись, нужно создать переменную соответствующего типа:

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

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

    Обращение к полям записи имеет несколько громоздкий вид, что особенно неудобно при использовании мнемонических идентификаторов длиной более 5 символов. Для решения этой проблемы в языке Delphi предназначен оператор with, который имеет формат:

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

    Допускается применение оператора присваивания и к записям в целом, если они имеют один и тот же тип. Например,

    После выполнения этого оператора значения полей записи Friend станут равными значениям соответствующих полей записи BestFriend.

    Записи с вариантами

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

    Вариантная часть напоминает условный оператор case . Между словами case и of записывается особое поле записи — поле признака . Оно определяет, какой из вариантов в данный момент будет активизирован. Поле признака должно быть равно одному из расположенных следом значений. Каждому значению сопоставляется вариант записи. Он заключается в круглые скобки и отделяется от своего значения двоеточием. Пример описания записи с вариантами:

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

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

    Работа с файлами в Delphi: классика Pascal. Работа с типизированными файлами в Delphi

    Удивительно, но факт — запрос «delphi файлы» в Яндексе — это один из самых популярных запросов, касающихся Delphi. Популярнее только «delphi скачать» — видимо ещё не все слышали про такую штуку как Delphi Community Edition. Раз есть в Сети запрос — должен быть и ответ. Посмотрим, что получится в итоге.

    Содержание статьи

    Классика работы с файлами в Delphi — ключевое слово File

    Этот способ, без преувеличения, можно назвать древнейшим способом работы с файлами в Pascal/Delphi. Однако и он до сих пор используется в работе, особенно, если это, например, лабораторная работа по информатике в школе или ВУЗе.

    Для определения файловой переменной в Delphi/Pascal используется ключевое слово File. При этом, мы можем определить как типизированный файл, так и не типизированный, например:

    Для типизированного фала мы можем задать тип данных фиксированного размера (ShortString, String[20], Integer, Single и так далее), например, мы можем определить такие типизированные файлы:

    Или, как в примере выше использовать для указания типа запись (record), в которой все поля имеют фиксированный размер. Для типизированного файла нельзя указывать типы данных, размер которых не фиксирован, например, вот такие определения файловых переменных недопустимы:

    Более того, даже компилятор Delphi укажет вам на ошибку, сообщив следующее:

    Определив файловую переменную можно приступать к работе с файлом. Алгоритм работы при этом будет следующим:

    1. Ассоциировать файловую переменную с файлом на диске
    2. Открыть файл
    3. Записать/Прочитать файл
    4. Закрыть файл

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

    Работа с типизированными файлами в Delphi

    Рассмотрим несколько примеров работы с типизированными файлами в Delphi.
    Для начала, рассмотрим вариант работы с типизированным файлом, например, представленном выше:

    Пример №1. Запись данных в типизированный файл Delphi

    Запишем в наш файл две записи:

    Рассмотрим методы, используемые в этом примере:

    Связывает файловую переменную F с внешним файлом FileName. В качестве второго параметра может задаваться как абсолютный путь к файлу, например, ‘C:/MyFile.txt‘, так и относительный, например, в коде выше файл будет создан рядом с exe-файлом.

    Создает новый файл и открывает его. Если внешний файл с таким именем уже существует, он удаляется и на его месте создается новый пустой файл. Если F уже открыт, он сначала закрывается, а затем воссоздается. Текущая позиция файла устанавливается в начале пустого файла.
    F — это переменная, связанная с внешним файлом с использованием AssignFile. RecSize — это необязательное выражение, которое можно указывать, только если F является нетипизированным файлом (об этом ниже).

    Используется для записи в типизированный файл. F — файловая переменная, P1..PN — это переменная того же типа, что и тип файла F.

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

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

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

    Пример №2. Добавление записей в типизированный файл Delphi

    Рассмотрим такой пример Delphi:

    Разберемся с тем, что здесь делается. Во-первых, условие:

    проверяет, существует ли файл на диске. Метод FileExist имеет следующее описание:

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

    Таким образом, в нашем примере, если файла нет на диске то он создается пустым. Далее выполняется цикл:

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

    Здесь, в принципе, весь алгоритм расписан в комментариях к процедуре.
    Метод Reset не воссоздает файл снова, как Rewrite, а открывает его для чтения/записи (в случае двоичных файлов). Что касается метода Seek, то он имеет следующее описание:

    F — файловая переменная, ассоциированная с файлом на диске, N — номер записи в файле (первый номер — 0). Чтобы переместиться сразу в конец файла, мы сделали такой вызов:

    где FileSize — это метод Delphi имеющий следующее описание:

    В случае использования типизированных файлов эта функция возвращает количество записей в файле.

    После того, как пользователь вводит что-то кроме 1 срабатывает метод ReadTypedFile — чтение всех записей из файла:

    Здесь мы, опять же, открываем файл методом Reset и в цикле while..do проходим по всем записям файла, пока не дойдем до конца. Здесь мы использовали два новых метода Delphi:

    Eof возвращает True, если текущая позиция файла находится за последним символом файла или файл пуст. В противном случае Eof возвращает False.
    По аналогии с методом Write, метод Read производит чтение очередной записи из файла и имеет следующее описание:

    Результат работы нашего примера может быть следующим:

    Ещё одним полезным методом для работы с типизированными файлами может быть процедура Truncate:

    Удаляет все записи после текущей позиции файла. Вызовите Truncate в коде Delphi, чтобы текущая позиция файла стала концом файла (Eof (F) вернет true).
    Рассмотрим пример использования этой процедуры.

    Пример №3. Удаление последних записей типизированного файла в Delphi

    Воспользуемся файлом, созданным в предыдущем примере и удалим из него две последние записи:

    В этом примере мы делаем следующее:

    1. Открываем файл существующий AssignFile/Reset
    2. Определяем количество записей в файле (Count:=FileSize(TypedFile))
    3. Если количество записей меньше двух, то спрашиваем у пользователя стереть ли все записи и, в случае положительного ответа, вызываем метод Tuncate
    4. Если количество записей в файле больше двух, то смещаемся на нужную нам позицию в файле (Seek(TypedFile, Count-2)) и затираем две последние записи методом Truncate.


    Подведем итог

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

    1. Определить тип записей в файле — это могут быть стандартные типы данных Delphi с фиксированным размером: ShortString, integer, single и так далее или собственные типы данных, например, записи (record), но, в этом случае, главное условие — размер записи должен быть фиксированным.
    2. В коде Delphi/Pascal определить файловую переменную, используя ключевое слово fileи, указав тип записей файла, определенный в пункте 1.
    3. Ассоциировать файловую переменную с внешним файлом на диске, используя метод AssignFile.
    4. Открыть файл для чтения/записи, используя методы Rewrite/Reset.
    5. Чтобы сделать в файл очередную запись используем метод Write, для чтения очередной записи из файла — используем метод Read.
    6. Закрыть файл методом CloseFile.

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

    Функции и процедуры для работы с типизированными файлами в Delphi/Pascal

    Рибята куда надо писать const в delphi 7

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

    type
    TForm1 = class(TForm)
    RadioButton1: TRadioButton;
    RadioButton2: TRadioButton;
    Label1: TLabel;
    Edit1: TEdit;
    Button1: TButton;
    Label3: TLabel;
    procedure RadioButton1Click(Sender: TObject);
    procedure RadioButton2Click(Sender: TObject);

    procedure Edit1KeyPress(Sender: TObject; var Key:Char);

    procedure Button1Click(Sender: TObject);
    procedure Label1Click(Sender: TObject);
    procedure Edit1Change(Sender: TObject);
    private
    < Private declarations >
    public
    < Public declarations >
    end;

    var
    Form1: TForm1;

    // Вычисление тока, напряжения или сопротивления
    procedure Calculate;
    var
    I,U,R: real; // ток, напряжение, сопротивление
    begin
    if Form1.RadioButton1.Checked then
    // ток
    begin
    U := StrToFloat(Form1.Edit1.Text);
    R := StrToFloat(Form1.Edit2.Text);
    if (R <> 0) then
    begin
    I := U/R;
    Form1.Label3.Caption := ‘Ток: ‘ + FloatToStrF(I,ffFixed,4,2) + ‘ А’;
    end
    else ShowMessage(‘Сопротивление не должно быть равно нулю.’);
    exit;
    end;

    if Form1.RadioButton2.Checked then
    // напряжение
    begin
    I := StrToFloat(Form1.Edit1.Text);
    R := StrToFloat(Form1.Edit2.Text);
    U := I*R;
    Form1.Label3.Caption := ‘Напряжение: ‘ + FloatToStrF(U,ffFixed,4,2) + ‘ В’;
    exit;
    end;

    if Form1.RadioButton3.Checked then
    // сопротивление
    begin
    U := StrToFloat(Form1.Edit1.Text);
    I := StrToFloat(Form1.Edit2.Text);
    if (I <> 0) then
    begin
    R := U/I;
    Form1.Label3.Caption := ‘Сопротивление: ‘ + FloatToStrF(R,ffFixed,4,2) + ‘ Ом’;
    end
    else ShowMessage(‘Ток не должен быть равен нулю.’);
    end;

    // Выбор переключателя Ток
    procedure TForm1.RadioButton1Click(Sender: TObject);
    begin
    Label1.Caption := ‘Напряжение (вольт)’;
    Label2.Caption := ‘Сопротивление (Ом)’;
    Label3.Caption := »;
    end;

    // Выбор переключателя Напряжение
    procedure TForm1.RadioButton2Click(Sender: TObject);
    begin
    Label1.Caption := ‘Ток (ампер)’;
    Label2.Caption := ‘Сопротивление (Ом)’;
    Label3.Caption := »;
    end;

    // Выбор переключателя Сопротивление
    procedure TForm1.RadioButton3Click(Sender: TObject);
    begin
    Label1.Caption := ‘Напряжение (вольт)’;
    Label2.Caption := ‘Ток (ампер)’;
    Label3.Caption := »;
    end;

    // Нажатие клавиши в поле Edit1
    procedure TForm1.Edit1KeyPress(Sender: TObject; var Key:Char);
    begin
    case Key of
    ‘0’..’9′,#8: ; // цифры и
    #13: Edit2.SetFocus; // клавиша
    ‘.’,’,’:
    begin
    if Key = ‘.’
    then Key := ‘,’;
    // не позволяет вводить знак запятой повторно
    if Pos(‘,’,Edit1.Text) <> 0
    then Key := Chr(0);
    end;
    else Key := Chr(0);
    end;
    end;

    // Нажатие клавиши в поле Edit2
    procedure TForm1.Edit2KeyPress(Sender: TObject; var Key:Char);
    begin
    case Key of
    ‘0’..’9′,#8: ;
    #13: Calculate; // клавиша — вычислить
    ‘.’,’,’:
    begin
    if Key = ‘.’
    then Key := ‘,’;
    // не позволяет вводить знак запятой повторно
    if Pos(‘,’,Edit2.Text) <> 0
    then Key := Chr(0);
    end;
    else Key := Chr(0);
    end;
    end;

    // Щелчок на кнопке Вычислить
    procedure TForm1.Button1Click(Sender: TObject);
    begin
    if (Edit1.Text <> ») and (Edit2.Text <> »)
    then Calculate // вычислить ток, напряжение или сопротивление
    else ShowMessage(‘Надо ввести исходные данные в оба поля’);
    end;

    procedure TForm1.Label1Click(Sender: TObject);
    begin

    procedure TForm1.Edit1Change(Sender: TObject);
    begin

    Enums vs Const vs Class Const в программировании Delphi

    У меня есть целочисленное поле в ClientDataSet, и мне нужно сравнить с некоторыми значениями, что-то вроде этого:

    Я могу использовать const

    или класс const

    Мне нравится подход класса const, но кажется, что это не путь delphi, поэтому я хочу знать, что вы думаете

    Я бы не сказал, что класс consts не является способом Delphi. Это просто они были введены в Delphi совсем недавно, и многие книги и статьи, которые вы найдете в Интернете, были написаны до их введения, и поэтому вы не увидите их широко используемыми. Многие разработчики Delphi (я бы сказал, большинство) начнут использовать Delphi, прежде чем они станут доступны, и, следовательно, они не являются первым, о чем думают.

    Литой, как правило, был мой последний выбор.

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

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

    Чтобы использовать немного ответа Джима МакКета — если вам нужно отобразить пользователю текстовую версию, или если вам нужно преобразовать выделенный текст в нумерованный тип, тогда массив будет полезен в сочетании с Тип:

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

    Продолжая. у вас может быть программа рассеяния, чтобы установить поле combo/list:

    В коде: SetList (Combo1.Items) или SetList (ListBox1.Items)..

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

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

    так много вариантов!:-) Я предпочитаю перечисления и регулярно использую их, как вы описываете. одна из частей, которые мне нравятся, заключается в том, что я могу использовать их с циклом «для». Я также использую константы класса, но предпочитаю перечисления (даже частные перечисления) в зависимости от того, чего я пытаюсь достичь.

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

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

    Сравнимые значения float в операциях if() и while() должны сравниваться со значениями одного и того же типа данных, поэтому лучше всего определить временную или глобальную переменную типа float, используемую для любых операторов сравнения (= ).

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

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

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

    К сожалению, Delphi не разрешает формат перечисления, как. TController: Integer = (NoController = 0, ncpod = 1, nextwave = 2);

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

    или разрешить константу класса использовать в качестве параметра по умолчанию в вызове типа. function getControllerName (Контроллер: TController = TController.NoController): string;

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

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

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

    Const — Ключевое слово Delphi

    В Delphi существует следующие виды констант:

    • неименованные
    • именованные
      • нетипизированные
      • типизированные
    • зарезервированные

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

    • любая последовательность цифр (возможно, предваряемая знаком «-» или «+» или разбиваемая одной точкой) воспринимается компилятором как число (целое или вещественное);
    • любая последовательность символов, заключенная в апострофы, воспринимается как строка;
    • любая последовательность целых чисел либо символов через запятую, обрамленная квадратными скобками, воспринимается как множество.

    Пример использования неименованных констант:

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

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

    Примеры типизированных констант:

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

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

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

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

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

    Возможностью изменения значения типизированной константы можно управлять с помощью настроек проекта: Project – Options… – Delphi Compiler – Compiling – Syntax options – Assignable typed constants. Кроме того эту опцию дублирует директива компилятора <$WRITEABLECONST ON>(или ее более краткий аналог <$J+>). По умолчанию эта возможность отключена – <$J->.

    Пример изменения значения типизированной константы в runtime:

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

    Типизированные константы обладают еще одним интересным свойством – будучи объявленной членом класса она будет общей для всех объектов этого класса (в отличие от переменной, значение которой будет “своим” для каждого объекта.

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

    • True (тип Boolean);
    • False (тип Boolean);
    • MaxInt (тип Integer);
    • MaxLongint (тип Integer).

    Использование этих констант может таить в себе опасность, если вы работаете с чужим кодом. Связано это с тем, что эти константы можно переопределить. Помните старый прикол?

    Так вот, тоже самое можно сделать и в Delphi.

    Будьте бдительны! Удачи в программировании!

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