Информационный портал MSEVM
 Поиск

Главная > Программирование в Delphi 6 > Глава 7



Глава 7

ТИПЫ ДАННЫХ

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

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

В этой и четырех последующих главах приводится подробное описание всех типов.

7.1. ПРОСТЫЕ ТИПЫ

К простым типам относятся порядковые, вещественные типы и тип дата-время.

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

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

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

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

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

Рис. 7.1. Структура типов данных

Для целых типов функция ord(x) возвращает само значение х, т. е. Ord(X) = х для х, принадлежащего любому целому типу. Применение Ord(x) к логическому, символьному и перечисляемому типам дает положительное целое число в диапазоне от 0 до 1 (логический тип), от 0 до 255 (символьный), от 0 до 65535 (перечисляемый). Тип-диапазон сохраняет все свойства базового порядкового типа, поэтому результат применения к нему функции ord(X) зависит от свойств этого типа.

К порядковым типам можно также применять функции:

pred(x) - возвращает предыдущее значение порядкового типа (значение, которое соответствует порядковому номеру

ord (X) -1), т. е. Ord(Pred(X)) = Ord(X) - 1;

succ (X) - возвращает следующее значение порядкового типа, которое соответствует порядковому номеру ord (X) +1, т. е.

Ord(Succ(X)) = Ord(X) + 1.

Например, если в программе определена переменная

var

с : Char;

begin

с := '5';

end;

то функция PRED(C) вернет символ '4', а функция SUCC(C) - символ '6'.

Если представить себе любой порядковый тип как упорядоченное множество значений, возрастающих слева направо и занимающих на числовой оси некоторый отрезок, то функция pred(x) не определена для левого, a succ (X) - для правого конца этого отрезка.

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

Название

Длина,байт

Диапазон значений

Cardinal

4

0. .. 2 147 483 647

Byte

1

0...255

Shortint

1

-128...+127

Smallint

2

-32 768...+32 767

Word

2

0...65 535

Integer

4

-2 147 483 648...+2 147 483 647

Longint

4

-2 147 483 648...+2 147 483 647

Int64

8

-9*1018. ..+9*1018

LongWord

4

0. . .4 294 967 295

 

Типы LongWord и Int64 впервые введены в версии 4, а типы Smallint и Cardinal отсутствуют в Delphi 1. Тип integer для этой версии занимает 2 байта и имеет диапазон значений от -32768 до +32767, т. е. совпадает с Smallint.

При использовании процедур и функций с целочисленными параметрами следует руководствоваться “вложенностью” типов, т. е. везде, где может использоваться word, допускается использование Byte (но не наоборот), в Longint “входит” Smallint, который, в свою очередь, включает в себя Shortint.

Перечень процедур и функций, применимых к целочисленным типам, приведен в табл. 7.2. Буквами b, s, w, i, l обозначены выражения соответственно типа Byte, Shortint, Word, Integer И Longint,

х - выражение любого из этих типов; буквы vb, vs, vw, vi, vl, vx обозначают переменные соответствующих типов. В квадратных скобках указывается необязательный параметр.

Таблица 7.2. Стандартные процедуры и функции, применимые к целым типам

Обращение

Тип результата

Действие

abs (x)

x

Возвращает модуль x

chr(b)

Char

Возвращает символ по его коду

dec (vx [, i] )

-

Уменьшает значение vx на i, а при отсутствии i - на 1

inc(vx[,i])

-

Увеличивает значение vx на i, а при отсутствии i -на 1

Hi(w)

Byte

Возвращает старший бант аргумента

Hi(I)

То же

Возвращает третий по счету байт

Lo(i)

Возвращает младший байт аргумента

Lo(w)

То же

odd(l)

Boolean

Возвращает True, если аргумент-нечетное число

Random(w)

 

 

Как у параметра

Возвращает псевдослучайное число, равномерно распределенное в диапазоне 0...(w-l)

sqr(x)

X

Возвращает квадрат аргумента

swap(i)

Integer

Меняет местами байты в слове

swap (w)

Word

Тоже

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

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

procedure TfmExample.bbRunClick(Sender: TObject) ;

var

k: Word;

begin

k := 65535; // Максимальное значение типа Word

k := k+1; // По правилам математики

k=65536 IbOutput.Caption := IntToStr(k); // На самом деле k=0!

end;

Если активизировать переключатель project | options | Compiler I Range checking и повторить компиляцию с помощью Project | Build All, компилятор вставит в программу код проверки переполнения и при прогоне программы возникнет исключительная ситуация, которую при желании можно соответствующим образом обработать. Замечу, что, если изменить программу следующим образом:

k := 65535; // Максимальное значение типа Word

IbOutput.Caption := IntToStr(k + 1);// Будет выведено 65536

переполнения не произойдет, т. к. 32-разрядный компилятор версий Delphi 32 автоматически преобразует операнды выражения k+i к 4-байтным величинам.

Логические типы. К логическим относятся типы Boolean, ByteBool, Bool, wordBool и LongBool. В стандартном Паскале определен только тип Boolean, остальные логические типы введены в Object Pascal для совместимости с Windows: типы Boolean и ByteBool занимают по одному байту каждый, Bool и WordBool - по 2 байта, LongBool - 4 байта. Значениями логического типа может быть одна из предварительно объявленных констант False (ложь) или True (истина). Для них справедливы правила:

Ord(False) = 0;

Ord(True) <> 0;

Succ(False)= True;

Pred(True) = False.

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

var

l : Boolean;

begin

for l := False to True do ....

Однако необходимо помнить, что в Delphi 32 для Boolean значение

Ord (True) = +1, В ТО Время как для других типов (Bool, WordBool И Т.Д.)

Ord (True) = -1, поэтому такого рода операторы следует использовать с осторожностью!. Например, для версии Delphi 6 исполняемый оператор showMessage (' --- ') в следующем цикле for не будет выполнен ни разу:

var

L: Bool;

k: Integer;

begin

for L := False to True do ShowMessage ('--);

end; __

Если заменить тип параметра цикла l в предыдущем примере на Boolean, цикл будет работать и сообщение дважды появится на экране.[Для Delphi версии 1 и 2 ord (True) =+1 для любого логического типа.]

Символьный тип. Значениями символьного типа является множество всех символов ПК. Каждому символу приписывается целое число в диапазоне О...255. Это число служит кодом внутреннего представления символа, его возвращает функция ord.

Для кодировки в Windows используется код ANSI (назван по имени American National Standard Institute - американского института стандартизации, предложившего этот код). Первая половина символов ПК с кодами 0... 127 соответствует таблице 7.3. Вторая половина символов с кодами 128...255 меняется для различных шрифтов. Стандартные Windows-шрифты Arial Cyr, Courier New Cyr и Times New Roman для представления символов кириллицы (без букв “ё” и “Ё”) используют последние 64 кода (от 192 до 256): “А”... “Я” кодируются значениями 192..223, “а”... “я” - 224...255. Символы “Ё” и ё” имеют соответственно коды 168 и 184.

Таблица 7.3. Кодировка символов в соответствии со стандартом ANSI

Код

Символ

Код.

Символ

Код.

Символ

Код

Символ

0

NUL

32

BL

64

@

96

'

1

ЗОН

33

!

65

А

97

а

2

STX

34

66

В

98

b

3

ЕТХ

35

#

67

С

99

с

4

EOT

36

$

68

D

100

d

5

ENQ

37

%

69

Е

101

е

6

ACK

38

&

70

F

102

f

7

BEL

39

'

71

G

103

д

8'

BS

40

(

72

Н

104

h

9

HT

41

)

73

I

105

i

10

LF

42

*

74

J

106

j

11

VT

43

+

75

К

107

k

12

FF

44

f

76

L

108

1

13

CR

45

-

77

М

109

m

14

SO

46

 

 

78

N

110

n

15

SI

47

/

79

0

111

о

16

DEL

48

0

80

Р

112

P

17

DC1

49

1

81

Q

113

q

18

DC2

50

2

82

R

114

r

19

DC3

51

3

83

S

115

s

20

DC 4

52

4

84

Т

116

t

21

NAK

53

5

85

U

117

u

22

SYN

54

6

86

V

118

v

23

ETB

55

7

87

W

119

W

24

CAN

56

8

88

х

120

x

25

EM

57

9

89

Y

121

У

26

SUB

58

:

90

Z

.122

z

27

ESC

59

;

91

t

123

{

28

FS

60

<

92

\

124

1

29

GS

61

=

93

]

125

}

30

RS

62

>

94

Л

126

~

31

US

63

f

95

 

 

127

r

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

К типу char применимы операции отношения, а также встроенные функции:

Сhr (в) - функция типа char; преобразует выражение в типа Byte в символ и возвращает его своим значением;

UpCase(CH) - функция типа char; возвращает прописную букву, если сн - строчная латинская буква, в противном случае возвращает сам символ сн (для кириллицы возвращает исходный символ).

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

type

colors = (red, white, blue);

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

type

ТипМесяц=(янв,фев,мар,апр,май,июн,июл,авг,сен,окт,ноя,дек);

var

месяц : ТипМесяц;

begin

if месяц = авг then

IbOutput.Caption := 'Хорошо бы поехать к морю!';

end.

 

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

type

TypeMonth=(jan,feb,mar,may,jun,jul,aug,sep,oct,nov,dec);

var

month: TypeMonth;

begin

if month = aug then

IbOutput.Caption := 'Хорошо бы поехать к морю!';

end.

Соответствие между значениями перечисляемого типа и порядковыми номерами этих значений устанавливается порядком перечисления: первое значение в списке получает порядковый номер О, второе - 1 и т. д. Максимальная мощность перечисляемого типа составляет 65536 значений, поэтому фактически перечисляемый тип задает некоторое подмножество целого типа word и может рассматриваться как компактное объявление сразу группы целочисленных констант со значениями 0, 1 и т. д.

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

type

colors = (black, red, white);

ordenal= (one, two, three) ;

days = (Monday, Tuesday, Wednesday);

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

Ord(black)=0, ... , Ord(white)=2,

Ord(one)=0, ... , Ord(three)=2,

Ord(Monday)=0, ... , Ord(Wednesday)=2.

