СТРОКИ
 

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

Например, строкой является
В жизни всё закономерно

Следует знать, что Паскаль налагает на использование строк некоторые ограничения. Во-первых, их длина не может превышать 255 символов. Во-вторых, все строки в программе должны быть заключены в апострофы. Т.е.
'Быть или не быть, вот в чем вопрос!'

И наоборот, все, что стоит между двумя апострофами, является строкой Например
'a := sin(x) + 5.65'
тоже строка, а не оператор присваивания.

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

Тип строка в Паскале имеет два названия. Исторически первое выглядит так:
var s: packed array [1..50] of char;

(т.е. упакованный символьный массив). Впоследствии его заменили на более короткое и понятное:
var s: string[50];

( string в переводе строка). Можете пользоваться любым. Объявление строки максимальной (255) длины еще короче:
var s: string;

Тип string - уникальный в том смысле, что им можно пользоваться одновременно и как единым значением (так, как мы используем целую переменную), и как массивом. Этим строка отличается от простого (неупакованного) символьного массива. Такой массив - обыкновенный, и все ниже сказанное к нему не относится, хотя формально он тоже последовательность символов.
В типе string (но не packed array) элемент с номером 0 используется для хранения длины строки. Сами символы-элементы строки имеют номера от 1 до последнего.

В строке, объявленной как string[50], можно хранить строки любой длины, лишь бы она не превосходила 50-ти.
 

Работа со строками.
 

Строки как единое значение можно:
- присваивать
- складывать
- вводить
- выводить
- сравнивать

В отличие от всех других массивов строки вводятся/выводятся одним оператором, без цикла!
Разберем эти действия.

1. Присваивание строк. Присваивать можно любую строку любой, независимо от объявления. Необходимо только следить за тем, чтобы строка "влезла" в строковую переменную. Другими словами, если строковая переменная объявлена как string[50], нельзя запихнуть в нее строку из 100 символов. Также можно присвоить строковой переменной символьную (символ можно назвать строкой из 1-го элемента), но не наоборот. Пример присваивания:
s := 'String переводится как строка';

2. Сложение строк. Такое сложение называется конкатенацией или катенацией и применяется для соединения нескольких строк в одну. Например, после выполнения оператора
s := 'Иван' + ' Васильевич';

в переменной s будет содержаться строка 'Иван Васильевич'. Как, надеюсь, Вы уже поняли, операция сложения строк обозначается +. Операция сложения применима только к строкам типа string.

3. Ввод/вывод строк. Для того, чтобы ввести строку s, достаточно написать
readln(s);
А чтобы вывести:
writeln(s);

4. Сравнение строк. К строкам применимы все операции сравнения: = (на равенство), <> (на неравенство) и т.п.

С другой стороны, строка - это массив, и каждый элемент ее - символ. Строку можно обрабатывать поэлементно, иначе говоря, с ней можно обращаться как с обыкновенным символьным массивом. И выполнять любые операции, разрешенные в данном случае (см. Одномерные массивы). В частности, 5-тый символ строки s имеет имя s[5], как обычно.
Впрочем, есть одно очень важное отличие строковых переменных - это массивы переменной длины. Их длина заранее неизвестна, она зависит от того, какую строку мы присвоили строковой переменной. Длина эта хранится в 0-м элементе строковой переменной. Сами символы хранятся в элементах начиная с 1-го. Таким образом, если мы напишем
s := 'abc'
то s[0] = 3, s[1] = 'a', s[2] = 'b', s[3] = 'c'. Остальные элементы строки (4-ый, 5-ый и т.д.), если они есть, неопределены. Скорее всего, там хранится всякий мусор.

Однако не рекомендуется получать длину строки s как s[0]. Для этого в Паскале существует специальная функция length(s). Она возвращает длину строки, переданной ей в качестве параметра. Такой способ безопасней и надежней.
Например, так можно перебрать всю строку по символам (операция, которая часто встречается в задачах):
var s: string[50];
i: integer;
...
begin
...
readln(s);
...
for i := 1 to length(s) do
begin
{что-то сделать с символом s[i]}
end;
...
end.
Так как элемент строки имеет тип char, над ним можно производить все операции, разрешенные для этого типа данных.
 

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

В Паскале есть несколько стандартных функций и процедур для работы со строковыми данными. Вот их спецификации:

1. Функция Length( <строка> ) : integer
Возвращает длину строки-параметра в символах. Например, length('abc') будет равно 3-м.

2. Функция Concat( <строка> [,<строка>, <строка> ...] ) : string

Возвращает строку, являющуюся объединением (конкатенацией) всех параметров функции. Эта функция является аналогом операции сложения.
Параметров - произвольное число. Все параметры должны иметь тип
string. Например, concat('a', 'bc', '!!') будет 'abc!!'.

3. Функция Copy( <строка>, <позиция>, <сколько> ) : string

В качестве результата возвращает подстроку <строки>, начинающуюся с символа номер <позиция> длиной <сколько> символов (как бы вырезает часть <строки>). Параметры <позиция> и <сколько> должны быть целыми выражениями. Например, результатом вызова copy('1234567890',3,4) будет строка '3456'.

