Классификация типов данных в Турбо Паскале

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

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

Var

a: byte; {занимает 1 байт}

b: integer; {занимает 2 байт}

c: Real; {занимает 6 байт}

a b c

Типы данных, как уже говорилось, бывают стандартные и нестандартные.

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

Type

имя = определение типа;

Type

M = record

a, b: byte:

end;

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

Var

имя1: описание нестандартного типа;

имя2: тип;

Например:

Var

v1: array [1..10] of char;

v2: byte;

Переменная v1 относится к тому типу, который вы определили при объявлении переменной, v2 - стандартный тип (но v1 не будет совместим никакой другой тип).

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

Const

N = 2; целого типа

C = 'c'; символьного типа

D = 1.28; вещественный тип

E = $AD; целого типа

F = 'abcd'; строкового типа

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

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

Const

N: byte = 2;

C: char = 'c';

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

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

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

6.4.1 Понятие порядкового типа

Порядковый тип описывает конечное и упорядоченное множество значений, для каждого элемента которого однозначно определяется предыдущий и следующий за ним элементы. В частности, последовательность целых чисел является порядковым типом данных. Например, для элемента 5 существует единственное следующее значение (6) и единственное предыдущее значение (4). Символы алфавита также представляют собой порядковый тип данных. Например, в латинском алфавите для символа " M" следующим является символ " N", а предыдущим - символ " L".В то же время вещественные числа нельзя отнести к порядковому типу. Например, для числа 15.8 существует бесконечное множество следующих и предыдущих значений (15.81, 15.801, 15.8001 и т.д.).

Упорядоченное множество значений переменной порядкового типа однозначно отображается на последовательность порядковых номеров 0, 1, 2, .... Исключение сделано только для целых чисел, которые отображаются сами на себя.

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

К любому порядковому типу применимы следующие три стандартные в Паскале функции: ORD(X), PRED(X), SUCC(X):

- ORD(X) в точку вызова функция возвращает порядковый (ординальный) номер значения Х среди множества значений данного порядкового типа. Всегда возвращает значение целого типа.

- PRED(X) (predecessed - предшествующий) возвращает в точку вызова значение, предшествующее в данном порядковом типе значению Х. Возвращает значение того же типа, что и тип аргумента.

- SUCC(X) (succeed - следующий) возвращает в точку вызова значение, следующее в данном порядковом типе за значением Х. Возвращает значение того же типа, что и тип аргумента.

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

Булевский (логический) тип

Логическое значение - это одно из двух значений истинности, которые обозначаются предопределенными именами false и true. Переменные этого типа занимают 1 байт, однако в Турбо Паскале версии 7.0 определены 3 логических типа: Bytebool (1 байт), Wordbool (2 байта), Longbool (4 байта) Значению “истина” в памяти при хранении значения соответствует 1, значению “ложь” – 0 (т.е. 0 и 1 – это внутреннее представление значений истина и ложь). При этом false < true.

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

x + 1 < y

при x = 0, y = 0 дает false; при x = 0, y = 10 - значение true.

Var b: boolean; - обозначение булевского типа.

Три стандартные функции для порядковых типов применимы и к этому типу:

Ord (true) = 1, Ord (false) = 0

Pred (true) = false

Succ (false) = true

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

· not

X not X

false true

true false

· and, or, xor

X	Y	X and Y	X or Y	X xor Y
false	False	false	False	false
false	True	false	True	true
true	True	true	True	false
true	False	false	True	true

Эти операции похоже на те, которые используются применительно к целым типам. Существуют отличия (особенности):

1. логические операции применимы только к логическим типам

2. логическими операциями возвращается результат логического типа.

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

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

FALSE < TRUE истина FALSE = TRUE ложь

while (логическое_выражение) do тело_цикла;

2) repeat тело_цикла until (логическое_выражение);

3) b: = логическое_выражение

4) if (логическое_выражение)

then...действие_если_истина..

else действие_если_ложь.;

Пример более сложного логического выражения:

((x + 1 < y) and not (x > 5)) or ((y > 0) and true)

Вычислим значение этого выражения при x = 5, y = 5:

((6 < 1) and not (5 > 5)) or ((5 > 0) and true) ===>

( false and not false ) or ( true and true )

( false and true ) or ( true and true )