Однако если определены переменные

var

col : colors;

num : ordenal;

day : days ;

то допустимы операторы

col := black;

num := Succ(two);

day := Pred(Tuesday);

но недопустимы

col := one;

day := black;

Как уже упоминалось, между значениями перечисляемого типа и множеством целых чисел существует однозначное соответствие, задаваемое функцией Ord(X). В Object Pascal допускается и обратное преобразование: любое выражение типа Word можно преобразовать в значение перечисляемого типа, если только значение целочисленного выражения не превышает мощности этого типа. Такое преобразование достигается применением автоматически объявляемой функции с'именем перечисляемого типа. Например, для рассмотренного выше объявления типов эквивалентны следующие присваивания:

col := black;

col := colors (0) ;

Разумеется, присваивание

col := 0;

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

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

var

col: (black, white, green);

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

Тип-диапазон задается границами своих значений внутри базового типа:

<мин.знач.>..<макс.знач.>

Здесь <мин. знач. > - минимальное значение типа-диапазона; <макс. знач. > - максимальное его значение.

Например:

type

digit = '0'..'9';

dig2 = 48 .. 57;

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

var

date : 1. .31;

month: 1..12;

Ichr : 'А'..'Z';

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

  • два символа “..” рассматриваются как один символ, поэтому жду ними недопустимы пробелы;
  • левая граница диапазона не должна превышать его правую границу.

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

type

days = (то,tu,we,th,fr,sa,su);

WeekEnd = sa .. su;

var

w : WeekEnd;

begin

w := sa;

end;

to ord(w) вернет значение 5, в то время как pred(W) приведет к ошибке.

В стандартную библиотеку Object Pascal включены две функции, поддерживающие работу с типами-диапазонами:

High(X) - возвращает максимальное значение типа-диапазона, к которому принадлежит переменная х;

Low (X) - возвращает минимальное значение типа-диапазона.

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

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

Таблица 7.4. Вещественные типы

Длина, байт

Название

Количество значащих цифр

Диапазон значений

8

4

8

10

8

8

Real

Single

Double

Extended

Comp

Currency

15…16

7…8

15…16

19…20

19…20

19…20

5.0*10e-324…1.7*10e308

1.5*10e-45…3.4*10e38

5.0*10e324…1.7*10e308

3.4*10-4951…1.1*10e4932

-2e63…+2e63-1

+/-922 337 203 685477,5807

 

В предыдущих версиях Delphi 1...3 тип Real занимал 6 байт и имел диапазон значений от2, 9*10-39 до 1,7*1038. В версиях 4 и 5 этот тип эквивалентен типу Double. Если требуется (в целях совместимости) использовать 6-байтньш Real, нужно указать директиву компилятора {SREALCOMPATIBILITY ON}.

Как видно из табл. 7.4, вещественное число в Object Pascal занимает от 4 до 10 смежных байт и имеет следующую структуру в памяти ПК:

S

е

M

Здесь s - знаковый разряд числа; е - экспоненциальная часть; содержит двоичный порядок; m - мантисса числа.

Мантисса m имеет длину от 23 (для single) до 63 (для Extended) двоичных разрядов, что и обеспечивает точность 7...8 для single и 19...20 для Extended десятичных цифр. Десятичная точка (запятая) подразумевается перед левым (старшим) разрядом мантиссы, но при действиях с числом ее положение сдвигается влево или вправо в соответствии с двоичным порядком числа, хранящимся в экспоненциальной части, поэтому действия над вещественными числами называют арифметикой с плавающей точкой (запятой).

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

Например, если “машинное эпсилон” (см. пример п. 5.4.3) вычисляется с помощью такой программы:

type

RealType = Real;

var

Epsilon : RealType;

begin

Epsilon := 1;

while l+Eps4.1on/2 > 1 do

Epsilon := Epsilon/2;

IbOutput.Caption := FloatToStr(Epsilon)

end;

то независимо от объявления типа RealType (он может быть single, Real, Double или Extended) на печать будет выдан результат

1.08420217248550Е-0019

что соответствует типу Extended. Происходит это по той причине, что все операнды вещественного выражения 1+Epsilon/2 в операторе while перед вычислением автоматически преобразуются к типу Extended. Чтобы получить правильный результат, программу необходимо изменить следующим образом:

type

RealType = Real;

var

Epsilon, Epsl : RealType;

begin

Epsilon := 1;

repeat

Epsilon := Epsilon/2;

Epsl := 1 + Epsilon

until Epsl = 1;

IbOutput.Caption := FloatToStr(2*Epsilon)

end.

Особое положение в Object Pascal занимают типы comp и Currency, которые трактуются как вещественные числа с дробными частями фиксированной длины: в comp дробная часть имеет длину 0 разрядов, т. е. просто отсутствует, в currency длина дробной части -4 десятичных разряда. Фактически оба типа определяют большое целое число со знаком, сохраняющее 19...20 значащих десятичных цифр (во внутреннем представлении они занимают 8 смежных байт). В то же время в выражениях comp и currency полностью совместимы с любыми другими вещественными типами: над ними определены все вещественные операции, они могут использоваться как аргументы математических функций и т. д. Наиболее подходящей областью применения этих типов являются бухгалтерские расчеты.

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

Таблица 7.5. Стандартные математические функции Object Pascal

Обращение

Тип параметра

Тип результата

Примечание

abs (x)

Real, Integer

Тип аргумента Real 

Модуль аргумента

Pi

-

<<

П =3.141592653...

ArcTan(x)

Арктангенс (значение в радианах)

cos (x)

To же <<

To же <<

Косинус, угол в радианах

exp(x)

<<

<<

Экспонента

frac(x)

<<

<<

Дробная часть числа

int(x)

<<

<<

Целая часть числа

ln(x)

<<

<<

Логарифм натуральный

Random

<<

Псевдослучайное число, равномерно распределенное в диапазоне 0...[1]

Random.fx)

 

Integer

 

Integer

 

Псевдослучайное целое число, равномерно распределенное в диапазоне 0...(х-1)

Randomize

 

-

 

-

Инициация генератора псевдослучайных чисел

sin (x)

Real

Real

Синус, угол в радианах

sqr(x)

To же

To же

Квадрат аргумента

sqrt(x)

<<

<<

Корень квадратный

На заметку Генератор псевдо случайных чисел представляет собой функцию которая берет некоторое целое число, называемое базовым, изменяет, его разряды По определенному алгоритму и выдает новое число результат. Одновременно с этим новое число становится базовым.прД следующем обращении к функций; и т. д. (Так как алгоритм процедуры не меняется: в ходе ее работы, числа называются псевдослучайна ми.) В системном модуле System, который автоматически доступен любой программе, базовое число хранится в переменной с именеД RandSeek и всегда имеет начальное значение.О. :Это означает, последовательном обращении к Random в разных, программах (или при нескольких прогонах одной программы) будет всегда вь1лапа'оД на и, та же прследовательность псевдослучайных чисел. НапримёД при; следующём обрабЬтчике bbRunCl.i.ck окно, нашей .учебной программы будет иметь вид, показанный на рис. 7.2:

procedure TfinExaniple.bbRunCliak(Sender:TObject);

var

S,3S: String;.

begin

S='';

for k :=1 to 300 do

SS := IntToStr (Random (1000))

while Length(SS)<3 do

if k mod 2С=0 then

begin

S : = '' ;

end

end

end;

(В программе выводятся 300 псевдослучайных чисел, которые группируются в строки по 20 чисел и дополняются ведущими нулями, если число имеет меньше трех цифр.) Если вы захотите повторить программу, вы получите точно такую же последовательность чисел, что н на рис. 7.2. С помощью процедуры Randomize в переменную RandSeek помещается

численное значение системного времени, что привёдет к генерации, другой последовательности. Обращение к этой процедуре нужно сделать в самом начале обработчика.

Рис. 7.2. Последовательность псевдослучайных чисел

Начиная с версии 2 в Delphi включен модуль Match, который существенно расширяет перечисленный в табл. 7.5 набор встроенных математических функций. Особенностью реализации содержащихся в нем почти 70 функций и процедур является их оптимизация для работы с арифметическим сопроцессором класса Pentium, так что все они производят необходимые вычисления за рекордно малое время.

Исходный текст содержится в файле файле Source\Rtl\Sys\Match.pas каталога размещения Delphi. В прил. 3 перечисляются подпрограммы модуля Match.

7.1.3. Тип дата-время

Тип дата-время определяется стандартным идентификатором TDateTime и предназначен для одновременного хранения и даты, и времени. Во внутреннем представлении он занимает 8 байт и подобно currency представляет собой вещественное число с фиксированной дробной частью: в целой части числа хранится дата, в дробной - время. Дата определяется как количество суток, прошедших с 30 декабря 1899 года, а время - как часть суток, прошедших с 0 часов, так что значение 36444,837 соответствует дате 11.10.1999 и времени 20:05. Количество суток может быть и отрицательным, однако значения меньшие -693594 (соответствует дате 00.00.0000 от Рождества Христова) игнорируются функциями преобразования даты к строковому типу.

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

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

Таблица 7.6. Подпрограммы для работы с датой и временем

Function Date: TDateTime;

 

Function DateToStr(D: TDateTime): String;

Function DateTimeToStr(D: TDateTime): String;

 

Function FormatDateTime (Format: String;

 

Value: TDateTime): String;

 

Function Now: TDateTime;

 

Function Time: TDateTime;

 

Function TimeToStrfT: TDateTime): String;

Возвращает текущую дату

 

Преобразует дату в строку символов

Преобразует дату и время в строку символов

 

 

Преобразует дату и время из параметра value в строку символов в соответствии со спецификаторами параметра Format (см. пояснения в п. 7.3.)

 

Возвращает текущую дату и время

 

Возвращает текущее время

 

Преобразует время в строку

 

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

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

IbOutput.Caption := DateToStr(Date + 21);

поместит в метку IbOutput дату, соответствующую текущей дате плюс 3 недели. Чуть сложнее с исчислением времени. Например, чтобы добавить к текущему времени полтора часа, следует использовать выражение

Time + StrToTime('1:30')