4. Функция Pos( <подстрока>, <строка> ) : byte

Определяет, содержится ли <подстрока> в <строке>. Если да, возвращает номер символа, с которого начинается <подстрока> в <строке>. Если нет, возвращает 0. Например, результатом pos('123', 'ab123cde') будет 3, т.к. строка '123' в строке 'ab123cde' содержится и начинается с позиции 3.

5. Процедура Delete( var <строка>, <позиция>, <сколько> )

Удаляет из <строки> <сколько> символов, начиная с символа номер <позиция>. По действию похожа на Copy, но вырезанная часть исчезает из <строки>. Параметр <строка> должен быть переменной строкового ти-
па, параметры <позиция> и <сколько> - выражениями целого типа. Например, пусть строка s = '123456789'. Тогда после выполнения процедуры delete(s,5,2) строка s будет равна '1234789'.

6. Процедура Insert( <строка>, var <строка-куда>, <позиция> )

Вставляет <строку> в <строку-куда>, начиная с символа номер <позиция>. Противоположна по действию процедуре Delete. Параметр <строка-куда> должен быть строковой переменной, параметр <позиция> -
целым выражением. Например, пусть строка s = 'abcde'. Тогда после выполнения процедуры Insert('12', s,3) строка s будет равна 'ab12cde'

7. Процедура Val( <строка>, var <ариф. перем.>, var <код ошибки> )

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

Если <код ошибки> равен 0, преобразование прошло успешно. Параметр <код ошибки> должен быть целой переменной. Например, пусть i и c целые переменные. Тогда после вызова Val('123', i, c) переменная i = 123, а с = 0. После вызова Val('1a2', i, c) значение переменной i не определено, а c = 2 (вторым символом встретилась буква).

8. Процедура Str( <ариф. выраж.>, var <строка> )

Преобразует числовое значение <ариф. выраж.> в строковое и помещает его в <строку>. Старое значение строки теряется. Параметр <строка> должен быть строковой переменной, а параметр <ариф. выраж.> - выражением целого либо вещественного типа. В <ариф. выраж.> можно задать формат преобразования (как в операторе вывода). Примеры преобразования (s - строка):
Str(4.14, s) s = '4.14'
i = 5 Str(i+12, s) s = '17'
f = 3.1415926 Str(f:5:2, s) s = '3.14'

Таковы стандартные функции работы со строковыми переменными. Однако практически все эти действия можно произвести без применения стандартных функций и процедур.

Пример решения задачи со строками.
 

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

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

Вариант A. С применением стандартных функций.

Как найти пробел? Для этого есть функция поиска подстроки pos (ничто не мешает считать пробел подстрокой, хотя и маленькой). Когда pos находит подстроку, она возвращает позицию ее начала - что нам и нужно. А если не находит - возвращает 0. Тогда мы должны закончить преобразование строки (пробелов не осталось!). Вырезать пробел можно с помощью процедуры delete, вставить - с помощью insert. Получаем следующий алгоритм:

1. Ввести строку.
2. Найти первый пробел в строке при помощи функции pos.
3. Пока результат pos не равен 0, выполнять шаги:
3.1. Удалить найденный пробел
3.2. Вставить на место пробела троеточие
3.3. Найти следующий пробел
4. Вывести получившуюся строку.

Вариант B. С использованием строки как символьного массива.

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

В отличие от первого варианта во втором потребуется две строки (дополнительная строка используется для конструирования результата). Алгоритм этого решения можно записать так:

1. Ввести исходную строку.
2. Записать в строку-результат пустую строку.
3. Для i от 1 до конца исходной строки выполнять:
если i-тый символ исходной строки - пробел то добавить к строке-результату троеточие, иначе добавить к строке-результату сам этот символ.
4. Вывести строку-результат.

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

program prim1; { вариант A }
uses crt;
var s: string;
k: byte; { это номер очередного символа-пробела }
begin
clrscr;
textcolor(lightgreen);
writeln('Замена в строке пробелов на ...');
write('Введите строку: ');
readln(s);
k := pos(' ', s);
while k <> 0 do
begin
delete(s, k,1);
insert('...', s, k);
k := pos(' ', s);
end;
writeln('Результат: ', s);
readkey;
end.
program prim_6a1b; { вариант B }
uses crt;
var s, res: string;
i: byte; { это номер очередного символа }
begin
clrscr;
textcolor(lightgreen);
writeln('Замена в строке пробелов на ...');
write('Введите строку: ');
readln(s);
res := '';
for i := 1 to length(s) do
if s[i] = ' ' then res := res + '...'
else res := res + s[i];
writeln('Результат: ', res);
readkey;
end.
 

ПОЛЕЗНЫЕ СОВЕТЫ.
 

1. Пустая строка обозначается '', а не ' '.
2. Строки ( string) можно складывать с символами ( char) - результат будет типа string.
3. Длина строки s хранится в ее элементе номер 0 (т.е. s[0]), однако безопаснее использовать функцию length(s).