false or true

true

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

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

· Odd(аргумент – целый) возвращает True, когда аргумент нечетный, и возвращает False, когда аргумент четный.

· Eoln(аргумент – текстовый файл) возвращает True, если текущим символом строки является символ конца строки.

· Eof(аргумент – файл) возвращает True, если текущий указатель файла установлен на конец файла.

Целые типы

Выделяют целые типы ------------- со знаком – shortint, integer, longint)

------------- без знака - byte, word.

Shortint - занимает 1 байт в памяти со знаком. Диапазон значений: от -128 до +127.

Byte - однобайтовый тип. Данные этого типа только положительные. Диапазон значений: от 0 до 255.

Integer - 2 байта со знаком. Диапазон значений: от -32768 (-2¹⁵) до +32767 (2¹⁵-1). Имеется предопределенная константа MaxInt, равная 32767 и определяющая максимальное значение целого числа типа integer.

Word - 2 байта без знака. Диапазон значений: от 0 до 65535.

Longint - занимает 4 байта со знаком. Диапазон значений: - 2 147 483 648 (-2³¹).. 2 147 483 647 (2³¹-1).

В Турбо-Паскале предопределены константы MaxLongint, равная 2 147 483 647, и MaxInt, равная 32767.

Для каждого значения этих типов нужно различать:

а) запись значения числа (в одной из систем счисления) в строковом представлении;

б) представление этого значения в виде двоичного кода

в) внутреннее представление (побайтное расположение) этого двоичного (многобайтового) кода в памяти ЭВМ

Рассмотрим пример на то, чем отличаются а) и б) для типов данных shortint и byte.

7 6 5 4 3 2 1 0 -------номера разрядов

2⁶ 2⁵2⁴ 2³ 2² 2¹2⁰--------веса разрядов

S Shortint

Знаковый разряд (не участвует в выработке значения)

7 6 5 4 3 2 1 0 -------номера разрядов

2⁷ 2⁶ 2⁵ 2⁴ 2³ 2² 2¹2⁰--------веса разрядов

Byte

старший разряд значения

Для типа shortint знак записывается в самом старшем разряде. А для типа byte этот разряд является частью значения. Поэтому для этих типов в одних тех же 8 битах одно и то же представление в двоичном коде будет соответствовать разным значениям:

Для shortint 11111111 = -1

1 1 1 1 1 1 1 1

Для byte 11111111 = +255

-1 для (shortint) получена потому, что 1 в знаковом разряде соответствует отрицательному числу. Отрицательные (и положительные тоже) числа хранятся в так называемом дополнительном коде. Он получается в 2 приема:

- абсолютное значение числа надо записать в виде двоичного кода и проинвертировать все разряды (0 → 1 1 → 0)

- далее к младшему разряду прибавляется единица. Полученное изображение и будет дополнительным кодом числа (знаковый разряд содержит 0 или 1 и говорит о знаке числа).

Рассмотрим теперь пример на то, чем в) отличается от б). Значения многобайтовых типов (Integer, Word и Longint) хранятся в памяти не так, как пишутся. Они размещаются в памяти, начиная с младших байтов.

Пусть запись целой многобайтовой константы имеет вид:

$ 12 34 - здесь 2 байта.

старший младший

байт байт

Этой записи числа в дампе памяти в отладчике будет соответствовать следующий код: 34 12

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

(совпадает с направлением просмотра)

С данными целых типов могут использоваться несколько стандартных функций и операций:

1 группа функций:

Следующие стандартные процедуры и функции могут применяться и использоваться с аргументами целых типов (x, y – целое число) и возвращают целое или порядкового типа значение:

x DIV y – целочисленное деление

x MOD y – остаток от целочисленного деления

Abs(x) – функция, возвращает значение модуля числа (абсолютного значения) в точку вызова

Chr(x) – функция, возвращает символ с кодом, равным значению аргумента

Dec(x) – процедура, выполняет уменьшение аргумента на единицу или на заданное значение

Inc(x) - процедура, увеличивает аргумент на единицу или на заданное вторым аргументом значение

Lo(x) – функция, возвращает в точку вызова значение младшего байта Low(x)

Hi(x) - функция, возвращает в точку вызова значение старшего байта High(x)