ИЛИ

Time+1.5/24

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

TDateTime:

procedure TfmExample.bbRunClick(Sender: TObject) ;

{Показывает вещественное число, введенное в строке edinput,в формате даты-времени}

var

k: Double;

begin

//Преобразуем строковый ввод в вещественное число

try

k := StrToFloat(edinput.Text);

except

ShowMessage('Ошибка записи вещественного числа');

edinput.SelectAll ;

Exit

end;

//Показываем результат как дату-время

IbOutput. Caption := ForrnatDateTime

('dd.mm.yyyy hh:mm:ss', k);

// Возвращаем фокус ввода в edinput edinput.SetFocus ;

end;

7.2. СТРУКТУРИРОВАННЫЕ ТИПЫ

Любой из структурированных типов (а в Object Pascal их четыре: массивы, записи, множества и файлы) характеризуется множественностью образующих этот тип элементов. Каждый элемент, в свою очередь, может принадлежать структурированному типу, что позволяет говорить о возможной вложенности типов. В Object Pascal допускается произвольная глубина вложенности типов, однако суммарная длина любого из них во внутреннем представлении не должна превышать 2 Гбайт [16-разрядные версии операционной системы Windows З.х используют так называемую “ сегментную” модель памяти, поэтому в Delphi 1 любой структурированный тип не может занимать более одного сегмента (65536 байт).].

В целях совместимости со стандартным Паскалем в Object Pascal разрешается перед описанием структурированного типа ставить зарезервированное слово packed, предписывающее компилятору по возможности экономить память, отводимую под объекты структурированного типа; но компилятор фактически игнорирует это указание: “упаковка” данных в Object Pascal осуществляется автомата- ;

чески везде, где это возможно.

7.2.1. Массивы

Массивы в Object Pascal во многом схожи с аналогичными типами данных в других языках программирования. Отличительная особенность массивов заключается в том, что все их компоненты суть данные одного типа (возможно, структурированного). Эти компоненты можно легко упорядочить и обеспечить доступ к любому из них простым указанием его порядкового номера, например:

type

digit = array [0..9] of Char;

matrix = array [byte] of Single;

var

m : matrix;

d : digit;

i : integer;

begin

m[17] := ord(d[i-l])/10;

end.

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

<имя типа> = array [ <сп.инд.типов> ] of <тип>;

Здесь <имя типа> - правильный идентификатор; array, of - зарезервированные слова {массив, из); <сп.инд.типов> - список из одного или нескольких индексных типов, разделенных запятыми; квадратные скобки, обрамляющие список, - требование синтаксиса;

<тип> - любой тип Object Pascal.

В качестве индексных типов в Object Pascal можно использовать любые порядковые типы, имеющие мощность не более 2 Гбайт (т. е. Кроме LongWord И Int64)

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

var

a,b : array [1..10] of Real;

Обычно в качестве индексного типа используется тип-диапазон, в котором задаются границы изменения индексов. Так как тип <тип>, идущий в описании массива за словом of, - любой тип Object Pascal, то он может быть, в частности, и другим массивом, например:

type

mat = array [0..5] of array [-2..2] of array [Char] of Byte;

Такую запись можно заменить более компактной:

type

mat = array [0..5,-2..2,char] of Byte;

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

Если, например,

var

a: array [1..2,1..2] of Byte;

begin

а[1,1] := 1;

а[2,1] := 2;

а[1,2] := 3;

а[2,2] := 4;

end.

то в памяти последовательно друг за другом будут расположены байты со значениями 1,3,2,4 . Это обстоятельство может оказаться важным при использовании стандартной процедуры копирования памяти MoveMemory.

В Object Pascal можно одним оператором присваивания передать все элементы одного массива другому массиву того же типа, например:

var

a,b : array [1..5] of Single;

begin

а := b;

end.

После этого присваивания все пять элементов массива а получат те же значения, что и в массиве в. Замечу, что объявление

var

a: array [1..5] of Single;

b: array [1..5] of Single;

создаст разные типы массивов, поэтому оператор

а := b;

вызовет сообщение об ошибке.

Над массивами не определены операции отношения. Нельзя, например, записать

if а = b then ...

Сравнить два массива можно поэлементно, например:

var

a,b : array [1..5] of Single;

eq : Boolean;

i : Byte;

begin

eq := True; for i := 1 to 5 do

if a[i] <> b[i] then

eq := False/if eq then

end.

Динамические массивы

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

var

A: array of Integer;

В: array of array of Char;

C: array of array of array of Real;

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

SetLength(А,3);

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

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

var

А,В: array of Integer;

begin

// Распределяем память:

SetLength(A,10) ;

SetLength(B,20) ;

// Используем массивы:

// Освобождаем память:

А := NIL;

Finalize(В);

end;

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

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

var

A: array of array of Integer;//Двумерный динамический массив begin

//Устанавливаем длину первого измерения (количество столбцов):

SetLength(A,3) ;

//Задаем длину каждого столбца:

SetLength(A[0],3) ;

SetLength(A[l],3) ;

SetLength(A[2] ,3) ;

end;

Обратите внимание: в отличие от обычных массивов стандартного Паскаля (и Object Pascal), динамические массивы могут иметь разную длину по второму и следующим измерениям. В предыдущем примере определен квадратный массив 3х3. Однако ничто не мешает нам создать, например, треугольный массив:

SetLength(A,3) ;

//Задаем длину каждого столбца:

SetLength(A[0],3) ;

SetLength(A[l],4) ;

SetLength(A[2],5) ;

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

var

A: array of array of array of Real;

i, j: Integer;

begin

SetLength(A,3) ;

for i := 0 to 2 do

begin

SetLength(A[i],3) ;

for j := 0 to 2 do SetLength{A[i,j],3) ;

end;

end;

7.2.2. Записи

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

Структура объявления типа записи такова:

<имя типа> = record <сп.полей> end;

Здесь <имя типа> - правильный идентификатор; record/ end - зарезервированные слова {запись, конец); <сп.полей> - список полей; представляет собой последовательность разделов записи, между которыми ставится точка с запятой.

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

type

BirthDay = record Day, Month: Byte;

Year : Word end;

var

a,b : Birthday;

В этом примере тип BirthDay (день рождения) есть запись с полями Day, Month и Year (день, месяц и год); переменные а и в содержат записи типа BirthDay.

Как и в массиве, значения переменных типа записи можно присваивать другим переменным того же типа, например

а := b;

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

a.day := 27;

b.year := 1939;

Для вложенных полей приходится продолжать уточнения:

type

BirthDay = record Day,Month: Byte;

Year : Word end;

var

с : record

Name : String;

Bd : BirthDay end;

begin

if c.Bd.Year = 1989 then ... end.

Чтобы упростить доступ к полям записи, используется оператор присоединения with:

with <переменная> do <оператор>;

Здесь with, do - зарезервированные слова (с, делать);

<переменная> - имя переменной типа запись, за которой, возможно,

следует список вложенных полей; <оператор> - любой оператор Object Pascal.

Например:

с.Bd.Month := 9;

Это эквивалентно

with c.Bd do Month := 9;

или with с do with Bd do Month := 9;

или with с, Bd do Month := 9;

Object Pascal разрешает использовать записи с так называемыми вариантными полями, например:

type

Forma = record Name: String;

case byte of

0: (Birthplace: String [40]);

1: (Country : String [20];

EntryPort : String [20];

EntryDate : 1..31;

ExitDate : 1..31)

end;

В этом примере тип Forma определяет запись с одним фиксированным полем Name и вариантной частью, которая задается предложением case ... of. Вариантная часть состоит из нескольких вариантов (в примере - из двух вариантов: 0 и 1). Каждый вариант определяется константой выбора, за которой следуют двоеточие и список полей, заключенный в круглые скобки. В любой записи может быть только одна вариантная часть, и, если она есть, она должна располагаться за всеми фиксированными полями.

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

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

var

Mem4 : record case Byte of

0 : (by : array [0..3] of Byte);

1 : (wo : array [0..1] of Word);

2 : (lo : Longint) ;

end;

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

var

х : Word;

xb: Byte;

xl: Longint;

begin

with m do begin

lo := Trunc(2*pi*x);

if wo[l] =0 then if by[l] =0 then

xb := x[0] else

x := wo[0] else

xl := lo

end;

end.

Предложение case ... of, открывающее вариантную часть, внешне похоже на соответствующий оператор выбора, но на самом деле лишь играет роль своеобразного служебного слова, обозначающего начало вариантной части. Именно поэтому в конце вариантной части не следует ставить end как пару к case ... of. (Поскольку вариантная часть - всегда последняя в записи, за ней все же стоит end, но лишь как пара к record). Ключ выбора в предложении case ... of фактически игнорируется компилятором: единственное требование, предъявляемое к нему в Object Pascal, состоит в том, чтобы ключ определял некоторый стандартный или предварительно объявленный порядковый тип.

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

7.2.3. Множества

Множества - это наборы однотипных логически связанных друг с другом объектов. Характер связей между объектами лишь подразумевается программистом и никак не контролируется Object Pascal. Количество элементов, входящих в множество, может меняться в пределах от 0 до 256 (множество, не содержащее элементов, называется пустым). Именно непостоянством количества своих элементов множества отличаются от массивов и записей.

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

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

type

digitChar = set of '0'..'9';

digit = set of 0. .9;

var

sl,s2,s3 : digitChar;

s4,s5,s6 : digit;

begin

si = ['1', '2', '3'];

s2 = ['3', '2', '1'];

s3 = ['2', '3'];

s4 = [0..3, 6];

s5 = [4, 5];

s6 = [3..9];

end.

В этом примере множества si и s2 эквивалентны, а множество S3 включено в s 2 , но не эквивалентно ему.

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

<имя типа> = set of <базовый тип>;

Здесь <имя типа> - правильный идентификатор; set, of - зарезервированные слова (множество, из); <базовый тип> - базовый тип элементов множества, в качестве которого может использоваться любой порядковый тип, кроме Word, Integer, Longint, Int64.

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

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

* пересечение множеств; результат содержит элементы, общие для обоих множеств; например, s4*s6 содержит [3], s4*s5 -пустое множество (см. выше);

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

