Встроенный тип STRING

 

Для хранения текста в оперативной памяти в языках программирования, как правило, используются специализированные типы данных. В Turbo Pascal 7.0 такими типами данных являются строки. Фактически строка – это массив символов. Но из-за специфики работы с текстом и из-за широкого использования строк они выделены в специальные типы данных.

В Turbo Pascal можно использовать два вида строк - строки типа string и строки типа ASCIIZ. Строки типа string являются для Turbo Pascal “родными”, а строки типа ASCIIZ позаимствованы из языка Си. Сразу заметим, что работать со строками string проще, чем со строками ASCIIZ. По этим причинам мы будем рассматривать только работу со строками string.

 

String определен в Turbo Pascal как стандартный тип данных. По сути дела он определен как массив из 256 символов, с индексами от 0 до 255, то есть следующим образом:

Type

String = array [0..255] of char;

 

На самом деле для хранения символов в строке string используется только 255 из 256 символов – это элементы с индексами от 1 до 255. Элемент с индексом 0 хранит количество реально используемых элементов в строке, то есть нулевой элемент строки String по своему назначению эквивалентен переменной n в следующем фрагменте программы:

Var

A: Array[1..255] of char; {Массив символов, в котором может храниться от 0 до 255 элементов}

N:Byte; {Реальное количество элементов, хранимых в массиве A}

 

Например, если S – строковая константа, объявленная следующим образом:

Const

S = ‘Строка’;

то S представляет следующее содержимое:

Например, если T – строковая переменная, объявленная и инициализированная следующим образом:

Var

T : String;

Begin

T := ‘Turbo Pascal’;

тогда в переменной T хранится следующее значение:

 

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

 

Var

S:string;

N:Byte;

Begin

Write(‘Введите строку’);

Readln(S); {Ввод строки S}

N:=s[0]; {ОШИБКА – нельзя символ присваивать

переменной целого типа}

N:=Ord(s[0]); {Ошибки нет – переменной целого типа

присваивается не символ, а его код , т.е. целое число }

Writeln(‘Вы ввели строку ‘’’,S,’’’’); {Вывод введенной

строки}

Writeln(‘Она содержит ’,N,’ символов’); { вывод количества

символов во введенной строке}

Writeln(‘Она содержит ’,ord(s[0]),’ символов’);{То же самое}

Writeln(‘Она содержит ’,Length(S),’ символов’);{Снова то же

самое, но теперь уже с использованием

стандартной функции Length}

End.

 

 

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

 

Пример 1:

Необходимо ввести строку. Заменить все пробелы на символ ‘#’. Вывести строку после обработки.

 

var

s : string; {Строка}

I : byte; {Счетчик для прохода по всем символам строки S}

begin

{Ввод строки}

write('Введите строку: ');

readln(s);

{Замена пробелов на ‘#’}

for i:=1 to ord(s[0]) do

if s[i]=' ' then s[i]:='#';

{Вывод получившейся строки}

writeln('Получили строку: ',s);

end.

 

В данном примере стоит обратить внимание на то, что, хотя строка и является массивом символов, но ввод и вывод строки не требует цикла – она вводится и выводится как единое целое. Заметим также, что ввод строки необходимо производить при помощи процедуры ReadLN, но ни в коем случае не при помощи процедуры Read (!).

 

Рассмотрим еще один пример обработки строки как массива символов:

Пример 2. Ввести строку. Все точки, запятые, двоеточия и тире из строки удалить. Вывести получившуюся строку.

 

var

s : string; {Строка}

i, j : byte; {Счетчики}

begin

{Ввод строки}

write('Введите строку: ');

readln(s);

 

{Поиск и удаление символов}

I := 1;

while I <= ord( s[0] ) do

{Проверка – нужно удалять символ s[i] или нет}

if ( s[i] = '.' ) or ( s[i] = ',' ) or ( s[i] = ':' )

or ( s[i] = '-' )

{**1**}

then

begin

{Собственно удаление}

for j := i to ord(s[0]) - 1 do

s[j] := s[j+1];

{Уменьшение длины строки}

s[0] := chr( ord(s[0]) - 1);

 

{**2**}

end

else

i:=i+1; {Переход к следующему символу}

 

{Вывод получившейся строки}

writeln('Получили строку: ',s);

end.

 

В этом примере есть 2 места, в которых можно чувствительно упростить программу. Начнем со второго:

{**2**} Вместо записи s[0]:=chr(ord(s[0])-1); можно написать dec(s[0]) – эффект будет тот же.

Теперь первое:

{**1**} Вместо записи if (s[i]='.') or (s[i]=',') or (s[i]=':') or (s[i]='-') можно записать if s[i] in [‘.’,’,’,’:’,’-’] – эффект будет тот же.

 

Последняя строка требует пояснения. Дело в том, что при обработке строк в Turbo Pascal весьма широко и эффективно используются множества.