Кирилл Сурков
Александр Вальвачев, Дмитрий Сурков, Юрий Четырько
дата публикации 18-11-2005 07:22

---

Версия для печати

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

Writeln('Я тебя люблю');

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

Writeln('Object Pascal is Delphi''s and Kylix''s language');

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

Writeln('Copyright '#169' А.Вальвачев, К.Сурков, Д.Сурков, Ю.Четырько');

Writeln('');

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

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

var
  FileName: string;
  EditText: AnsiString;

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

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

type
  TName = string;
var
  Name: TName;
const
  FriendName: TName = 'Alexander';

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

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

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

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

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

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

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

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

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

var
  Address: ShortString;
  Person: string[30];

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

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

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

type
  TName = string[30];
var
  Name: TName;
const
  FriendName: TName = 'Alexander';

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

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

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

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

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

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

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

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

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

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

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

resourcestring
  SCreateFileError = 'Cannot create file: ';
  SOpenFileError = 'Cannot open file: ';

var
  S: string;
begin
  S := SCreateFileError + 'MyFile.txt';
  ...
end;

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

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

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

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

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

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

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

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

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

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

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

• AdjustLineBreaks(const S: string): string - возвращает копию строки S, в которой все мягкие переносы строк (одиночные символы #13 или #10) заменены жесткими переносами строк (последовательность символов #13#10).



• AnsiCompareStr(const S1, S2: string): Integer - сравнивает две строки, делая различие между заглавными и строчными буквами; учитывает местный язык. Возвращаемое значение меньше нуля, если S1 < S2, равно нулю, если S1 = S2, и больше нуля, если S1 > S2.



• AnsiCompareText(const S1, S2: string): Integer - сравнивает две строки, не делая различий между заглавными и строчными буквами; учитывает местный язык. Возвращаемое значение меньше нуля, если S1 < S2, равно нулю, если S1 = S2, и больше нуля, если S1 > S2.



• AnsiDequotedStr(const S: string; Quote: Char): string - удаляет специальный символ, заданный параметром Quote, из начала и конца строки и заменяет парные спецсимволы на одиночные; если специальный символ отсутствует в начале или конце строки, то функция возвращает исходную строку без изменений.



• AnsiExtractQuotedStr(var Src: PChar; Quote: Char): string - делает то же, что и функция AnsiDequotedStr, но результат возвращается вместо исходной строки, которая имеет тип PChar.



• AnsiLowerCase(const S: string): string - преобразует заглавные буквы строки S к строчным буквам с учетом местного языка.



• AnsiPos(const Substr, S: string): Integer - выполняет те же действия, что и функция Pos, но в отличие от нее поддерживает работу с многобайтовой MBCS-кодировкой.



• AnsiQuotedStr(const S: string; Quote: Char): string - преобразует строку, заменяя все вхождения специального символа, заданного параметром Quote, на парные спецсимволы, а также помещает специальный символ в начало и конец строки. Поддерживает работу с MBCS-кодировкой.



• AnsiSameCaption(const Text1, Text2: string): Boolean - сравнивает две строки, не делая различие между заглавными и строчными буквами, а также не учитывая символ '&'; учитывает местный язык.



• AnsiSameStr(const S1, S2: string): Boolean - сравнивает строки, делая различие между строчными и заглавными буквами; учитывает местный язык.



• AnsiSameText(const S1, S2: string): Boolean - сравнивает строки, не делая различие между строчными и заглавными буквами; учитывает местный язык.



• AnsiUpperCase(const S: string): string - преобразует все строчные буквы в заглавные; учитывает местный язык.



• CompareStr(const S1, S2: string): Integer - выполняет сравнение двух строк, делая различие между строчными и заглавными буквами; не учитывает местный язык. Возвращаемое значение меньше нуля, если S1 < S2, равно нулю, если S1 = S2, и больше нуля, если S1 > S2.



• CompareText(const S1, S2: string): Integer - выполняет сравнение двух строк, не делая различий между строчными и заглавными буквами; не учитывает местный язык. Возвращаемое значение меньше нуля, если S1 < S2, равно нулю, если S1 = S2, и больше нуля, если S1 > S2.



• DateTimeToStr(const DateTime: TDateTime): string - преобразует значение даты и времени в строку.



• DateTimeToString(var Result: string; const Format: string; DateTime: TDateTime) - преобразует значение даты и времени в строку, выполняя при этом форматирование в соответствии со значением строки Format. Управляющие символы строки Format подробно описаны в справочнике по среде Delphi.



• DateToStr(const DateTime: TDateTime): string - преобразует числовое значение даты в строку.



• Format(const Format: string; const Args: array of const): string - форматирует строку в соответствии с шаблоном Format, заменяя управляющие символы шаблона на значения элементов открытого массива Args. Управляющие символы подробно описаны в справочнике по среде Delphi.



• FormatDateTime(const Format: string; DateTime: TDateTime): string - преобразует значение даты и времени в строку, выполняя при этом форматирование в соответствии со значением строки Format. Управляющие символы строки Format подробно описаны в справочнике по среде Delphi.



• BoolToStr(B: Boolean; UseBoolStrs: Boolean = False): string - преобразует булевское значение в строку. Если параметр UseBoolStrs имеет значение False, то результатом работы функции является одно из значений '0' или '-1'. Если же параметр UseBoolStrs имеет значение True, то результатом работы является одно из значений 'FALSE' или 'TRUE' (программист может задать другие значения; о том, как это сделать, читайте в справочнике по системе Delphi).



• IntToHex(Value: Integer; Digits: Integer): string - возвращает шестнадцатиричное представление целого числа Value. Параметр Digits задает количество цифр результирующей строки.



• IntToStr(Value: Integer): string - преобразует целое число Value в строку.



• IsDelimiter(const Delimiters, S: string; Index: Integer): Boolean - проверяет, является ли символ S[Index] одним из символов строки Delimiters. Функция поддерживает работу с многобайтовой MBCS-кодировкой.



• IsValidIdent(const Ident: string): Boolean - возвращает True, если строка Ident является правильным идентификатором языка Delphi.



• LastDelimiter(const Delimiters, S: string): Integer - возвращает индекс последнего вхождения одного из символов строки Delimiters в строку S.



• LowerCase(const S: string): string - преобразует все заглавные буквы строки S к строчным; не учитывает местный язык (в преобразовании участвуют лишь символы в диапазоне от 'A' до 'Z').



• QuotedStr(const S: string): string - преобразует исходную строку в строку, взятую в одиночные кавычки; внутри строки символы кавычки дублируются.



• SameText(const S1, S2: string): Boolean - сравнивает строки, не делая различие между строчными и заглавными буквами; учитывает местный язык.



• SetString(var S: string; Buffer: PChar; Len: Integer) - копирует строку с типом PChar в строку с типом string. Длина копируемой строки задается параметром Len.



• StringOfChar(Ch: Char; Count: Integer): string - возвращает строку, в которой повторяется один и тот же символ. Количество повторений задается параметром Count.



• StringToGUID(const S: string): TGUID - преобразует строковое представление глобального уникального идентификатора в стандартный тип TGUID.



• StrToBool(const S: string): Boolean - преобразует строку в булевское значение.



• StrToBoolDef(const S: string; const Default: Boolean): Boolean - преобразует строку в булевское значение. В случае невозможности преобразования, функция возвращает значение, переданное через параметр Default.



• StrToDate(const S: string): TDateTime - преобразует строку со значением даты в числовой формат даты и времени.



• StrToDateDef(const S: string; const Default: TDateTime): TDateTime - преобразует строку со значением даты в числовой формат даты и времени. В случае невозможности преобразования, функция возвращает значение, переданное через параметр Default.



• StrToDateTime(const S: string): TDateTime - преобразует строку в числовое значение даты и времени.



• StrToDateTimeDef(const S: string; const Default: TDateTime): TDateTime - преобразует строку в числовое значение даты и времени. В случае невозможности преобразования, функция возвращает значение, переданное через параметр Default.



• StrToInt(const S: string): Integer - преобразует строку в целое число. Если строка не может быть преобразована в целое число, функция генерирует исключительную ситуацию класса EConvertError (обработка исключительных ситуаций рассматривается в главе 4).



• StrToIntDef(const S: string; Default: Integer): Integer - преобразует строку в целое число. Если строка не может быть преобразована в целое число, функция возвращает значение, заданное параметром Default.



• StrToInt64(const S: string): Int64 - 64-битный аналог функции StrToInt - преобразует строку в 64-битное целое число. Если строка не может быть преобразована в 64-битное число, функция генерирует исключительную ситуацию класса EConvertError (обработка исключительных ситуаций рассматривается в главе 4).



• StrToInt64Def(const S: string; const Default: Int64): Int64 - 64-битный аналог функции StrToIntDef - преобразует строку в 64-битное целое число. Если строка не может быть преобразована в 64-битное число, функция возвращает значение, заданное параметром Default.



• StrToTime(const S: string): TDateTime - преобразует строку в числовой формат времени. Если строка не может быть преобразована в числовой формат времени, функция генерирует исключительную ситуацию класса EConvertError (обработка исключительных ситуаций рассматривается в главе 4).



• StrToTimeDef(const S: string; const Default: TDateTime): TDateTime - преобразует строку в числовой формат времени. В случае ошибки преобразования, функция возвращает значение, заданное параметром Default.



• TimeToStr(Time: TDateTime): string - преобразует числовое значение времени в строку.



• Trim(const S: string): string - возвращает часть строки S без лидирующих и завершающих пробелов и управляющих символов.



• Trim(const S: WideString): WideString - Unicode-аналог функции Trim - возвращает часть строки S без лидирующих и завершающих пробелов и управляющих символов.



• TrimLeft(const S: string): string - возвращает часть строки S без лидирующих пробелов и управляющих символов.



• TrimLeft(const S: WideString): WideString - Unicode-аналог функции TrimLeft - возвращает часть строки S без лидирующих пробелов и управляющих символов.



• TrimRight(const S: string): string - возвращает часть строки S без завершающих пробелов и управляющих символов.



• TrimRight(const S: WideString): WideString - Unicode-аналог функции TrimRight - возвращает часть строки S без завершающих пробелов и управляющих символов.



• UpperCase(const S: string): string - преобразует все строчные буквы строки S в заглавные; не учитывает местный язык (в преобразовании участвуют лишь символы в диапазоне от 'a' до 'z').



• WideFormat(const Format: WideString; const Args: array of const): WideString - Unicode-аналог функции Format, учитывающий символы местного языка, - форматирует строку в соответствии с шаблоном Format, заменяя управляющие символы в шаблоне на значения элементов открытого массива Args. Управляющие символы подробно описаны в справочнике по системе Delphi.



• WideFmtStr(var Result: WideString; const Format: WideString; const Args: array of const) - аналог функции WideFormat. Отличие в том, что WideFmtStr возвращает результат через параметр Result, а не как значение функции.



• WideLowerCase(const S: WideString): WideString - Unicode-аналог функции LowerCase (учитывает местный язык) - преобразует все заглавные буквы строки S к строчным буквам.



• WideSameCaption(const Text1, Text2: WideString): Boolean - Unicode-аналог функции AnsiSameCaption - сравнивает две строки, не делая различие между строчными и заглавными буквами, а также не учитывая символ '&'; учитывает местный язык.



• WideSameStr(const S1, S2: WideString): Boolean - Unicode-аналог стандартной операции сравнения строк - сравнивает две строки, делая различие между строчными и заглавными буквами.



• WideSameText(const S1, S2: WideString): Boolean - Unicode-аналог функции SameText (учитывает местный язык) - сравнивает строки, не делая различие между строчными и заглавными буквами.



• WideUpperCase(const S: WideString): WideString - Unicode-аналог функции UpperCase (учитывает местный язык) - преобразует все строчные буквы строки S в заглавные.



• WrapText(const Line: string; MaxCol: Integer = 45): string - разбивает текст Line на строки, вставляя символы переноса строки. Максимальная длина отдельной строки задается параметром MaxCol.



• WrapText(const Line, BreakStr: string; const BreakChars: TSysCharSet; MaxCol: Integer): string - более мощный аналог предыдущей функции - разбивает текст Line на строки, вставляя символы переноса строки.



• AnsiToUtf8(const S: string): UTF8String - перекодирует строку в формат UTF8.



• PUCS4Chars(const S: UCS4String): PUCS4Char - возвращает указатель на первый символ строки формата UCS-4 для работы со строкой, как с последовательностью символов, заканчивающейся символом с кодом нуль.



• StringToWideChar(const Source: string; Dest: PWideChar; DestSize: Integer): PWideChar - преобразует стандартную строку к последовательности Unicode-символов, завершающейся символом с кодом нуль.



• UCS4StringToWideString(const S: UCS4String): WideString - преобразует строку формата UCS-4 к строке формата Unicode.



• Utf8Decode(const S: UTF8String): WideString - преобразует строку формата UTF-8 к строке формата Unicode.



• Utf8Encode(const WS: WideString): UTF8String - преобразует строку формата Unicode к строке формата UTF-8.



• Utf8ToAnsi(const S: UTF8String): string - преобразует строку формата UTF-8 к стандратной строке.



• WideCharLenToString(Source: PWideChar; SourceLen: Integer): string - преобразует строку формата Unicode к стандартной строке. Длина исходной строки задается параметром SourceLen.



• WideCharLenToStrVar(Source: PWideChar; SourceLen: Integer; var Dest: string) - аналог предыдущей функции - преобразует строку формата Unicode к стандартной строке. Длина исходной строки задается параметром SourceLen, а результат возвращается через параметр Dest.



• WideCharToString(Source: PWideChar): string - преобразует последовательность Unicode-символов, завершающуюся символом с кодом нуль, к стандартной строке.



• WideCharToStrVar(Source: PWideChar; var Dest: string) - аналог предыдущей функции - преобразует последовательность Unicode-символов, завершающуюся символом с кодом нуль, к стандартной строке. Результат возвращается через параметр Dest.



• WideStringToUCS4String(const S: WideString): UCS4String - преобразует строку формата Unicode к строке формата UCS-4.

2.11. Массивы

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

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

type
  TStates = array[1..50] of string;
  TCoordinates = array[1..3] of Integer;

var
  States: TStates; { 50 strings }
const
  Coordinates: TCoordinates = (10, 20, 5); { 3 integers }

var
  Symbols: array[0..80] of Char; { 81 characters }

Symbols[0]

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

var
  Table: array[1..5] of array[1..20] of Double;

var
  Table: array[1..5, 1..20] of Double;

Table[2][10]

Table[2, 10]

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

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

var
  A, B: array[1..10] of Integer;

A := B;

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

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

program Console; {$APPTYPE CONSOLE} uses SysUtils; var A: array[1..5] of Double; Sum: Double; I: Integer; begin for I := 1 to 5 do Readln(A[I]); Sum := 0; for I := 1 to 5 do Sum := Sum + A[I]; Writeln(Sum); Writeln('Press Enter to exit...'); Readln; end.

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

for I := Low(A) to High(A) do Sum := Sum + A[I];

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

var
  Table: array[1..5, 1..20] of Double;

for Col := 1 to 5 do
  for Row := 1 to 20 do
    Table[Col, Row] := 0;

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

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

const Max = 63; type TStatistics = array [0..Max] of Double; function Average(const A: TStatistics): Double; var I: Integer; begin Result := 0; for I := Low(A) to High(A) do Result := Result + A[I]; Result := Result / (High(A) - Low(A) + 1); end;

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

function Average(const A: array of Double): Double; var I: Integer; begin Result := 0; for I := Low(A) to High(A) do Result := Result + A[I]; Result := Result / (High(A) - Low(A) + 1); end;

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

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

var Statistics: array[1..10] of Double; Mean: Double; begin ... Mean := Average(Statistics); Mean := Average([0, Random, 1]); ... end;

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

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

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

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

var
  A: packed array[1..10] of Byte;

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

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

2.12. Множества

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

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

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

type
  TLetters = set of 'A'..'Z';

var
  Letters: TLetters;

var
  Symbols: set of Char;

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

const
  Vowels: TLetters = ['A', 'E', 'I', 'O', 'U'];
begin
  Letters := ['A', 'B', 'C'];
  Symbols := [ ]; { пустое множество }
end;

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

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

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

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

Операции принадлежности (>=, <=). Выражение A >= B равно True, если все элементы множества B содержатся в множестве A. Выражение A <= B равно True, если выполняется обратное условие, т.е. все элементы множества A содержатся в множестве B.

Операция in. Используется для проверки принадлежности элемента указанному множеству. Обычно применяется в условных операторах.

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

if (X = 1) or (X = 2) or (X = 3) or (X = 5) or (X = 7) then

if X in [1..3, 5, 7] then

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

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

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

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

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

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

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

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