S4+S5 содержит [0,1,2,3,4,5,6];

S5+S6 содержит [3, 4, 5, 6, 7, 8, 9] ;

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

S6-S5 содержит [3,6,7,8,9];

S4-S5 содержит [0,1, 2, 3, 6] ;

= проверка эквивалентности; возвращает True, если оба множества эквивалентны;

<> проверка неэквивалентности; возвращает True, если оба множества неэквивалентны;

<= проверка вхождения; возвращает True, если первое множество включено во второе;

>= проверка вхождения; возвращает True, если второе множество включено в первое;

in проверка принадлежности; в этой бинарной операции первый элемент - выражение, а второй - множество одного и того же типа; возвращает True, если выражение имеет значение, принадлежащее множеству:

3 in s 6 возвращает True;

2*2 in si возвращает False.

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

include - включает новый элемент во множество. Обращение к процедуре:

Include(S,I)

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

exclude - исключает элемент из множества. Обращение:

Exclude(S,I)

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

Учебная программа PRIMSET

В следующем примере, иллюстрирующем приемы работы с множествами, реализуется алгоритм выделения из первой сотни натуральных чисел всех простых чисел[Простыми называются целые числа, которые не делятся без остатка на любые другие целые числа, кроме 1 и самого себя. К простым относятся 1, 2, 3, 5, 7, 11, 13 и т. д..]. В его основе лежит прием, известный под названием “решето Эратосфена”. В соответствии с этим алгоритмом вначале формируется множество BeginSet, состоящее из всех целых чисел в диапазоне от 2 до N. В множество primerset (оно будет содержать искомые простые числа) помещается 1. Затем циклически повторяются следующие действия:

  • взять из BeginSet первое входящее в него число Next и поместить его В PrimerSet;
  • удалить из BeginSet число Next и все другие числа, кратные ему, Т. е. 2*Next, 3*Next И Т.Д.

Цикл повторяется до тех пор, пока множество BeginSet не станет пустым.

Эту программу нельзя использовать для произвольного N, так как в любом множестве не может быть больше 256 элементов.

procedure TfmExample.bbRunClick(Sender: TObject);

// Выделение всех простых чисел из первых N целых

const

N = 255; // Количество элементов исходного множества

type

SetOfNumber = set of 1..N;

var

n1,Next,i: Word; // Вспомогательные переменные

BeginSet, // Исходное множество

PrimerSet: SetOfNumber; // Множество простых чисел

S: String;

begin

BeginSet := [2..N];

// Создаем исходное множество

PrimerSet:= [1]; // Первое простое число

Next := 2; // Следующее простое число

while BeginSet о [ ] do // Начало основного цикла

begin

nl := Next; //nl-число, кратное очередному простому (Next)

// Цикл удаления из исходного множества непростых чисел:

while nl <= N do

begin

Exclude(BeginSet, nl);

n1 := nl + Next // Следующее кратное

end; // Конец цикла удаления

Include(PrimerSet, next);

// Получаем следующее простое, которое есть первое

// число, не вычеркнутое из исходного множества

repeat

inc(Next)

until (Next in BeginSet) or (Next > N)

end;

// Конец основного цикла

// Выводим результат:

S := '1';

for i := 2 to N do

if i in PrimerSet then

S := S+', '+IntToStr(i);

mmOutput.Lines.Add(S)

end;

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

type

SetOfNumber = set of 1..1;

и еще раз запустите программу из предыдущего примера. На экран будет выведено 1, 3, 5, 7

Множества BeginSet и PrimerSet состоят теперь из одного элемента, а программа сумела поместить в них не менее семи!

Секрет этого прост: внутреннее устройство множества таково, что каждому его элементу ставится в соответствие один двоичный разряд (один бит); если элемент включен во множество, соответствующий разряд имеет значение 1, в противном случае - 0. В то же время минимальной единицей памяти является один байт, содержащий 8 бит, поэтому компилятор выделил множествам по одному байту, и в результате мощность каждого из них стала равна 8 элементам. Максимальная мощность множества - 256 элементов. Для таких множеств компилятор выделяет по 16 смежных байт.

И еще один эксперимент: измените диапазон базового типа на 1..256. Хотя мощность этого типа составляет 256 элементов, при попытке компиляции программы компилятор сообщит об ошибке: Sets may have at most 256 elements (Множества могут иметь не более 256 элементов) т. к. нумерация элементов множества начинается с нуля независимо от объявленной в программе нижней границы. Компилятор разрешает использовать в качестве базового типа целочисленный тип-диапазон с минимальной границей 0 и максимальной 255 или любой перечисляемый тип не более чем с 256 элементами (максимальная мощность перечисляемого типа - 65536 элементов).

7.3. СТРОКИ

Для обработки текстов в Object Pascal используются следующие типы:

  • короткая строка shortString или string [n] , где n <= 255;
  • длинная строка string;
  • широкая строка WideString;
  • нуль-терминальная строка pchar.

Общим для этих типов является то, что каждая строка трактуется как одномерный массив символов, количество символов в котором может меняться в работающей программе: для string [n] длина строки меняется от 0 до n, для string и pchar - от 0 до 2 Гбайт.

В стандартном Паскале используются только короткие строки String [n] . В памяти такой строке выделяется n+i байт, первый байт содержит текущую длину строки, а сами символы располагаются начиная со 2-го по счету байта. Поскольку для длины строки в этом случае отводится один байт, максимальная длина короткой строки не может превышать 255 символов. Для объявления короткой строки максимальной длины предназначен стандартный тип ShortString (эквивалент String[255]).

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

В 32-разрядных версиях Delphi введен новый тип string, сочетающий в себе удобства обоих типов. При работе с этим типом память выделяется по мере надобности (динамически) и ограничена имеющейся в распоряжении программы доступной памятью. Замечу, что в Delphi 1 тип string эквивалентен String [2 55], т. е. определяет короткую строку максимально возможной длины.

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

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

var

ssS: String[250];// Короткая строка длиной до 250 символов

ssMax: ShortString;// Короткая строка длиной до 255 символов

stS: String; // Длинная строка

swS: WideString;// Широкая строка

pcS: PChar; // Ссылка на нуль-терминальную строку

acS: array [0..1000] of Char; // Нуль-терминальная строка

// длиной до 1000 символов

При объявлении переменной sss компилятор выделит для ее размещения 250 + 1 = 251 байт и поместит в первый байт 0 - текущую длину строки. При выполнении такого фрагмента программы:

procedure TfmExample.bbRunClick(Sender: TObject);

var

ssS: String[250];

begin

ssS :='Строка символов';

ssS[6] := 'и'; // Символы в строке нумеруются, начиная с 1 IbOutput.Caption := ssS; // Выводится “Строки символов”

end;

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

Совершенно другим будет механизм работы с памятью при объявлении длинной строки sts: компилятор выделит для переменной 4 байта, достаточные для размещения номера той ячейки памяти, начиная с которой будет фактически располагаться символьная строка. Говорят, что sts ссылается на строку. Такого рода переменные-ссылки называются указателями и обсуждаются в гл. 9. При выполнении первого оператора такого обработчика:

procedure TfmExample.bbRunClick(Sender: TObject);

var

stS, stSS: String;

begin

stS :='Строка символов';

stSS := stS;

stS := 'Это - '+stS;

stS[7] := ' c' ; // Символы в строке нумеруются, начиная с 1 IbOutput.Caption := stS; //Выводится “Это - строка символов”

end;

программа (а не компилятор!) определит длину цепочки символов Строка символов, обратится к ядру перационной системы (ОС) с требованием выделить для нее участок памяти длиной 15+5=20 байт, поместит в переменную sts номер первого выделенного байта [На самом деле в stS запоминается дескриптор выделенного участка памяти, см. гл. 9.] и, начиная с него, разместит в этом участке цепочку символов, завершив ее терминальным нулем и 4-байтным счетчиком ссылок. Такое размещение на этапе прогона программы называется динамическим, в то время как размещение на этапе компиляции - статическим. Счетчик ссылок играет важную роль в механизме работы с памятью. С его помощью реализуется “кэширование” памяти: при выполнении оператора

stSS := stS;

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

stS := 'Это - '+stS;

счетчик ссылок уменьшается на единицу, выделяется новая область памяти длиной 2 о + б = 2 б байт, указатель на эту область помещается в stS, а в саму память переписывается цепочка символов Это -строка символов, терминальный ноль и содержащий единицу счетчик ссылок. Теперь переменные stS и stss будут ссылаться на разные участки памяти, счетчики ссылок которых будут содержать по единице. Выделенная для размещения строки String область памяти освобождается, если ее счетчик ссылок стал равен нулю.

Похожим образом осуществляется работа с памятью при объявлении переменной pcs типа pchar: компилятор считает эту переменную указателем и выделит для нее 4 байта:

 

procedure TfmExample.bbRunClick(Sender: TObject);

var

pcS: PChar;

begin

pcS :='Строка символов';

pcS[5] := 'и';{Символы в нуль-строке нумеруются,начиная с 0}

IbOutput.Caption := pcS; // Выводится “Строки символов”

end;

Программа потребует от ОС 15 + 1 = 16 байт, разместит в памяти цепочку символов и завершающий ее терминальный 0 и поместит адрес выделенного участка памяти в pcs.

В стандартном паскале, при обращении к области памяти, на которую ссылается указатель , требуется за именем указателя ставить специальный символ .“^”. В Object Раsса1 интенсивно используется динамическая, память, и поэтому, это жесткое требование смягчено: в большинстве случаев (и при обращении к типу pchar в том числе) символ "^" ставить не следует.

И, наконец, последнее объявление acs как массива символов. В Object Pascal считается совместимым с pchar одномерный массив символов с нулевой нижней границей. В отличие от pcs память для такой переменной выделяется статически (в нашем примере компилятор выделит в сегменте данных для переменной acs 1001 байт).

Для размещения в acs нуль-терминальной цепочки символов используется процедура strcopy:

procedure' TfmExample.bbRunClick(Sender: TObject) ;

var

acS: array [0..1000] of Char;

begin

StrCopy(acS,'Строка символов') ;

