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

Символьные массивы.

Наиболее простым способом для работы с текстом является применение символьных переменных и линейных массивов, содержащих данные символьного типа (char).

    VAR
     ms: array[1..80] of CHAR;

В этом случае необходимо использовать все правила, приёмы и методы обработки массивов. Но как показывет практика, такой подход не совсем удобен. Поэтому для работы с текстом в языке Turbo Pascal был введён специальный тип данных, предназначенный для работы с фрагментами текста - строками (цепочками символов).

Строки.

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

     Writeln('Текст заключённый в кавычки - это и есть строка.');

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

     Writeln('Строка с кавычкой '' внутри.');

При выполнении этого оператора на экране монитора вы получите:

Строка с кавычкой ' внутри.

Объявление строчных типов и переменных.

Для объявления строковых типов и переменных используется служебное слово STRING, вслед за которым в квадратных скобках указывается максимальная длина строки. Например:

     VAR
       s1: string[70];

     или

     TYPE
       Line: string[70];
     VAR
       s1: Line;

В приведённых выше примерах переменная s1 в качестве своего значения может иметь любую последовательность символов (каждый из которых имеет тип char) произвольной длины (от 0 до 70 символов).

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

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

     s1 := 'Пример строки.';
     Readln(s1);

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

PROGRAM EX_22_1;
VAR
     ShortStr: string[5];
BEGIN
     ShortStr := 'Очень длинная строка';
     Writeln (ShortStr);    {Очень}
END.

Операция конкатенации.

Для строковых величин определена операция конкатенации '+':

PROGRAM EX_22_;
VAR  s1: string[80];
BEGIN
     s1 := 'Пример ' + 'строки.';
     Writeln(s1);     {Пример строки.}
END.

Длина строки.

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

     VAR
       att: string;
       ts2: string[255];

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

     att := 'Короткая строка';

     att := att + ' стала длиннее';

Функции для работы со строками.

Concat (S1, [S2, ..., Sn]: string): string;

Объединяет несколько строк в одну (при необходимости усекает чрезмерно большую строку до 255 символов). S1, S2, ..., Sn - объединяемые строки.

Length (S: string): integer;

Возвращает текущий размер строки. S - строка, у которой определяется размер.

PROGRAM EX_22_2;
VAR
     W: string;
BEGIN
     Write('Введите, пожалуйста, слово');
     Readln(W);
     Writeln('Это слово состоит из ',Length(W),'букв! ');
END.

Pos (P,S: string): byte;

Поиск последовательности P в строке S (результат равен номеру первого символа строки S, с которого начинается искомая последовательность, или 0, если такой последовательности в строке нет.

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

Copy (S: string; I: integer; C: integer);

Создаёт подстроку строки S.
S - исходная строка;
I - номер первого, выделяемого символа строки, (если значение больше длины строки, возвращается пустая строка);
C - число выделяемых символов (если всех необходимых символов в строке нет, возвращается имеющийся остаток строки).

PROGRAM EX_22_3;
VAR
     W: string[79];
     s1, s2, s3: string[20];
BEGIN
     W := 'картографирование';
     Writeln(W);                {картографирование}
     s1 := Copy(W,6,4);
     Writeln(s1);               {граф}
     s2 := Copy(W,2,3);
     Writeln(s2);               {арт}
     s3 := Copy(W,11,3);
     Writeln(s3);               {ров}
END.

Delete (var S: string; I: integer; C: integer);

Удаляет подстроку из строки S.
I - номер первого удаляемого символа (если номер больше размера строки, символы не удаляются);
C - число удаляемых символов (если символов в строке недостаточно, удаляется остаток символов).

Insert (P: string; var S: string; I: integer);

Помещает подстроку P в строку S (если получается строка слишком большого размера, то она усекается до 255 символов).
S - исходная строка;
P - подстрока, помещаемая в строку;
I - номер позиции исходной строки, начиная с которой помещается подстрока.

PROGRAM EX_22_4;
VAR
     s1: string[79];
     s2: string[20];
BEGIN
     s1 := 'компьютеризация';
     Writeln(s1);               {компьютеризация}
   Delete(s1,1,7);
     Writeln(s1);               {еризация}
   Delete(s1,3,2);
     Writeln(s1);               {ерация}
     s2 := 'Г';
   Insert(s2,s1,1);
     Writeln(s1);               {Герация}
     s2 := 'не';
   Insert(s2,s1,3);
     Writeln(s1);               {Генерация}
END.

Отдельные элементы строк.

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

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

PROGRAM EX_22_5;
VAR
     Str: string[26];
     i: integer;
BEGIN
     Str := 'A';
     for i:=1 to 26 do
         Str[i] := Chr(Ord('A')+i-1;
     Writeln(Str);
END.

Предполагается, что данная программа должна сформировать строку из 26 символов, содержимым которой является последовательность заглавных букв латинского алфавита. Однако вызов процедуры Writeln покажет, что содержимым переменной Str будет строка из одного символа A. Ошибка заключается в том, что присваивание значений элементам строки НЕ ВЛИЯЕТ на её текущую длину, которая была установлена равной 1 при первом присваивании (здесь значение получала строка в целом). Поэтому более правильной будет следующая программа:

PROGRAM EX_22_6;
VAR
     Str: string[26];
     i: integer;
BEGIN
     Str := '';
     for i:=1 to 26 do
         Str := Str+Chr(Ord('A')+i-1;
     Writeln(Str);
END.

Механизм хранения строк.

Механизм динамических строк реализован в TP весьма просто, поэтому память под переменные строкового типа отводится по максимуму, а используется лишь часть этой памяти, реально занятая символами строки в данный момент. Более точно для описания строковой переменной длиной N символов отводится N+1 байтов памяти, из которых N байтов предназначены для хранения символов строки, а один байт - для значения текущей длины этой строки. Это можно объяснить с помощью следующего рисунка.

  0    1   2   3   4   5   6      ...      К  К+1   ...      N-1  N
+-------------------------------------------------------------------+
|////|___|___|___|___|___|___|___________|___|   |      |   |   |   |
+-------------------------------------------------------------------+
  |  +------- Занятая часть строки --------+ +-- Незанятая часть --+
  +--- Значение К - текущая длина строки

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

     S[0] := Chr(7);  или  S[0] := #7;

В таких присвоениях в качестве присваиваемой величины может выступать целое число в диапазоне от 0 до 255, преобразуемое к типу CHAR с помощью префикса "#" или функции "Chr". Такое преобразование необходимо, так как каждый элемент строки, в том числе и показатель длины должен быть символом "Char".

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

PROGRAM EX_22_7;
VAR
     W: string[60];
     l: byte;
BEGIN
     W := '---------------------------------------------------------';
     for l:=1 to 12 do
          begin
     W[0] := Chr(l*5);
     Writeln (W);
          end;
END.

В этом примере на экран выводятся фрагменты различной длины строки W, которая первоначально состояла из 60 символов '-'.

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

Контрольные вопросы.

1. Что такое строка?
2. Как объявляются переменные для хранения строк?
3. Какова максимальная длина строки?
4. Что такое текущая длина строки?
5. Объясните механизм хранения строк.
6. Опишите функции для работы со строками.
7. Опишите процедуры для работы со строками.
8. Как используется символ N 32?
9. Как обратиться к отдельному элементу строки?

Задания для самостоятельного выполнения.

НАЗАД                    ДАЛЕЕ