Swap(x) - функция, выполняет следующее действие над двухбайтовыми аргументами: меняет местами старший и младший байты

Замечание: для Lo(x), Hi(x) и Swap(x) аргумент может быть или типа Word или Integer

Odd(x) -функция, возвращает в точку вызова логическое значение “истина”, если значение аргумента нечетно, или “ложь”, если значение аргумента четно

Random(x) – функция, возвращает в точку вызова случайное число из диапазона от 0 до значения аргумента (само значение аргумента не включается в этот диапазон).

Sqr(x) функция, возведение аргумента в квадрат

(для сравнения: Sqrt (x) функция для извлечение квадратного корня из вещественного аргумента, возвращает вещественный результат )

2 группа функций:

Следующие функции всегда возвращают вещественное значение при целочисленных аргументах:

Sin (x), Cos (x), Arctan (x), Ln (x), Exp(x)

3 группа функций:

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

Round(x) – функция, округляет вещественное значение до ближайшего большего целого и возвращает его в точку вызова (Round(1.2)=1, Round(1.5)=2, Round(1.9)=2).

Trunc(x) – функция, отсекает дробную часть и возвращает результат в точку вызова. Есть функции, делающие обратное:

Frac(x) – функция, отбрасывает целую часть и возвращает в точку вызова дробную

Int(x) - функция, возвращает для вещественного аргумента целое число, являющееся округлением аргумента до ближайшего меньшего (в сторону 0) целого.

Например, Int(1.45) = 1

Int(1.9) = 1

Int(-1.9) = -2

trunc(1.45) = 1

trunc(1.9) = 1

trunc(-1.9) = -1

Замечание по поводу функций и процедур: процедура и функция отличаются формой вызова.

Пример:

Var

y: integer;

begin

x: -10;

Dec(x); //Вызов процедуры Dec с фактическим параметром х

randomize; //Процедура без параметров. Вызывать надо перед random, чтобы инициализировать

// датчик случайных чисел

y: =random(x); //Вызов функции Random с фактическим параметром х

Операция в языках программирования – это элементарное действие, вырабатывающее некоторое значение (результат операции). По числу операндов операции делятся на одноместные и двухместные. По типу операндов и результата операции делятся: 1) арифметические (операнды – числа, результат – число); 2) логические (операнды – логические, результат – логический); 3) отношения (операнды – произвольные, результат – логический).

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

x = y

x > y

x < y

x < > y

x > = y

x < = y

Арифметические операции, которые могут применяться с использованием данных целых типов:

div - операция целочисленного деления (без остатка)

mod - остаток от целочисленного деления

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

- если оба операнда у первых 3 операций - целого типа, то будет получен результат целого типа.

- если хотя бы один из операндов у первых 3 операций - вещественного типа, то результат получится вещественного типа.

- операция деления всегда возвращает вещественный результат (несмотря на тип операндов).

К данным целого типа применимы также поразрядные операции. Они выполняются над каждой парой одноименных разрядов операндов. Рассмотрим правила выполнения поразрядных операций над одним из разрядов (например, с номером i):

*	x₁	x₂	x₃	…	x_i-1	x_i	…	x_n-1	x_n
y₁	y₂	y₃	…	y_i-1	y_i	…	y_n-1	y_n
	z₁	z₂	z₃	…	z_i-1	z_i	…	z_n-1	z_n

Обобщенное обозначение поразрядной операции:

z_i = x_i * y_i

Поразрядное “НЕ” (одноместная операция)

X_i	not X_i

1

Поразрядное “И” или поразрядное умножение (двухместная операция)

X_i	Y_i	X_i and Y_i

Поразрядное “ИЛИ” или поразрядное сложение (двухместная операция)

X_i	Y_i	X_i or Y_i

Поразрядное “ИСКЛЮЧАЮЩЕЕ ИЛИ”. Эта операция устанавливает результат, равным единице, при несовпадении соответствующих разрядов (двухместная операция):

X_i	Y_i	X_i xor Y_i

Поразрядный сдвиг вправо и влево достигается применением операций (двухместных):

X Shl Y - значение X сдвигается влево на Y разрядов

X shr Y - значение X сдвигается вправо на Y разрядов.

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

При сдвиге вправо мысленная правая граница (где заканчивается целая часть числа) перемещается влево;