acS[5] := 'и';{ Символы в нуль-строке нумеруются,начиная с 0}

lbOutput.Caption := acS; // Выводится “Строки символов”

end;

Необходимость в нуль-терминальных строках возникает только при прямом обращении к API-функциям ОС. При работе с компонентами Delphi в основном используются более удобные длинные строки, которые рассматриваются в п. 7.3.1.

И несколько слов о широких строках, 32-разрядные версии Windows используют три сорта символов: однобайтный символ ANSI, двухбайтный символ и символ Unicode. Однобайтный символ связан с одним из 256 возможных значений, которые трактуются в зависимости от установленной в Windows национальной страницы (для размещения кириллицы используется страница 1251). 256 символов вполне достаточны для отображения национального алфавита любого европейского языка. Для отображения алфавитов некоторых азиатских языков этого недостаточно. В этом случае используется двухбайтный символ, в котором младший байт обычно кодируется семибитным ASCII-кодом, а старший указывает, как должен трактоваться этот код (каким символом он будет изображаться в документе или на экране). Символ Unicode в памяти занимает одно слово, которое имеет 65536 возможных значений. Специальная международная комиссия по Unicode выработала соглашение, позволяющее с помощью этого кода представить все символы всех языков мира. Двухбайтные символы и символы Unicode объявляются стандартным типом widecnar, а составленные из них строки - типом widestring. Все Windows-программы, использующие OLE-технологию обмена строками, должны кодировать символы в соответствии с Unicode.

7.3.1. Типы String и ShortString

Несмотря на разницу во внутреннем представлении, короткие строки ShortString и длинные строки string имеют для программиста одинаковые свойства.

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

while (Length(stS) о 0) and (stS[Length(stS)] = ' ') do

SetLentgh(stS, Length (stS) - 1);

В этом примере стандартная процедура setLength устанавливает новую длину строки. К строкам можно применять операцию “+” -сцепление, например:

stS := 'а' + 'b'; // stS содержит "ab"

stS := stS + 'с'; // stS содержит "abc"

Если длина сцепленной строки превысит максимально допустимую длину N короткой строки, то “лишние” символы отбрасываются. Следующая программа, например, выведет символ “I”:

Procedure TfmExamlpe.bbRunClick(Sender: TObject);

var

ssS: String[1];

begin

ssS := '123';

IbOutput := ssS;

end;

Операции отношения =, <>, >, <, >=, <= выполняются над двумя строками посимвольно, слева направо с учетом внутренней кодировки символов. Если одна строка меньше другой по длине, недостающие символы короткой строки заменяются значением #о.

Следующие операции отношения дадут значение True:

