Общая характеристика языка

Размещено на http://www.allbest.ru/

Общая характеристика языка

Синтаксис языка

Основные синтаксические правила записи программ на языке Object Pascal сводятся к следующему:

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

· Прописные и строчные буквы идентичны.

· При записи идентификаторов могут использоваться латинские буквы, цифры, символ подчеркивания "_". Идентификатор не может начинаться с цифры и не может содержать пробелов. Длина идентификатора не ограничена, но воспринимается не более 255 первых символов идентификатора.

· При ссылках на идентичные идентификаторы, описанные в разных местах, например, в разных модулях или в разных объектах, используется нотация с точкой, в которой сначала перечисляются идентификаторы объектов, разделенные символами точки. Например, Unit2.A, или, Form2.Label1.Caption.

· Каждое предложение языка кончается символом точка с запятой (;). Точку с запятой можно не ставить перед ключевым словом end.

· В строке может размещаться несколько операторов. Надо выделять объединенные смыслом операторы в группы, широко используя для этого отступы и комментарии.

· Комментарии в тексте заключаются в фигурные скобки: {текст комментария}. Вместо фигурных скобок можно использовать символы круглых скобок с символами звездочки "*": (* текст комментария *). Комментарии, заключенные в фигурные скобки или в круглые скобки со звездочками, могут вводится в любом месте текста, в частности, внутри операторов, и занимать любое количество строк. Текст комментария в фигурных скобках не может начинаться с символа доллара, поскольку сочетание символов {$ воспринимается как начало директивы компилятора. Еще один способ введения комментария - размещение его после двух символов "слеш" ("//"). Этот комментарий должен занимать конец строки, в котором он введен, и не может переходить на следующую строку. Любой текст в строке, помещенный после символов "//" воспринимается как комментарий.

· Операторные скобки begin…end выделяют составной оператор. Все операторы, помещенные между ключевыми словами begin и end воспринимаются синтаксически как один оператор.

· Программа или отдельный модуль завершаются оператором "end." (ключевое слово end с символом точки).

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

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

объявления

begin

операторы

end;

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

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

Таблица, определяющая область видимости элемента:

Если элемент объявлен…	Его область видимости простирается…
в головном файле программы, в функции или процедуре	от точки объявления до конца текущего блока, включая все вложенные в него блоки
в разделе interface модуля	от точки объявления до конца данного модуля, а также во всех модулях, которые с помощью предложения uses используют данный модуль
в разделе implementation модуля, но не в блоке какой-то функции или процедуры	от точки объявления до конца раздела implementation, включая все расположенные в этом разделе функции и процедуры
в определении записи, т.е. является именем поля записи	от точки объявления до конца определений типов полей
в определении класса, т.е. является свойством или методом	от точки объявления до конца определения класса, а также в классах - наследниках и в блоках всех методов данного класса и его наследников

Константы и константные выражения

Константы и константные выражения могут использоваться непосредственно в тексте программы в любых операторах и выражениях. Константы (именованные константы) могут объявляться с помощью ключевого слова const. Это слово начинает раздел объявления констант. После него может следовать ряд объявлений констант в форме:

<идентификатор константы> = <константное выражение>;

Имеются также определенные константы: true - истина, false - ложь, nil - нулевой указатель.

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

Abs Addr ArcTan Chr Cos Exp	Frac Hi High Int Length Ln	Lo Low Odd Ord Pi Pred	Round Sin SizeOf Sqr Sqrt Succ	Swap Trunc

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

100

'A'

Sin(35*180/Pi)

'Мой файл'+' '+'Mf.txt'

Chr(32)

Ord('Z')-Ord('A')+1

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

Const NMax=55;

Pi2=2*Pi; {удвоенное число Пи}

Kd=Pi/180; {коэффециент пересчета градусов в радианы}

Name='Алексей';

Константы, являющиеся целыми числами, обычно записываются в десятичной форме Например, 7, 22,-5. Могут использоваться также константы в шестнадцатеричной форме. В этом случае константа начинается с символа "$", после которого записывается до 8 шестнадцатеричных цифр. Диапазон значений шестнадцатеричных констант от $00000000 до $FFFFFFFF.

Константы, являющиеся действительными числами, могут записываться в десятичном виде с точкой, отделяющей целую часть от дробной, или с указанием порядка, после символа "е". Например, 6.2 (6,2), 7е5 (7*10⁵), -3.1е-4 (-3,1*10^-4).

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

Const MyFile='Имя моего файла ''Mf.txt'' ' {Имя моего файла 'Mf.txt'}

Еще один вид констант - строки ресурсов. Они включаются в проект с помощью ключевого слова resourcestring вместо const. Например:

resourcestring

LineTooLong='Строка слишком длинная';

Переменные

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

Объявление переменной имеет вид:

var <список идентификаторов переменных> : <тип>;

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

var I: integer;

X, Y, Z: Double;

Digit: 0..9;

Okay: Boolean;

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

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

<идентификатор переменной>:<тип>=<константное выражение>;

Пример инициализации переменных:

var I:integer=7;

Deg:double=35*180/Pi;

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

Var CrtMode: Byte absolute $0040

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

В приложениях с несколькими параллельно выполняемыми потеплений могут быть определены переменные, локализуемые в потоках (thread-local или thread). Они подобны глобальным переменным, но каждый поток или нить (thread) получает свою копию такой переменной, не доступную другим нитям. Объявление переменной, локализуемой в потоке, осуществляется с помощью ключевого слова threadvar. Например:

threadvar X: Integer;

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

В приложениях с несколькими параллельно выполняемыми потеплений могут быть определены переменные, локализуемые в потоках (thread-local или thread). Они подобны глобальным переменным, но каждый поток или нить (thread) получает свою копию такой переменной, не доступную другим нитям. Объявление переменной, локализуемой в потоке, осуществляется с помощью ключевого слова threadvar. Например:

threadvar X: Integer;

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

Типизированные константы

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

Типизированная константа объявляется выражением:

Const <идентификатор>:<тип>=<константное выражение>;

Например:

Const In: integer=7;Angl:double=35*Pi/180

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

Типы данных

Классификация типов данных, объявление типов

Типы данных можно разделить на предопределенные в языке (встроенные) типы и типы, определяемые пользователем. К предопределенным относятся типы целые, действительные, символы, строки, указатели, булевы, variant.

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

синтаксический программа язык константа

<идентификатор типа>=<описание типа>;

Пример. Объявление

var Mode : (mRead,mEdit,mWrite);

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

type TMode : (mRead, mEdit,mWrite);

var Mode1,Mode2 : TMode;

задают имя нового типа - TMode и определяют две переменные введенного пользователем типа - Mode1 и Mode2.

Объявление типа можно использовать и для создания псевдонима встроенного типа. Например, объявление

Type TMyString = string;

Создает тип TMyString, являющийся псевдонимом встроенного типа строк string.

Приведение типов

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

A:=I;

A:A+I;

Но недопустим оператор

I:A+I;

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

Явное приведение типов осуществляется программистом с помощью следующей конструкции:

<идентификатор типа>(<выражение>)

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

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

Явное приведение типа переменной может использоваться и в правой, и в левой частях оператора присваивания. Например, могут быть записаны такие операторы (предполагается, что переменная Ch имеет тип Char, а I -- Integer):

Ch :=Char(I)

Shortint(Ch) :=I;

Эти два оператора дают один и тот же результат. Например, если I = 122 (код символа "z"), то значение переменной Ch в результате выполнения любого из этих операторов станет равно символу "z".

Явное приведение типа значения некоторого выражения осуществляется после его вычисления. Например, в операторе

Ch :=Char(I-1);

cначала вычисляется выражение в скобках, а потом производится приведение результата к типу Char.

Порядковые типы данных

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

Функция	Параметр	Возвращаемое значение	Замечания
Ord	Выражение порядкового типа	Порядковый номер значения данного выражения	Не воспринимает аргумент типа Int64
Pred	Выражение порядкового типа	Величина, предшествующая значению данного выражения	Нельзя использовать в свойствах, имеющих процедуру Write
Succ	Выражение порядкового типа	Величина, следующая для значения данного выражения	Нельзя использовать в свойствах, имеющих процедуру Write
High	Идентификатор порядкового типа или переменная порядкового типа	Максимально возможное значение	Используется также для типов коротких строк и массивов ''
Low	Идентификатор порядкового типа или переменная порядкового типа	Минимально возможное значение	Используется также для типов коротких строк и массивов

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

Inc(I)

эквивалентен оператору

I :=Succ(I);

а оператор

Dec(I);

эквивалентен оператору

I :=Pred(I);

Если I -- целая переменная, то приведенные операторы эквивалентны соответственно

I :=I+1;

и

I :=I-1;

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

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

Тип	Диапазон значений	Требования к памяти в байтах	Знаковый (может ли хранить отрицательные числа)
Byte	0255	1	нет
Word	065535	2	нет
Longword	04294967295	4	нет
ShortInt	-128127	1	да
SmallInt	-3276832767	2	да
Cardinal	04294967295	4	нет
Integer	-2147483648 2147483647	4	да
LongInt	-2147483648 2147483647	4	да
Int64	-263 263 -1	8	да

Арифметические операции над целыми числами возвращают тип Integer. Только если оба операнда имеют тип Int64, результат тоже имеет тип Int64.

Большинство стандартных процедур и функций, работающих с целыми аргументами, усекают аргументы типа Int64 до 4 байтов. Исключение составляют функции High, Low, Succ, Pred, Inc, Dec, IntToHex, полностью поддерживающие аргументы типа Int64. Функции Round, Trunc, StrToInt64, StrToInt64Def также возвращают результат типа Int64. Функция Ord к Int64 применяться не может.

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

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

Тип	Диапазон значений	Число значащих разрядов	Требования к памяти в байтах
Real48		11-12	6
Real		15-16	8
Single		7-8	4
Double		15-16	8
Extended		19-20	10
Comp		19-20	8
Currency		19-20	8

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

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

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

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

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

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

Переменные булевых типов данных представляют логические значения, например, true (истина) и false (ложь). Булевы типы относятся к целым порядковым типам.

Тип	Значения	Требования к памяти в байтах
Boolean	Булева величина в один байт	1
ByteBool	Булева величина в один байт	1
WordBool	Булева величина в одно слово	2
LongBool	Булевская величина в два слова	4

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

Тип Boolean	Типы ByteBool, WordBool, LongBool
false < true	false<>true
Ord(false)=0	Ord(false)=0
Ord(true)=1	Ord(true)<>0
Succ(false)=true	Succ(false)=true
Pred(true)=false	Pred(true)=true

Для булевых типов определены операции and (И), or (ИЛИ), not (НЕ, отрицание) и xor (исключающее ИЛИ). Использование этих операций расширяет возможности по формированию сложных условий в ряде операторов.

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

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



Тип	Размер в байтах	Что может хранить
ANSIChar	1	Один символ ANSI
ANSIChar	2	Один символ Unicode
Char	1	Эквивалентен ANSIChar

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

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

Типы строк

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

Тип строки	Максимальная длина	Используется для	Нулевой символ в конце
ShortString	255	обратной совместимости	нет
AnsiString	~231 (~2 Гб)	символов ANSI	Есть
String	или 255, или до ~2 Гб	символов ANSI или Unicode	Есть или нет
WideString	~230 (~1 Гб)	символов Unicode, в серверах COM и интерфейсах	есть

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

Стандартная функция Length возвращает число символов в строке, переданной ей в качестве параметра. Процедура SetLength устанавливает длину строки.

Для строк определены операции сравнения >, <, = и т.п. Если сравниваются строки разной длины, то большей считается более длинная строка. Если сравниваются строки одинаковой длины, то принимаются в расчет символы в одинаковых позициях -- сравниваются коды этих символов.

Со строками можно оперировать как с индексированными массивами символов. Например, S[i] -- это символ, расположенный в строке в позиции i (индексы отсчитываются от 1, т.е. индекс 1 соответствует первому символу). Для строк типа ShortString или AnsiSting выражение S[i] имеет тип AnsiChar, для строк типа WideString - WideChar.

Сцепление (конкатенация) строк осуществляется операцией "+". Например, выражение S1+S2 даст в результате строку, в которой после символов строки S1 будут расположены символы строки S2.

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

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

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

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

Теперь остановимся на использовании в строках нулевого конечного символа. В настоящее время тип ShortString поддерживается только для обеспечения обратной совместимости с более ранними версиями языка. А основным типом строк становятся строки с нулевым символом в конце. Строки с нулевым символом в конце представляют собой массивы символов с индексами, начинающимися с 0. В массиве хранятся символы строки и в конце нулевой символ (#0), указывающий на окончание строки. Таким образом, тип строки с нулевым символом в конце может, например, объявляться как AnsiString, а может объявляться как статический массив символов, например:

Type

TS = array[0..15] of Char;

Если значение переменной строки с нулевым символом в конце инициализируется при ее объявлении, то после значащих символов остальные элементы массива надо инициализировать символами #0. Например:

Const SHello: array[0..7] of Char = `Привет!'#0;

Этого не надо делать в операторах присваивания. Например:

SHello := `Привет!';

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

const SHello: AnsiString = `Привет!';

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

Var P: PChar;

…

P:='Привет!';

Это эквивалентно операторам

Const SHello: array[0..7] of char = `Привет!'#0;

Var P: PChar;

…

P :=@SHello;

но, конечно, гораздо короче.

Совместимость указателей типов PChar и PWideChar со строковыми константами позволяет в вызовах функций и процедур с параметрами соответствующих типов использовать просто строки символов. Например, если некоторая процедура F требует параметр типа PChar, то обратиться к ней можно так:

Var P: PChar;

…

P:='Привет!';

F(P);

Или

F(`Привет!');

Указатели типов PChar и PWideChar могут индексироваться точно так же, как строки и массивы символов. Например, Р[0] -- это первый символ строки, на которую указывает Р.

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

S := string(P1)+string(P2);

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

Var s: string;

…

S:=StrLower(PChar(Edit1.Text));

Свойство Text окна редактирования Edit имеет тип string, а функция StrLower преобразования текста к нижнему регистру требует параметр типа PChar. Поэтому в вызове функции необходимо явное приведение типа. В то же время преобразование возвращаемого функцией StrLower значения типа Pchar к типу string переменной s производится автоматически.

Перечислимые типы

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

Переменная перечисленного типа может определяться предложением вида:

var <имя переменной> : (<значение 1>, …, <значение n>);

Например

Var Mode : (mRead, mEdit, mWrite);

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

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

type <имя типа>=(<значение 1>, …, <значение n>);

Тогда можно ввести в программе несколько переменных этого типа. Например:

Type TMode =: (mRead, mEdit, mWrite);

Var Mode1, Mode2 : TMode;

Ограниченные типы

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

<минимальное значение>..<максимальное значение>

Например:

Var Letter: 'a'..'z';

Num : 1..12;

Type Caps = 'A'..'z';

В этих примерах переменная Letter может принимать только символы латинских букв в нижнем регистре, переменная Num -- только целые числа в диапазоне 112 (это могут быть, например, номера месяцев), переменные, чей тип будет объявлен как Caps будут принимать только символы латинских букв в верхнем регистре.

При использовании в объявлении ограниченного типа константных выражений (см. раздел 12.5.1) возможны некоторые ошибки компилятора. Например, объявления

const X=100;

Y=200;

type Scale = (X+Y) div 2..Y;

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

const X=100;

Y=200;

type Scale = 1*(X+Y) div 2..Y;

Множества

Множество -- это группа элементов, которая ассоциируется с ее именем и с которой можно сравнивать другие величины, чтобы определить, принадлежат ли они этому множеству. Один и тот же элемент не может входить в множество более одного раза. Как частный случай, множество может быть пустым. Множество определяется перечислением его элементов, заключенным в прямоугольные скобки. Такая форма определения называется конструктором множества. Например, если множество возможных единичных символов, которые могут быть получены в ответ на вопрос программы "Yes/No", содержит символы "y", "Y", "n" и "N", то это множество можно описать таким конструктором: ['y', 'Y, 'n', 'N']. Для определения, принадлежит ли переменная множеству, служит операция in. В предыдущем примере проверить, дал ли пользователь один из допустимых ответов, можно оператором:

If (Key in ['y', 'Y, 'n', 'N'])

Then <оператор, выполняемый при допустимом ответе>

Множества могут содержать не только отдельные значения, но и ограниченные типы. Например, если вы хотите контролировать символы, вводимые пользователем при вводе целого положительного или отрицательного числа, вы можете определить множество ['0'..'9','+','-'] и использовать его, например, при обработке события OnKeyPress какого-то окна редактирования:

In not (Key in ['0'..'9','+','-']) then Key:=#0;

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

set of <базовый тип>

Приведем примеры.

Объявление глобальной переменной с инициализацией:

Var K: set of Char=['0'..'9','+','-'];

...

If (Key in K) then ...

Объявление типизированной константы:

const K: set of Char=['0'..'9','+','-'];

Объявление типа множества и переменных этого типа:

Type TDigit=set of '0'..'9';

Var D1,D2: TDigit;

D1:=['0','1'];

D2:=['2'..'9'];

Помимо операции in для множеств определен еще ряд операций: объединение, пересечение, операции отношения и ряд других.

Тип Variant

В переменных типа variant могут хранился данные любых типов, кроме записей, множеств, статических массивов, файлов, классов, ссылок на классы, указателей и Int64. Иначе говоря, переменные типа Variant могут хранить все, кроме структур, указателей и Int64. Они могут также хранить объекты СОМ и СОRВА, обеспечивая доступ к их методам и свойствам. Могут они также хранить динамические массивы и специальные массивы variant.

Например, если определить тип переменной V как variant, то могут выполняться такие операторы:

V: variant; // bPV V не определен (xB>DR Unassigned)

…

V:=5; // тип V становится равным integer

…

V:=le10; // тип V становится равным real

…

V:=Edit1.Text; // тип V становится равным string

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

Переменные типа variant занимают 16 битов и содержат код типа и значение переменной или указатель на это значение. В момент создания эти переменные инициализируются специальным значением Unassigned. Значение переменной null свидетельствует о неизвестном или ошибочном значении переменной.

Переменные типа variant могут использоваться в выражениях как операнды любых операций, кроме ^, is и in, совместно с другими величинами типов variant, integer, real, string, Boolean. Компилятор в этих случаях автоматически осуществляет приведение типов величин в выражении. Если оба операнда операции имеют тип variant и один или оба операнда равны null, то результат операции тоже равен null. Если один или оба операнда имеют значение Unassigned, то генерируется исключение. Если в бинарной операции только один из операндов имеет тип variant, то другой тоже преобразуется в тип variant.

Приведение типов при вычислении выражений, содержащих операнды variant, осуществляется обычным образом. Например, если V1 и V2 типа variant содержат данные типов integer и real, то выражение V1+V2 вернет значение real. Узнать действительный тип значение переменной variant можно с помощью функции VarType, возвращающей значение типа TVarData, содержащее код типа. Запись TVarData определена в модуле System. Имеется также предопределенная константа varTypeMask, сложение которой по операции end с переменной типа TVarData возвращает истинный тип переменной. Например, выражение

VarType(V) and varTypeMask = varDouble;

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



varEmpty	Переменная в состоянии Unassigned
varNull	Значение переменной равно null
VarSmallint	Тип Smallint
varInteger	Тип Integer
varSingle	Тип Single
varDouble	Тип Double
varCurrency	Тип Currency
varDate	Тип Date (дата и время)
varOLEStr	Ссылка на динамически размещенную строку UNICODE
varDispatch	Ссылка на автоматический объект (указатель на интерфейс IDispatch)
varError	Код ошибки операционной системы
varBoolean	Тип WordBool
varUnknown	Ссылка на неизвестный объект COM (указатель на интерфейс IUnknown)
varByte	Тип Byte
varString	Ссылка на динамически размещенную строку в стиле Pascal (тип AnsiString)
varTypeMask	Битовая маска для извлечения кода типа
varArray	Бит, устанавливаемый при ссылке на массив variant
varByRef	Бит, устанавливаемый при ссылке на тип variant

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

Function VarArrayCreate (const Bounds: array of integer;

VarType: Integer):Variant;

Здесь параметр Bounds является массивом, содержащим четное количество целых чисел, каждая пара которых определяет нижнее и верхнее значения индекса массива (точнее, размерности массива, если массив многомерный). Параметр VarType определяет тип элементов массива. Он может принимать значения, приведенные выше в таблице, кроме varString, varArray, varByRef. Например, операторы

var V: variant;

...

V:=VarArrayCreate ([0,9],varInteger);

создают в переменной V типа variant массив из десяти целых чисел. Операторы

var A: variant;

...

A:=VarArrayCreate ([0,3],varVariant);

A[0] :=1;

A[1] :=1234.5678;

A[2] :='Привет!';

A[3] :=True;

Label1.Caption :=A[0];

Label2.Caption :=A[1];

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

Функция VarArrayOf определена следующим образом:

Function VarArrayOf (const Values: array of Variant): Variant;

Она возвращает одномерный массив элементов, задаваемых параметром Values. Например, приведенный выше пример можно дополнить операторами

A[3] :=VarArrayOf ([1, `привет!', 100, 1000]);

Label3.Caption:=A[3] [1];

Указатель является величиной, указывающей на некоторый адрес в памяти, где хранятся какие-то данные. Указатели бывают типизированные, указывающие на данные определенного типа, и нетипизированные (типа pointer), которые могут указывать на данные произвольного типа. Чаще всего указатели используются для работы с объектами в динамически распределяемой области памяти, особенно при работе с записями.

Ряд предопределенных типов указателей. Это прежде всего типы указателей на строки: PAnsiChar и PWideChar, представляющие собой соответственно указатели на значения AnsiChar и WideChar . Имеется также родовой тип PChar, определяющий указатель на Char (т.е. пока указывающий на AnsiChar). Эти указатели используются при работе со строками с нулевым символом в конце.

Тип указателя	Тип переменной, на которую указывает указатель
PAnsiString, PString	AnsiSting
PByteArray	ByteArray (объявлен в модуле SysUtils). Используется для доступа к динамически размещаемым массивам
PCurrency	Currency
PExtended	Extended
POleVariant	OleVariant
PShortString	ShortString
PTextBuf	TextBuf (объявлен в модуле SysUtils). Внутренний тип буфера в записи файлов TTextRec
PVarRec	TVarRec (объявлен в модуле System)
PVariant	Variant
PWideString	WideString
PWordArray	TWordArray (объявлен в модуле SysUtils). Используется для доступа к динамически размещаемым массивам 2-байтных величин

Объявление своего типизированного указателя на любой тип имеет вид:

type <имя указателя> = ^<тип данных>;

Например, предложения:

type Print =^integer;

var P1,P2: Print;

объявляют тип Print указателя на величину типа integer и две переменные P1 и P2, являющиеся указателями на значения типа integer. Однако, надо понимать, что объявление переменных Р1 и Р2 не создает самих величин, на которые они указывают. Выделяется только память под хранение указателей, но сами эти указатели ни на что не указывают. Имеется предопределенная константа nil, которая обычно присваивается указателям, которые в данный момент ни на что не указывают. Чтобы получить доступ к данным, на которые указывает типизированный указатель, надо применить операцию его разыменования. Она записывается с помощью символа ^, помещаемого после указателя. Например, если переменная P1 является указателем приведенного выше типа Print, то выражение P1^ - это та целая величина, на которую указывает указатель Р1. Если I -- переменная целого типа, то после выполнения оператора

P1^ := I;

Р1 начнет указывать на переменную I и выражение P1^ будет возвращать значение этой переменной. Того же результата можно добиться операцией адресации. Например, приведенный выше оператор можно заменить эквивалентным оператором

P1 :=@I;

Этот оператор присваивает указателю P1 адрес переменной I.

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

New (P1);

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

Операция разыменования не применима к указателям типа pointer. Чтобы разыменовать указатель pointer, надо сначала привести его к другому типу указателя. Например, если указатель Р объявлен как указатель типа pointer, то выражение PInt(P) приведет его тип к объявленному выше типу Print, после чего его можно будет разыменовывать. Таким образом, с помощью приведения типа можно записать такие операторы:

PInt(P) :=P1;

I :=PInt(P)^+P2^;

Указатели широко используются в Object Pascal и Delphi, причем часто неявно для пользователя. Например, передача параметров по ссылке в процедуры и функции осуществляется именно через указатели.

Пример программы



Код:

unit Unit1;

interface

uses

Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,

Dialogs, StdCtrls;

type

TForm1 = class(TForm)

Label1: TLabel;

Label2: TLabel;

Label3: TLabel;

Label4: TLabel;

Label5: TLabel;

Edit1: TEdit;

Edit2: TEdit;

Button1: TButton;

Label6: TLabel;

Label7: TLabel;

Label8: TLabel;

Label9: TLabel;

procedure Button1Click(Sender: TObject);

private

{ Private declarations }

public

{ Public declarations }

end;

var

Form1: TForm1;

implementation

{$R *.dfm}

procedure TForm1.Button1Click(Sender: TObject);

const

Pi2=2*Pi; //объявление константы удвоенное Пи

var

R, //радиус

H, //высота

S, //площадь

V : real; //масса

begin

//получаем исходные данные

R :=StrToFloat(Edit1.Text);

H :=StrToFloat(Edit2.Text);

//расчет

S :=Pi2*R*(R+H); //Площадь поверхности цилиндра

V :=Pi*(R*R)*H; //Объем цилиндра

//результат

Label6.Caption := format('%f кв.м', [S]);

Label7.caption := format('%f куб.м', [V]);

end;

end.

Размещено на Allbest.ru