При сдвиге влево мысленная левая граница (за самым старшим разрядом) перемещается вправо.

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

Нулями всегда заполняются разряды, добавляемые при сдвиге влево или вправо целых положительных чисел. При этом сдвиг влево на N разрядов эквивалентен умножению на 2^N, а сдвиг вправо на N разрядов равносилен целочисленному делению (без остатка) на 2^N.

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

При сдвиге этих же чисел влевознаковый разряд замещается тем значением, которое придет справа. Но так происходит лишь если выключена опция компилятора Range Checking (Options – Compiler – Generated code – Range Checking). Если же она включена, то при попытке изменить знаковый разряд получим сообщение о выходе за границы диапазона (Range check error).

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

1) выделение нужного фрагмента двоичного кода

2) очистка (установка в ноль) нужного фрагмента двоичного кода

3) проверка (равен 0 или 1) разрядов нужного фрагмента двоичного кода

4) инвертирование нужного фрагмента двоичного кода (весь код можно проинвертировать с помощью операции not)

5) занесение единицы в нужные разряды двоичного кода без имени (литерал)

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

ПРИМЕР 1. Рассмотрим выделение из всего двоичного кода нужных разрядов.

Пусть имеется следующее объявление двух переменных:

Var

c: word; {Результат выделения}

w: word; {Исходное число}

В этом случае выделение из 2 байтов переменной w семи младших разрядов будет выглядеть следующим образом:

c: = w and $ 7F 7 разрядов

маска = 0000 0000 0111 1111

----- ----- ------ -----

0 0 7 F

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

ПРИМЕР 2. Установка в ноль ( очистка ) 7 младших разрядов.

Var

c, w: word;

Begin

c: = w and $ FF80

здесь маска имеет вид:

1111 1111 1000 0000

F F 8 0

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

ПРИМЕР 3. Проверка заданных разрядов. Может выполняться с помощью условного оператора языка Паскаль, маски и поразрядной операции and. В условном операторе выполняется проверка на совпадение результата операции and с маской.

Var

w: word; {анализируемое число}

Begin

if (w and маска) = маска

then …..{если совпало}

else ……{если не совпало}

Например: if (i and 3) = 3 ------------------------ проверка младших двух разрядов

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

ПРИМЕР 4. Инвертирование избранных разрядов числа.

Var

c, w: word;

Begin

c: = w XOR $7;

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

Примечания:

1) если эта операция повторяется два раза, то значение исходного числа восстановится;

2) имеется поразрядная операция NOT, но она инвертирует все разряды, а нам необходимо инвертировать только некоторые

ПРИМЕР 5. Установка (занесение 1) в три младших разряда (остальные остаются без изменения):

Var

c, w: word;

Begin

c: = c OR $7;

Здесь в маске устанавливают в единицу те разряды, в которые надо занести единицу.

ПРИМЕР 6 (Более сложный). Пусть надо выполнить комбинированное действие – из двух переменных (одна представляет собой младшее слово, вторая – старшее слово многословного числа) типа Word (2 байта) собрать одну типа Longint (4байта).

high_word low_word

Longint

Var

high_word: word;

low_word: word;

long_word: longint;

begin

high_word: =$7F00; Приведение к типу Longint

low_word: = $00FE;

long_word: = (longint(high_word) shl 16) + longint(low_word);

end.

ЗАМЕЧАНИЕ: Во всех рассмотренных пяти примерах есть одна особенность: вид маски зависит от разрядности числа. Рассмотрим, например, маску, которая используется в операции очистки 7 младших разрядов числа типа Word. Если мы захотим с помощью той же самой маски очистить младшие 7 разрядов, но уже в переменной longint, то очистятся 7 младших разрядов + 16 старших разрядов.

Var

c: longint; {Раньше был тип Word}

c: = c AND $FF80;

Так произойдет потому, что применительно к типу longint маска фактически будет иметь запись 0000FF80. То есть, для типа longint маска должна была бы иметь вид FFFFFF80. Вывод из этого : для достижения универсальности надо стремиться к тому, чтобы запись маски не зависела от разрядности числа, к которому она применяется.

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

Not ($7F)

0111 1111