'''' < '.'

'А' > '1'

'Object' < ' Object Pascal'

'Пас' > 'Pascal'

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

Таблица 7.7. Процедуры и функции для работы со строками

Function AnsiLowerCase(const S: String): String;

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

Function AnsiUpperCase(const S: String): String;

Возвращает исходную строку s, в которой все строчные буквы заменены на заглавные в соответствии с национальной кодировкой Windows

Function Concat(Sl [, S2, ..., SN]: String): String;

Возвращает строку, представляющую собой сцепление строк-параметров S1, S2, ... , SN

Function Copy(St: String; Index, Count: Integer): String;

Копирует из строки St count символов, начиная с символа с номером Index

Procedure Delete(St: String;

Index, Count:" Integers-

Удаляет count символов из строки St, начиная с символа с номером index

Procedure Insert(SubSt:

String; St, Index: Integer);

Вставляет подстроку SubSt в строку St, начиная с символа с номером Index

Function Length(St: String): Integer;

Возвращает текущую длину строки St

Function LowerCase(const S:String): String;

Возвращает исходную строку S, в которой все латинские заглавные буквы заменены на строчные

procedure OleStrToStrVar(Source: PWideChar; var Dest:String) ;

Копирует “широкую” (двухбайтную) строку в обычную строку Object Pascal

Function Pos(SubSt, St:String): Integer;

 

 

Отыскивает в строке St первое вхождение подстроки SubSt и возвращает номер позиции, с которой она начинается. Если подстрока не найдена, возвращается ноль

Procedure SetLength(St:String; NewLength: Integer); 

 

 

Устанавливает новую (меньшую) длину NewLength строки St. если NewLength больше текущей длины строки, обращение к SetLength игнорируется

function StringOfChar(Ch:Char; Count: Integer):String;

Создает строку, состоящую из Count раз повторенного символа ch 

function StringToOleStr(const Source: String):PWideChar;

Копирует обычную строку в двухбайтную 

function StringToWideChar(const Source: String; Dest:PWideChar; DestSize: Integer) : PWideChar;

Преобразует обычную строку в строку с символами UNICODE

Function Uppercase(const S:String): String;

Возвращает исходную строку S, в которой все строчные латинские буквы заменены на заглавные

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

Function StrToCurr(St: String): Currency;

Преобразует символы строки St в целое число типа Currency. Строка не должна содержать ведущих или ведомых пробелов

Function StrToDate(St: String): TDateTime;

Преобразует символы строки St в дату. Строка должна содержать два или три числа, разделенных правильным для Windows разделителем даты (в русифицированной версии таким разделителем является “.”). Первое число - правильный день, второе - правильный месяц. Если указано третье число, оно должно задавать год в формате XX или ХХХХ. Если символы года отсутствуют, дата дополняется текущим годом. Например: DateToStr(StrToDate('28.06')) даст строку '28.06.99' (см. ниже пояснения)

Function StrToDateTime(St:

String): TDateTime;

 

 

 

 

Преобразует символы строки St в дату и время. Строка должна содержать правильную дату (см. StrToDate) и правильное время (см. StrToTime), разделенные пробелом, например: StrToDateTime('28.06 18:23')

Function StrToFloat(St:String): Extended;

 

 

Преобразует символы строки St в вещественное число. Строка не должна содержать ведущих или ведомых пробелов

Function StrToInt(St:String): Integer;

Преобразует символы строки St в целое число. Строка не должна содержать ведущих или ведомых пробелов

Function StrToIntDef(St:String; Default: Integer):Integer;

 

Преобразует символы строки St в целое число.

Если строка не содержит правильного представления целого числа, возвращается значение Default

Function StrToIntRange(St:String; Min, Max: Longint):Lomgint;

Преобразует символы строки St в целое число и возбуждает исключение ERangeError, если число выходит из заданного диапазона Min.. .мах

Function StrToTime(St:String): TDateTime;

 

 

 

 

 

 

 

 

 

 

Преобразует символы строки St во время.

Строка должна содержать два или три числа, разделенных правильным для Windows раздели телем времени (для русифицированной версии таким разделителем является “:”). Числа задают часы, минуты и, возможно, секунды. За послед ним числом через пробел могут следовать символы “am” или “рm”, указывающие на 12- часовой формат времени

Procedure Val(St: String; var

X; Code: Integer);

 

 

 

 

 

 

 

 

 

 

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

Подпрограммы обратного преобразования

Function DateTimeToStr(Value: TDateTime): String; Procedure DateTime-ToString(var St: String; Format: String;- Value: TData-Time);

Преобразует дату и время из параметра в строку символов Преобразует дату и время из параметра value в строку St в соответствии со спецификаторами параметра Format (см. пояснения ниже)

Function DateToStr(Value: TDateTime): String;

Преобразует дату из параметра value в строку символов

Function FloatToStr(Value: Extended): String;

Преобразует вещественное значение value в строку символов.

Function FloatToStrF(Value:

Extended; Format: TFloatPor-

mat; Precision, Digits: Inte

ger) : String;

Преобразует вещественное значение Value в строку символов с учетом формата Format и параметров precision и Digits (см. пояснения ниже).

Function Format(const Format: String; const Args: array of const): Strings;

 

 

Преобразует произвольное количество аргументов открытого массива Args в строку в соответствии с форматом Format (см. пояснения ниже)

Function FormatDateTime (Format: String; Value:.TDateTime): String;

Преобразует дату и время из параметра value в строку символов в соответствии со спецификаторами параметра Format (см. пояснения ниже)

Function FormatFloat(Format:String; Value: Extended): String;

Преобразует вещественное значение value в строку символов с учетом спецификаторов формата Format (см. пояснения ниже)

function IntToHex(Value: Integer; Digits: Integer):Strings;

Преобразует целое число Value в строку символьного представления шестнадцатеричного формата: Digits - минимальное количество символов в строке

Function IntToStr(Value: Integer) : String;

Преобразует целое значение Value в строку символов

Procedure Str(X [:Width[:Decimals]]; var St:String) ;

 

 

 

Преобразует число х любого вещественного илицелого типов в строку символов St; параметры width и Decimals, если они присутствуют, задают формат преобразования: width определяет общую ширину поля, выделенного под соответ ствующее символьное представление вещественного или целого числа х, a Decimals - количество символов в дробной части (этот параметр имеет смысл только в том случае, когда х -вещественное число)

Function TimeToStr(Value: TDateTime): String;

Преобразует время из параметра Value в строку символов

 

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

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

procedure TfmExample.bbRunClick (Sender : TObject) ;

var S: String;

begin

S:=FloatToStrF(1000,ffNumber,4,0);

EdOutput.Yext:=IntToStr(Ord(S[2]));

end;

Если вы действительно хотите использовать пробел, его нужно явно указать в окошке. Разделитель: групп разрядов (Пуск.| Настройка | Панель управления | Язык и стандарты | Числа)

В Delphi 4...6 изменена функция StrToDate для того, чтобы упростить ввод двух цифр года с учетом смены столетия. С этой целью в модуле system введена глобальная переменная TwoDigitYearCenturywindow, которая определяет цифровой рубеж столетия. Если две цифры года больше или равны значению этой переменной, цифры года относятся к текущему столетию, если меньше - переносятся в следующее. Пусть, например, TwoDigitYearCenturywindow содержит значение 50. Тогда любые две цифры года в диапазоне 00..49 дополняются базой 2000 (2000, 2001,...,2049), в то время как цифры в диапазоне 50..99 дополняются базой 1900 (1950, 1951,...,1999). Такой прием позволяет в известной мере смягчить проблему двухцифровых годов на рубеже столетия, однако полным ее решением будет, разумеется переход на четырехцифровое представление года. По умолчанию TwoDigitYearCenturywindow имеет значение 0, и поэтому любые две цифры года дополняются базой 1900.

Используемая в процедуре DateTimeToString и в функции FormatDateTime строка Format может содержать такие символы-спецификаторы (в примерах показаны строки для времени 19 часов 45 минут и даты 8 июня 1999 года):

Таблица 7.8. Спецификаторы формата даты/времени

с

  

Отображает сначала дату в формате дд.мм.гг, затем пробел и время в формате чч.мм. ее: 08.06. 99 19:45

d

Отображает день без ведущего нуля: 8

dd

Отображает день с ведущим нулем: 0 8

dddd

Отображает день недели: воскресенье (для нерусифицированной версии Windows - Sunday)

ddddd

Отображает дату в формате дд. мм. гг: 08.06.99

dddddd

Отображает дату в формате д Месяц год: 8 Июнь 1999 (для нерусифицированной версии Windows - 8 June 1999)

m

Отображает число месяца без ведущего нуля: 6

mm

Отображает число месяца с ведущим нулем: 06

nunm

Отображает сокращенное название месяца: июн.

nuninm

Отображает полное название месяца: Июнь

у или уу

Отображает две последние цифры года: 9 9

ууу или уууу

Отображает все цифры года: 1999

h

Отображает час без ведущего нуля: 19

hh

Отображает час с ведущим нулем: 19

n

Отображает минуты без ведущего нуля: 4 5

nn

Отображает минуты с ведущим нулем: 4 5

s

Отображает секунды без ведущего нуля: 0

ss

Отображает секунды с ведущим нулем: 00

t

Отображает время в формате чч:лш: 19:45

tt

Отображает время в формате чч:мм:сс: 19:45:00

am/pm

Отображает время в 12-часовом формате (am - до полудня, pm - после полудня). Для спецификаторов hh: mm am/pm получим 07:45 pm

ampm

Отображает время в 12-часовом формате, но без указания до/после полудня. Для спецификаторов hh: mm ampm получим 07:45

a/p

Отображает время в 12-часовом формате (а - до полудня, р - после полудня). Для спецификаторов hh: mm a/p получим 07:45 р

/

Отображает используемый в Windows разделитель даты. Для спецификаторов d/m/у получим 8. 6. 99

:

Отображает используемый в Windows разделитель времени. Для спецификаторов h:n: s получим 19:45:0

 Замечу, что любые другие символы, указанные в строке Format, a также заключенные в апострофы или кавычки специальные символы-спецификаторы помещаются в выходную строку без преобразования, поэтому спецификаторы 'h час n мин' дадут строку 19 час 45 мин, а 'h час "n" мин' - 19час n мин.

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

Таблица 7.9. Системные переменные, управляющие стандартным отображением данных

CurrencyString: String;

 

Символ или символы денежной единицы; для русифицированной Windows ими являются символы “р. ”

CurrencyFormat: Byte; 

 

Определяет положение символов денежной единицы: 0 - $1; 1 - 1$; 2 - $ 1; 3 - 1 $; в русифицированной Windows используется формат 1 (1р.)

NegCurrFormat: Byte;

Определяет формат отрицательной суммы: 0 = ($1); 1 = -$1; 2 = S-1; 3 = $1-; 4 = (1$); 5 = -1$; 6 = 1-$; 7 =1$-; 8=-!$; 9=-$!; 10=1 $-; 11 =$1-; 12=$-!; 13= 1- $; 14 = (S 1); 15 = (1 $); в русифицированной Windows используется формат 5 (-lp.)

ThousandSeparator: Char; 

Разделитель тысяч; в русифицированной Windows используется символ #166

DecimalSeparator: Char;

Разделитель дробной и целой частей числа (', ')

CurrencyDecimals: Byte; 

 

 

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

DateSeparator: Char;

Разделитель даты; в русифицированной Windows используется ' . '

ShortDateFormat: String;   

 

 

 

Обычно используется формат ' dd. mm. уу ', что соответствует, например, дате '31.05.00'. По скольку на рубеже столетий цифры года в таком формате кажутся неверными, я советую в начале каждой программы вставлять оператор Short-DateFormat := 'dd.mm.yyyy'; это даст '31.05.2000'

LongDateFormat: String; 

Для русифицированной версии содержит символы 'dd MMMM yyyy г.',что дает'31 Май 2000 г. '

TimeSeparator: Char;

Разделитель времени (' : ')

TimeAMString: String; 

 

Символы 12-часового формата для времени до полудня (не используются в русифицированной версии Windows)

TimePMString: String; 

 

Символы 12-часового формата для времени после полудня (не используются в русифицированной версии Windows)

ShortTimeFormat: String;

Краткий формат времени (обычно ' h: mm ')

LongTimeFormat: String;

Полный формат времени (обычно ' hh: mm: ss ')

ShortMonthNames: array

[1..12] of String;

Краткие имена месяцев (янв, фев, мар, апр, май, июн, июл, авг, сен, окт, ноя, дек)

LongMonthNames: array

[1..12] of String; 

Полные имена месяцев (Январь, Февраль, Март, Апрель, Май, Июнь, Июль, Август, Сентябрь, Октябрь, Ноябрь, Декабрь)

ShortDayNames: array [1..7] of String;

Краткие имена дней недели (Вс, Пн, Вт, Ср, Чт, Пт, Сб)

LongDayNames: array [1..7] of String; 

 

Полные имена дней недели (воскресенье, понедельник, вторник, среда, четверг, пятница, суббота)

type TSysLocale = packed record DefaultLCID: LCID; PriLangID: LANGID;

SubLangID: LANGID;

FarEast: Boolean;

MiddleEast: Boolean; 

end;

var SysLocale: TSysLocale;

Определяет локализацию Windows: DefaultLCID- идентификатор локализации (1049); PriLangID- идентификатор первичного языка (25); SubLangID - идентификатор вторичного языка (если в качестве второго языка используется английский (США), это поле имеет значение 1); Far-East - локализация для Дальнего Востока (False): MiddleEast - локализация для Среднего Востока(False)

EraNames: array [1..7] of String;

Используется в функции DateTimeToStr в Windows для Ближнего Востока

EraYearOffsets: array [1..7] of Integer;

Используется в функции DateTimeToStr в Windows для Ближнего Востока

TListSeparator: Char;

Разделитель списка строк ('; ')

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

procedure WeekToDates(aDate: TDateTime; var Week: Byte;var Year: Word; var FirstDate, LastDate: TDateTime);

{Возвращает для указанной даты aDate год Year, номер недели от начала года Week, а также даты начала и конца недели} var

S: String;

begin

//Получаем в S символы года для даты aDate:

DateTimeToString(S,'yyyy',aDate) ;

//Формируем дату 1 января:

FirstDate := StrTo-Date('01'+DateSeparator+'01'+DateSeparator+S) ;

Year := StrToInt(S); //Возвращаем год

//Формируем последнюю дату 1-й недели:

LastDate := FirstDate;

DateTimeToString(S,'dddd',LastDate) ;

while SOLongDayNames [1] do

// LongDayNames [1 ]= 'воскресенье '

begin

LastDate := LastDate+1;

DateTimeToString(S,'dddd',LastDate);

end;

Week := 1;

//Циклически наращиваем FirstDate, LastDate и Week, пока

// LastDate не станет больше или равна aDate:

while LastDate<aDate do

begin

inc(Week);

FirstDate := FirstDate+7;

LastDate := LastDate+7

end

end; // WeekToDates

Для форматного преобразования вещественных чисел предназначены функции FloatToStrF и FormatFloat. Первая использует значение Format перечисляемого типа TFloatFormat и два дополнительных параметра - Precision и Digits. Правила использования параду метров функции FloatToStrF показаны в следующей таблице' (примеры преобразования даются для value = П = 3,141593654, Precision = 5 и Digits = 2):

Таблица 7.10. Правила использования параметров функции FloatToStrF

Значение Format

Описание

ffExponent

Научная форма представления с множителем ехх (“умножить на 10 в степени XX”). precision задает общее количество десятичных цифр мантиссы, Digits - количество цифр в десятичном порядке хх. Число округляется с учетом первой отбрасываемой цифры:3,1416Е+00

ff Fixed

Формат с фиксированным положением разделителя целой и дробной частей, precision задает общее количество десятичных цифр в представлении числа. Digits - количество цифр в дробной части. Число округляется с учетом первой отбрасываемой цифры:3,14

ff General

Универсальный формат, использующий наиболее удобную для чтения форму представления вещественного числа. Соответствует формату ff Fixed, если количество цифр в целой части меньше или равно precision, а само число - больше или равно 0,00001, в противном случае соответствует формату ff Exponent: 3,1416

ffNumber

Отличается от ffFixed использованием символа-разделителя тысяч при выводе больших чисел (для русифицированной версии Windows таким разделителем является пробел). Для value = П *1000 получим 3 141,60

ffCurrency

Денежный формат. Соответствует ffNumber, но в конце строки ставится символ денежной единицы (для русифицированной версии Windows - символы “р.”). Для value = я*1000 получим 3 141,60р.

Параметр Format в функции FormatFloat может содержать такие спецификаторы:

Таблица 7.11. Спецификаторы форматирования вещественных чисел

;

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

0

Определяет поле для цифры. Если в данной позиции форматируемое число имеет значащую цифру, она выводится, если нет - выводится 0

#

Определяет поле для цифры. Если в данной позиции форматируемое число имеет значащую цифру, она выводится, если нет - ничего не выводится

.

Поле для разделителя целой и дробной частей числа

,

Поле для разделителя тысяч

E+,e+

E-,e-

Признак представления числа в научном формате. В этом случае число представляется мантиссой и десятичным порядком, между которыми стоит символ Е. Спецификаторы е+ и е+ предписывают выводить знак + перед неотрицательным десятичным порядком, при использовании Е- и е- знак + перед порядком не выводится

Как и в случае даты/времени, любые другие символы строки Format, а также заключенные в апострофы или кавычки специальные символы-спецификаторы помещаются в выходную строку без преобразования: для value = 71*1000 спецификаторы'#, рубля' дадут строку 3 142 рубля. С помощью символа “;” можно задавать различные формы представления положительного, отрицательного и нулевого числа. При этом набор спецификаторов без “;” относится ко всем числам; если используется один символ “;”, то спецификаторы слева от него применяются для форматирования положительных чисел, справа - отрицательных, а вывод нулей подавляется; при использовании двух символов “; ” первый набор - для положительных, второй - для отрицательных и третий - для нулевых чисел. Например, спецификаторы '#;нуль' для value = -1 выведут нуль, а для value = о ничего не выведут, в то время как спецификаторы '#;00;нуль' для value = -1 выведут 01, а для value = 0 - строку нуль. Спецификаторы '#;;нуль' для value = -1 выведут -1, т. к. в этом случае спецификатор для отрицательных чисел не задан и для их вывода будет использован спецификатор положительных чисел, в то время как спецификаторы '#; ;нуль' подавляют вывод отрицательных чисел.

Мощная функция преобразования Format (табл. 7.7) перешла в Object Pascal из языка Си. Она позволяет преобразовать сразу несколько элементов открытого массива аргументов в соответствии с указаниями форматирующей строки. Например, Format('Строка "%s" содержит %d символов',['Паскаль',7]) даст такой результат: Строка "Паскаль" содержит 7 символов.

Элементами массива аргументов могут быть константы и/или переменные целого и вещественного типа, строки и указатели.

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

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

"%" [index ":"] ["-"] [width] ["." prec] type

Здесь: index ":" - индекс открытого массива, с помощью этого элемента можно явно указать аргумент, который будет обрабатывать спецификатор; "-" указывает на необходимость прижать отформатированный спецификатором текст к левой границе отведенного для него пространства; width - число, определяющее количество символов для обработанного спецификатором текста; если это число меньше требуемого, этот элемент спецификатора игнорируется, если больше - дополняется справа (если есть элемент "-") или слева (если он отсутствует) нужным количеством пробелов; "." prec - задает точность представления целых и вещественных типов; type - символ, определяющий тип форматирования (см. таблицу ниже).

Таблица 7.12. Форматирующие спецификаторы для функции Format

d

 

 

Целое десятичное число. Если задан параметр ргес, то символьное представле

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

Беззнаковое целое число. Используется подобно типу d, но аргумент должен быть положительным числом. Если аргумент - отрицательное целое, результат форматирования непредсказуем

е

 

 

Вещественное число в экспоненциальном представлении: символьное представление имеет вид -d, dddddddddddE+ddd. Если число положительное, ведущий минус опускается, а если его модуль меньше 1, знак плюс меняется на минус. Всегда содержит одну цифру целой части, по меньшей мере одну цифру дробной части и не меньше трех цифр десятичного порядка. Если задан параметр точности, он определяет общее количество цифр до символа Е, но не меньше двух: если параметр точности содержит 1 или 0, он заменяется на 2. Если символьное представление содержит больше символов, чем ргес, оно округляется по первой отбрасываемой цифре. Умалчиваемое значение параметра точности 15

 

Вещественное число в виде -ddd, ddd (фиксированное представление). Параметр точности (по умолчанию 2) указывает количество цифр в дробной части. Если он 0, выводится только целая часть числа

g  

 

 

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

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

Денежное представление вещественного числа. Подобно типу n, но справа ставится знак денежной единицы

p

Указатель. Выводит содержимое указателя в виде 8 шестнадцатеричных цифр

s

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

x

Шестнадцатеричное представление целого числа. Параметр точности определяет минимальное количество шестнадцатеричных цифр (если число меньше, оно дополняется ведущими нулями)

Функция не чувствительна к высоте букв, указывающих тип преобразования. Параметры index, ргес и width задаются явно (числами в форматирующей строке) или неявно - с помощью символа “*”. В этом случае в качестве параметра берется значение очередного аргумента в списке аргументов (он должен быть целым числом). Например, два следующих обращения дадут одинаковый результат:

Format ('%*.*f, [8, 2, 123.456]);

Format ('%8.2f, [123.456]);

7.3.2. Нуль-терминальные строки

Нуль-терминальные строки широко используются при обращениях к так называемым API-функциям Windows (API - Application Program Interface - интерфейс прикладных программ). Поскольку компоненты Delphi берут на себя все проблемы связи с API-функциями Windows, программисту редко приходится прибегать к нуль-терминальным строкам. Тем не менее в этом разделе описываются особенности обработки таких строк.

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

procedure TfmExample.FormActivate(Sender: TObject);

var

pcS: PChar;

ssS: String;

begin

pcS := '123456';

ssS := 'X = ';

IbOutput.Caption := ssS + pcS;

end;

В строке IbOutput будет выведено х = 123456. Другой пример. В состав API-функцией входят функция MessageBox, с помощью которой на экране создается диалоговое окно с заголовком, текстовым сообщением и набором кнопок. Если в конце предыдущего примера добавить оператор

MessageBox(0, ssS + pcS, 'Заголовок окна', mb_0k);

то компилятор укажет на ошибку, т. к. вторым параметром обращения к функции должно быть выражение типа PChar, в то время как выражение sss+pcs приводится компилятором к общему типу String. Правильным будет такое обращение:

MessageBox(0, PChar (ssS + pcS), 'Заголовок окна', mb_0k) ;

Текстовые константы совместимы с любым строковым типом, поэтому третий параметр обращения (он тоже должен быть типа PChar) компилятор обработает без ошибок.

В Delphi считается совместимым с pchar и string массив символов с нулевой нижней границей. В отличие от pchar и String такой массив распределяется статически (на этапе компиляции), поэтому наполнение массива символами и завершающим нулем осуществляется специальной процедурой Strcopy:

procedure TfmExample.bbRunClick(Sender:TObject);

var

acS: array [0..6] of Char;

begin

StrCopy(acS, '123456');

IbOutput.Caption := acS;

end;

Для работы с типом pchar используются такие же операции, как и с типом String: операция конкатенации “+” и операции сравнения >, >=, <, <=, =, <>.

Таблица 7.13. Подпрограммы для работы с нуль-терминальными строками

Function CharToOem

(Str, OemStr: PChar):

Bool;

Преобразует символы строки Str из кодировки ANSI в кодировку MS-DOS и помещает результат в OemStr.Всегда возвращает True

Function CharToOemBuff(Str, OemStr: PChar; MaxLen: Lorigint): Bool;

Преобразует не более MaxLen символов строки Str из кодировки ANSI в кодировку MS-DOS и помещает результат в OemStr. Всегда возвращает True

Function OemToChar (OEMStr, Str: PChar): Bool;

Преобразует символы из кодировки MS-DOS в кодировку ANSI и возвращает True

Function OemToCharBuff(OEMStr, Str: PChar;MaxLen: Longint): Bool;

Преобразует не более MaxLen символов строки OemStr из кодировки MS-DOS в кодировку ANSI и помещает результат в Str. Всегда возвращает True

Function StrCat(Dest,Source: PChar): PChar;

Копирует строку Source в конец строки Dest и возвращает указатель на строку Dest

Function StrComp (Strl,Str2: PChar): Integers;

Побайтно сравнивает строку Strl со строкой Str2 и возвращает следующий результат: =0 для Strl=Str2; >0 для Strl>Str2,- 0 для Strl<Str2

Function StrCopy(Dest,Source: PChar): PChar;

Копирует строку Source в строку Dest и возвращает указатель на Dest. StrCopy не проверяет реальный размер памяти, связанный с Dest (он должен быть не меньше StrLen(Source)+1)

Procedure StrDispose(Str: PChar) ; 

Удаляет строку Str из памяти. Строка должна быть предварительно помещена в память функцией StrNew. Если Str=NlL, процедура ничего не делает

Function StrECopy(Dest, Source: PChar): PChar; 

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

Function StrEnd(Str:

PChar): PChar;

Функция возвращает указатель на терминальный нольстроки Str

Function StrIComp(Strl,Str2: PChar): PChar; 

 

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

Function StrLCat(Dest,Source: PChar; MaxLen:Word): PChar;

 

 

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

Function StrLComp(Dest,

Source: PChar; MaxLen:

Word): PChar;

В отличие от StrComp сравнивает не более MaxLen символов строк. Возвращаемый результат такой же, как и у StrComp

Function StrLCopy(Dest,

Source: PChar; MaxLen:

Word): PChar; 

Копирует символы из строки Source в строку Dest до тех пор, пока не будет скопирована вся строка или пока не будет скопировано MaxLen символов. В отличие от StrCopy блокирует возможное переполнение области памяти, связанной с Dest. В качестве MaxLen обычно используется выражение SizeOf(Dest)-1

Function StrLen(Str:PChar): Cardinal;

Возвращает длину строки 

 

Function StrLIComp(Strl, Str2: PChar; MaxLen: Word): PChar; 

Сравнивает не более MaxLen символов строк, проверяя точное соответствие высоты букв. Возвращаемый результат см. StrComp. Функция правильно работает только с латиницей

Function StrLower(Str:

PChar): PChar;

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

Function S t rMove(Dest,

Source: PChar; Count:Word): PChar;

Копирует точно Count символов строки Source в строку Dest и возвращает указатель на результат. Функция игнорирует действительные размеры строк и может выйти за их пределы

Function StrNew(Str:PChar): PChar;

Помещает строку в память

Function StrPas(Str:PChar): String;

Преобразует нуль-терминальную строку в строку String

Function StrPCopytStr: PChar; S: String):PChar;

Преобразует строку String в нуль-терминальную строку. Возвращает указатель на Str

Function StrPos(Strl,

Str2: PChar): PChar;

Ищет подстроку Str2 в строке Strl и возвращает указатель на первое вхождение Str2 или MIL, если подстрока не найдена

Function StrRScan(Str:

PChar; Ch: Char):PChar;

Ищет символ Ch в строке Str и возвращает указатель напоследний обнаруженный символ Ch или NIL, если символ не найден

Function StrScan(Str:PChar; Ch: Char):PChar;

Ищет символ Ch в строке Str и возвращает указатель на первый обнаруженный символ Ch или MIL, если символ не найден

Function StrUpper (Str: PChar) : PChar

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

Функции преобразования из ANSI-кодировки в кодировку MS-DOS (charToxxx) и обратно (OеmTоххх) правильно работают с кириллицей, если в MS-DOS используется национальная страница 866 (так называемая альтернативная кодировка). А вот четыре функции, использующие преобразование высоты букв (strLower, StrUpper, Stricomp и StrLIComp), работают корректно только для букв латинского алфавита (латиницы). Для русских букв вместо обращения к этим функциям следует использовать стандартные функции AnsiLowerCase И AnsiUpperCase, которые используют как параметры String, так и PChar, но возвращают результат типа string:

var

acS: array [Byte] of Char;

begin

StrCopy(acS, 'заглавные буквы');

Caption := AnsiUpperCase(acS) end;

Аналогично для функции Stricomp:

var

apSl,apS2: array [0..1000] of Char;

begin

StrCopy(apSl,'эталон');

StrCopy(apS2,'ЭТАЛОН') ;

Caption := IntToStr(StrIComp(PChar(AnsiUpperCase(apSl)),

PChar(AnsiUpperCase(apS2))))

end;

7.4. УКАЗАТЕЛИ И ДИНАМИЧЕСКАЯ ПАМЯТЬ

7.4.1. Динамическая память

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

7.4.2. Указатели

Оперативная память ПК представляет собой совокупность ячеек для хранения информации - байтов, каждый из которых имеет собственный номер. Эти номера называются адресами, они позволяют обращаться, к любому байту памяти. Object Pascal предоставляет в распоряжение программиста гибкое средство управления динамической памятью - так называемые указатели. Указатель - это переменная, которая в качестве своего значения содержит адрес байта памяти. С помощью указателей можно размещать в динамической памяти любой из известных в Object Pascal типов данных. Лишь некоторые из них (Byte, Char, ShortInt, Boolean) занимают во внутреннем представлении один байт, остальные - несколько смежных. Поэтому на самом деле указатель адресует лишь первый байт данных.

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

var

p1 : ^Integer;

р2 : ^Real;

type

PerconPointer = "PerconRecord;

PerconRecord = record Name : String;

Job : String;

Next : PerconPointer ,

end;

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

В Object Pascal можно объявлять указатель и не связывать его при этом с каким-либо конкретным типом данных. Для этого служит стандартный тип pointer, например:

var

р: Pointer;

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

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

Если, например,

var

pI1,pI2: ^integer;

pR: ^Real;

p: Pointer;

то присваивание

pI1 := pI2;

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

pl1 :=pR;

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

p := pR;

pI1 := p;

и тем самым достичь нужного результата.

7.4.3. Выделение и освобождение динамической памяти

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

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

var pI,pJ: ^Integer;

pR: ^Real;

begin

New (pI) ;

New (pR) ;

end;

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

pJ^ := 2; // В область памяти pJ помещено значение 2

pl^ := 2*pi; // В область памяти pR помещено значение 6.28

Таким образом, значение, на которое указывает указатель, т. е. собственно данные, размещенные в куче, обозначаются значком ^, который ставится сразу за указателем. Если за указателем нет значка ^, то имеется в виду адрес, по которому размещены данные. Имеет смысл еще раз задуматься над только что сказанным: значением любого указателя является адрес, а чтобы указать, что речь идет не об адресе, а о тех данных, которые размещены по этому адресу, за указателем ставится ^ (иногда об этом говорят как о разыменовании указателя).

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

рR^ := Sqr(pR") + I^ - 17;

Разумеется, совершенно недопустим оператор

pR := Sqr(pR") + I^ - 17;

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

pR^ := Sqr(pR) ;

поскольку значением указателя pR является адрес и его (в отличие от того значения, которое размещено по этому адресу) нельзя возводить в квадрат. Ошибочным будет и такое присваивание:

pR^' := pJ;

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

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

Dispose(pJ);

Dispose(pR);

вернут в кучу память, которая ранее была закреплена за указателями pJ и pR (см. выше).

Замечу, что процедура Dispose (pPtr) не изменяет значения указателя pPtr, а лишь возвращает в кучу память, ранее связанную с этим указателем. Однако повторное применение процедуры к свободному указателю приведет к возникновению ошибки периода исполнения. Освободившийся указатель программист может пометить зарезервированным словом nil. Помечен ли какой-либо указатель или нет, можно проверить следующим образом:

const

pR: ^Real = NIL;

begin

if pR = NIL then

New (pR) ;

Dispose(pR) ;

pR := NIL;

end;

Никакие другие операции сравнения над указателями не разрешены.

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

Как уже отмечалось, параметром процедуры New может быть только типизированный указатель. Для работы с нетипизированными указателями используются Процедуры GetMem И FreeMem:

GetMem(P, Size); // резервирование памяти;

FreeMem(P, Size); // освобождение памяти.

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

Испoльзoвaние прцeдyp GetMem/FreeMemMem, как и вообще вся работа диамияесжой памятью, требует особой осторожности и тщателвного солюдения простого правила: освобождать нужно ровно столько пайти, сколько её было зарезервировано, и именно с того адреса, с которого она была зарезёрвирована.

7.4.4. Процедуры и функции для работы с динамической памятью

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

Таблица 7.14. Средства Object Pascal для работы с памятью

Function Addr(X):

Pointer;

Возвращает адрес аргумента X. Аналогичный результат возвращает операция @

Procedure Dispose (var P: Pointer) ;

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

Procedure Free-Mem(var P: Pointer; Size: Integer) ;

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

 

Procedure Get-Mem(var P: Pointer; Size: Integer) ;

Резервирует за нетипизированным указателем Р фрагментдинамической памяти требуемого размера Size  

Procedure New(var P: Pointer) ;

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

Function SizeOf(X): Integer;

Возвращает длину в байтах внутреннего представления указанного объекта Х

 

Windows имеет собственные средства работы с памятью. В табл. 7.15 перечислены соответствующие API-функции и даны краткие пояснения. За более полной информацией обращайтесь к справочной службе в файлах WIN32. hlp или WIN32S. hlp.

Таблица 7.15. Средства Windows для работы с памятью

CopyMemory

 

Копирует содержимое одного блока памяти в другой блок.

Блоки не должны перекрываться хотя бы частично

FillMemory

Заполняет блок памяти указанным значением

GetProcessHeap

Возвращает дескриптор кучи для текущей программы

GetProcessHeaps

Возвращает дескрипторы куч для всех работающих программ

GlobalAlloc

Резервирует в куче блок памяти требуемого размера

GlobalDiscard

Выгружает блок памяти

GlobalFlags

Возвращает информацию об указанном блоке памяти

GlobalFree 

Освобождает блок памяти и возвращает его в общий пул памяти

GlobalHandle 

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

GlobalLock

Фиксирует блок памяти и возвращает указатель на его первый байт

GlobalMemoryStatus

 

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

GlobalReAlloc  

Изменяет размер и атрибуты ранее зарезервированного блока памяти

GlobalSize

Возвращает размер в байтах блока памяти

GlobalUnlock

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

HeapAlloc

Резервирует в куче неперемещаемый блок памяти

HeapCompact

Удаляет фрагментацию кучи

HeapCreate

Создает для программы новую кучу

HeapDestroy

Возвращает кучу в общий пул памяти

HeapFree

 

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

HeapAlloc или HeapReAlloc

HeapLock

Делает указанную кучу доступной только для текущего потока

HeapReAlloc

Изменяет размер и/или свойства кучи

HeapSize

Возвращает размер кучи в байтах

HeapUnlock 

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

HeapValidate

Проверяет состояние кучи или размещенного в ней блока памяти

IsBadCodePtr 

 

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

IsBadHugeReadPtr

 

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

IsBadHugeWritePtr 

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

IsBadReadPtr

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

IsBadStringPtr

Сообщает, может ли программа читать содержимое строки, распределенной в куче

IsBadWritePtr

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

LocalAlloc

Аналогична GlobalAlloc

:: LocalDiscard

Аналогична GloalDiscard

'LocalFlags

Аналогична GlobalFlags

LocalFree

Аналогична Global Free

LocalHandle

Аналогична GlobalHandle

LocalLock

Аналогична GlobalLock

LocalReAlloc

Аналогична GlobalReAlloc

LocalSize

Аналогична GlobalSize

LocalUnlock

Аналогична GlobalUnlock

MoveMemory 

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

VirtualAlloc

Резервирует блок виртуальной памяти

VirtualFree

Освобождает блок виртуальной памяти

VirtualLock

Фиксирует блок виртуальной памяти

VirtualProtect 

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

VirtualProtectEx

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

VirtualQuery 

Возвращает свойства виртуального блока памяти по отношению к вызывающей программе

VirtualQueryEx

Возвращает свойства виртуального блока памяти по отношению к указанной программе

VirtualUnloc'k

Снимает фиксацию блока виртуальной памяти

ZeroMemory

Заполняет блок памяти нулями

 

7.5. ПСЕВДОНИМЫ ТИПОВ

Для любого типа можно объявить сколько угодно псевдонимов. Например:

type

TMyInteger = Integer;

В дальнейшем псевдоним можно использовать так же, как и базовый тип:

var

Mylnt: TMyInteger;

begin

Mylnt := 2*Round(pi);

end;

Такого рода псевдонимы обычно используются для повышения наглядности кода программы. Однако в Object Pascal можно объявлять строго типизированные псевдонимы добавлением зарезервированного слова type перед именем базового типа:

type

TMyIntegerType = type Integer;

var

MylntVar: TMyIntegerType;

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

function MylntFunc(APar: integer): Integer;

begin

end;

то такое обращение к ней

MylntFunc(MylntVar)

будет расценено компилятором как ошибочное.

Строго типизированные псевдонимы заставляют компилятор вырабатывать информацию о типе для этапа прогона программы (RTTI - Run-Time Type Information). Эта информация обычно используется средой Delphi для обеспечения функционирования разного рода редакторов свойств и программ-экспертов.



e-mail рассылки
Радиолюбитель
Подписаться письмом
Найти DataSheet!





Rambler's Top100