10.2. Строковые данные

Строка – это последовательность любых символов кода обмена информацией.

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

Различают строковые константы и строковые переменные.

10.2.1. Строковые константы

Строковая константа – это последовательность любых символов, допускаемых для представления в компьютере, заключенная в апострофы. Например, ‘TEKST’.

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

1. Если в строке необходимо поместить апостроф, то его повторяют дважды. При подсчете длины строки два рядом стоящих апострофа считаются одним символом.

2. При подсчете длины строки учитываются пробелы.

Например,

‘ПРОГРАММА ‘‘ИНТЕГРАЛ’’’

Так должна быть написана строка ПРОГРАММА ‘ИНТЕГРАЛ’.

‘ЗНАК ‘‘+’’’

Так должна быть написана строка ЗНАК ‘+’.

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

‘’ – это пустая строка нулевой длины.

4. Delphi разрешает вставлять в строку символов управляющие символы. Символ # с целой константой без знака (от 0 до 255) обозначает соответствующий этому значению символ в коде ASCII. Между # и целой константой не должно быть никаких разделителей. Если несколько управляющих символов входят в строковую константу, то между ними не должно быть разделителей.

Например,

‘TURBO’#13#10’TEKST’

Здесь #13#10 – это управляющие символы, осуществляющие переход к началу следующей строки.

#7#7’MAKE’#7#7

Здесь #7 – это управляющий символ «Звонок».

#13#10

Эта строковая константа состоит только из управляющих символов.

Управляющие символы пишутся вне апострофа.

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

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

1-ый способ задания строковых переменных.

Задает строковые переменные постоянной длины. Строковая переменная определяется как одномерный массив символов. Например:

Array [1 .. N] Of Char

<Тип_индекса> может быть задан только с помощью типа диапазон, где N – длина строки (N ≥ 1), определяемая как целое число без знака.

При таком способе объявления строка обладает всеми свойствами массивов.

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

Пример 10.14.

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

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

Type

{Одномерный массив символов (строка)}

Stroka = Array [1 .. 9] Of Char;

{Двумерный массив символов (одномерный массив строк)}

Stranitca = Array [1 .. 30] Of Stroka;

Var

Stroka1, Stroka2: Stroka;

Stranitca1, Stranitca2: Stranitca;

I, K, J: 1..30;

X, Y: Boolean;

Const

Literal = ‘Программа’;

Begin

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

{K этому моменту Stroka2 должна быть определена:}

Stroka1 := Stroka2;

{Одной строке может быть присвоено значение другой строки той же

длины. Здесь К-ой строке страницы присваивается значение строки:}

Stranitca1[K] := Stroka2;

{Обращение к отдельным символам строковой переменной:}

Stroka1[I] := ‘A’;

Stroka1[J] := Stroka2[I];

{J-ому символу I-ой строки страницы присваивается значение К-ого

символа строки:}

Stranitca1[I, J] := Stroka1[K];

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

Особенности строковых переменных по сравнению с массивами:

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

Пример 10.15.

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

Stroka1 := Literal;

Stranitca[I] := Literal;

Stroka1 := ‘ПРОГРАММА’;

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

Пример 10.16.

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

X := Stroka1 = Stroka2;

Если Stroka1 и Stroka2 равны, то X примет значение True, в противном случае – False.

Y := Stranitca[I] >= Stroka2;

I-ая строка страницы сравнивается со строкой (у них длины должны быть одинаковые).

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

2-ой способ задания строковых переменных.

Задает короткие строки переменной длины. Короткая строка может быть объявлена двумя способами:

1. с помощью стандартного идентификатора ShortString;

2. с помощью задания типа String [N]. N после слова String определяет максимальную длину строки (этот способ аналогичен заданию строк переменной длины в языке Паскаль).

Например,

Var

St1 : String [100]; {максимальная длина строки St1 равна 100}

St3, St2 : ShortString; {максимальная длина строк St3 и St2 равна 255}

Короткая строка может иметь максимальную длину от 1 до 255 символов. Каждый символ строки занимает один байт памяти.

Тип данных ShortString эквивалентен объявлению String [255].

N после слова String должно иметь положительное целочисленное значение, не превышающее 255 (≥1).

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

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

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

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

1 .. <Текущая_длина_строки>.

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

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

Над данными типа Короткая строка определены операции сравнения (=, <>, >, <, >=, <=) и операция конкатенации (сцепления). Операция конкатенации имеет более высокий приоритет, чем операции сравнения.

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

Операция сцепления обозначается символом +. При ее выполнении две строки соединяются в одну результирующую строку. Длина результирующей строки может превышать 255 символов.

Пример 10.17.

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

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

Var

St1 : String [100]; {максимальная длина равна 100}

St3, St2 : ShortString; {максимальная длина строк St3 и St2 равна 255}

L: Boolean;

Begin

St1 := ‘Ми’; {текущая длина ST1 равна 2}

St2 := ‘н’; {текущая длина ST2 равна 1}

St3 := ‘ск’; {текущая длина ST3 равна 2}

St3 := St1 + St2 + St3; {сцепление (конкатенация) строк: в ST3 значение ‘Минск’; текущая длина равна 5}

L := St3 > St1; {в L запишется True}

St3[2] := ‘e’; {в ST3 значение ‘Менск’}

3-ой способ задания строковых переменных.

Задает длинные строки переменной длины (нуль-терминированные строки). Длинная строка может быть объявлена следующими способами:

3. с помощью стандартного идентификатора AnsiString;

4. с помощью задания типа String (без указания максимальной длины строки);

5. с помощью стандартного идентификатора WideString.

Например,

Var

St1 : String;

St2 : AnsiString;

St3 : WideString;

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

При создании строки инициализируются пустым значением ('').

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

В строках типа WideString каждый символ кодируется двумя байтами, элементами строки WideString являются символы типа WideChar. В строках типа AnsiString каждый символ кодируется одним байтом, элементами строки AnsiString являются символы типа AnsiChar. В строках типа String каждый символ кодируется одним байтом, элементами строки String являются символы типа Char.

Длинные строки введены в язык Delphi для обеспечения совместимости со строками языка Си (C-строками).

Над длинными строками определены те же операции, что и над короткими строками переменной длины.

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

The $LongStrings compiler directive determines whether Delphi treats the string type as an AnsiString when on (default) or ShortString when off.   The default recognises that the general use of string types is to hold data that is likely to be longer than 255 characters (ShortString capacity).

var   // Define littleString to be treated as a ShortString   {$LongStrings Off}   littleString : string;   // Define bigString to be treated as an AnsiString   {$LongStrings On}   bigString : string; begin   // Show the size of the little string - 256 bytes   Writeln(Format('littleString size = %d',[SizeOf(littleString)]));   // Show the size of the big string - 4 - a pointer to text   Writeln(Format('   bigString size = %d',[SizeOf(bigString)])); end; Вывод:

littleString size = 256 bigString size = 4