Если в общем случае нужно получить маску из n единиц, например, начиная с k-го разряда вправо n единиц (k считается справа налево, начиная с 1), то значение этой маски можно получить следующим образом:

к=8 к=1

m: = (not( (not 0) shl n)) shl (k - n) 1 1 1 1

будут получены все единицы n=4 разрядов

справа будут получены n нулей к=6

из n нулей будет получено n единиц

единицы перегоняются на заданную k позицию

Если надо получить маску из n единиц, начиная с k-го разряда (но k считается теперь слева направо начиная с 1 до sizoeof(m)*8), то значение этой маски можно получить следующим образом:

m: = (not( (not 0) shl n)) shl (sizeof(m)*8 – k);

где sizeof(m) – размер типа в байтах

Перечисляемый тип.

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

Var

0 1 2 3 4 5 ----- в программу вместо имен будут подставлены эти значения

v: (a, b, c, d, e, f);

идентификаторы

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

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

Если булевский тип не был бы введен, то мы его бы ввели таким образом:

type

boolean = (false, true);

Хранятся данные этого типа очень компактно. Если вы перечисляете не более 256 имен, то хранится переменная в одном байте; если > 256 но < 65535 то занимает 2 байта. Это действительно компактно, если учесть, что для описания 65535 переменных требуется как минимум 65535 байт. Из вот такой компактной формы хранения этих переменных невозможно выводить значение этих переменных на экран и вводить с клавиатуры. Нельзя написать следующую конструкцию:

write (V);

Однако можно посмотреть значение такой переменной в окне Watch.

Примечание:

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

Var

v: (1, 2, 3, 4, 5, 6); нельзя!

Вопрос: что можно присвоить переменной этого типа – имя (из перечня) или число?

Тип – диапазон

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

Общий вид:

Var

v: левая.. правая;

Примечание 1.

Правая граница должна быть обязательно больше, чем левая.

ПРИМЕР:

Var

v: 1..10; {правильная запись}

v: 10..1; {неправильная запись}

Примечание 2.

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

Var

s: ‘a‘..’z’; - базовым является символьный (char) тип.

Примечание 3.

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

Примечание 4.

Если включена опция компилятора Range Checking или использована директива компилятора {$R+} в программе, то это заставляет компилятор выполнять проверку выхода значения переменной за указанный диапазон.

Символьный тип

Объявляется следующим образом:

Var

c: char;

Переменная этого типа занимает 1 байт без знака. Диапазон значений от 0 до 255.

Для каждой переменной символьного типа в памяти хранится код символа (порядковый номер символа в таблице кодов ASCII), то есть:

c: = ‘ ‘; ------ храниться будет 32₁₀.

c: = ‘1’; ------- храниться будет 61₁₀.

Для переменных символьного типа применяются три стандартные функции:

Ord (‘ ’)=32 - возвращает порядковый номер символа в кодировочной таблице ASCII

Pred (‘b’)=’a’ - возвращает значение предыдущего аргументу символа в таблице кода ASCII

Succ (‘a’)=’b’ - возвращает следующий за аргументом по порядку символ в таблице кодов ASCII.

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

1) в таблице ASCII символы с изображением цифр расположены так, что символу, которому соответствует б о льшая цифра, соответствует б о льший номер.

2) в таблице ASCII cимволы с изображением латинских букв расположены в соответствии с их порядком в алфавите.

3) в таблице ASCII вначале расположены все цифры, потом все латинские буквы, а потом все русские.

4) в таблице ASCII вначале расположены все заглавные (прописные) латинские буквы, а потом - все маленькие (строчные).

5) Расстояние между прописной буквой и такой же строчной равно 32.

Для полученных значений переменной символьного типа по коду символа используется функция Chr:

Var c: = chr(b)

b: byte;

c: char; b c

begin

b: = 25; b: = ord(c)

c: = Chr(b);

b: = Ord(c);

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

1). c: = ‘a’;

2). c: =#61; - символ с кодом 61 в 10 системе счисления

3). c: =#$20; - символ с кодом 32 в 10 системе счисления

Вещественные типы.

Вещественные типы относятся к простым, но не являются порядковыми (5 разновидностей).

Real - занимает 6 байтов

Single - 4

Double - 8

Extended - 10

Comp - 8

12 3 4 5 6 7 8 9 10 Следующая ⇒