Введение
Массив - это упорядоченная совокупность однотипных данных. Каждому элементу массива соответствует один или несколько индексов, определяющих положение элемента в массиве. Индексы образуют упорядоченные последовательности.

Тип индекса определяет его допустимые значения. В качестве типа индекса может быть указан любой порядковый тип (boolean, char, integer, перечисляемый тип, а также диапазоны этих типов), кроме типа longint и его производных.

В зависимости от количества типов индексов различают: одномерные, двумерные, трехмерные и n-мерные массивы. Двумерные массивы обычно называют матрицами, считая первый индекс - номером строки, а второй -номером столбца.

Тип элементов массива - любой допустимый в Borland Pascal тип (в том числе и массив), кроме файла.

Объявление переменных типа массив выполняется двумя способами:

·       в операторе объявления переменных.

·       с предварительным объявлением типа.

Ограничения на количество индексов в Borland Pascal нет. Однако суммарная длина массива не должна превышать 65537 байт.

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

Данная тема является актуальной, так как удобство массивов не в способе хранения, а в способе их обработки.

Целью работы является изучение понятия «Символьный массив».

Основными задачами исследования являются: рассмотрение понятия символьного массива, символьной строки и операций над ними.
Глава 1
1. Символьные массивы.
Инициализация массивов. Для объявления инициализированных массивов в Borland Pascal используют типизированные константы. При этом соответствующие значения указывают в скобках через запятую. Значения элементов многомерных массивов перечисляют в порядке возрастания индексов справа налево, заключая в скобки каждый подмассив. Для матриц такой порядок соответствует построчному указанию значений.

Операции над массивами. Над массивом в целом определена единственная операция - операция присваивания.

Присваивание массивов заключается в копировании элементов одного массива в другой. Эту операцию можно выполнять только над массивами одного типа. Массивы считаются совпадающими по типу, если они объявлены через запятую в одной строке или, если вначале объявлен тип массива, а затем массивы этого типа.

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

Значения индексов можно указать непосредственно литералом, например а[3], или косвенно, указав идентификатор переменной, которая содержит, значение индекса.

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

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

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

Ввод-вывод массивов. Ввод-вывод массивов выполняют поэлементно, используя циклы с заданным числом повторений.

Значения элементов массива вводят в порядке обращения к ним из цикла, например для цикла, показанного выше: aj, а2, а3, а4, а5. Эти значения могут задаваться в одной строке через пробел или с нажатием клавиши Enter после ввода одного или нескольких чисел.

При выполнении операций ввода-вывода матриц и массивов большой размерности целесообразно вводить и выводить значения построчно.

Символьные массивы. Символьными называют массивы, элементами которых являются символы. Такие массивы традиционно использовались для представления символьной информации, например различных текстов. Обработка символьных массивов в Borland Pascal имеет некоторые особенности.

1.    Объявляя символьный массив как типизированную константу, значения символов можно указывать поэлементно:

Const d:array [1..10] of char = ('0\ '1\ '2\ '3\ '4\ '5\ '6'/ Ђ7\ '8\ '9');

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

Const d:array [1..10] of char = '0123456789';.

2.    Присвоить значение символьному массиву также можно целиком, используя строковую константу, длина которой должна совпадать с длиной массива:

Var S: array [1..11] of char;... S:= 'Пример один';

3.    При вводе элементы символьного массива нельзя разделять пробелами, так как пробел будет восприниматься как символ:

Var S: array [1..10] of char;

for i:= 1 to 10 do Read(S[i]);   {вводим строку «ABCDE FILN » и нажимаем ENTER}

4.    Символьный массив можно выводить поэлементно в цикле, как обычный одномерный массив, а можно - целиком, одним оператором Write или WriteLn:

WriteLn(S); {вывод символьного массива одним оператором}

5.    В операторе вывода допускается использование операции конкатенации (слияния) символьных массивов, обозначаемой символом «+». Результатом этой операции будет новый символьный массив, число элементов которого равно сумме размеров исходных массивов, а значениями элементов -элементы исходных массивов, последовательно записанные друг за другом:

WriteLn(stl + '  ' + st2); {конкатенация символьных массивов}

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

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

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

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

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

        Например:
             var

                A: array[0..63] of Char;

                P: PChar;

                .

                .

                .

             begin

                P := A;

                PrintStr(A);

                PrintStr(P);

             end;
Благодаря оператору присваивания P теперь указывает на  первый элемент массива A, поэтому PrintStr вызывается дважды с одним и тем же значением.

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

Кроме непосредственного использования строк в выражениях, строку можно поместить в символьный (типа char) массив с вы­бранным именем и в дальнейшем обращаться к ней по имени массива. Чаще всего для размещения строковой константы в массиве использу­ется его инициализация. Следующая программа выполняет указанные действия:

//Р2-07.СРР - инициализация массива строковой константой

#include <iostream.h> void main
()

{
char stroka
[ ] =
"REPETITIO EST MATER STUDIORUM"
;

cout
«
"\nsizeof stroka
= " «
sizeof stroka;

cout

«
"\
nstroka

= " «
stroka
;

}

Результат выполнения программы:

sizeof stroka = 30

stroka
=
REPETITIO EST MATER STUDIORUM

Обратите внимание, что при определении массива char после его имениstroka в скобках [] не указано количество элементов. Размер массива подсчитывается автоматически во время инициализации и равен количеству символов в строковой инициализирующей констан­те (в нашем случае 29) плюс один элемент для завершающего символа  ’\о’.

Кавычки не входят в строку, а служат ее ограничителями при за­писи в программе. В строке может быть один символ, например, "А" - строка из одного символа. Однако в отличие от символьной констан­ты 'А' длина внутреннего представления строки "А" равна 2. Строка может быть пустой ^ии, при этом ее длина равна 1. Однако символьная константа не может быть пустой, т.е. запись ‘ ’ в большинстве реали­заций недопустима.






2. Символьные строки
Символьные строки хранят такую информацию, как имена файлов, названия книг, имена служащих и другие символьные сочетания. Большинство программ на C++ широко используют символьные строки. Далее вы узнаете, что в C++ символьные строки хранятся в массиве типа char, который заканчивается символом NULL (или ASCII 0). В данном уроке символьные строки рассматриваются более подробно. Вы узнаете, как хранить и обрабатывать символьные строки, а также как использовать функции библиотеки этапа выполнения, которые манипулируют символьными строками. К концу этого урока вы освоите следующие основные концепции:

·       Чтобы объявить символьную строку, вы должны объявить массив типа char,

·       Чтобы присвоить символы символьной строке, ваши программы просто присваивают символы элементам массива символьных строк.

·       Программы C++ используют символ NULL (ASCII 0), чтобы отметить последний символ строки.

·       C++ позволяет вашим программам инициализировать символьные строки при их объявлении.

·       Программы могут передавать символьные строки в функцию, как и любой массив.

·       Большинство библиотек этапа выполнения C++ обеспечивают набор функций, которые управляют символьными строками.
Программы на C++ хранят символьные строки как массив типа char. Большинство программ широко используют символьные строки. Экспериментируйте с каждой программой, представленной в этом уроке, чтобы освоиться с символьными строками.






3. Объявление символьных строк в программах
Программисты на C++ широко используют символьные строки для хранения имен пользователей, имен файлов и другой символьной информации.

Для объявления символьной строки внутри программы просто объявите массив типа char с количеством элементов, достаточным для хранения требуемых символов. Например, следующее объявление создает переменную символьной строки с именем filename, способную хранить 64 символа (не забывайте, что символ NULL является одним из этих 64 символов):

char filename[64];

Как видно из рис. 17.1, это объявление создает массив с элементами, индексируемыми от filename[0] до filename[63].

 
Рис. 17.1. C++ трактует символьную строку как массив типа char.

Главное различие между символьными строками и другими типами массивов заключается в том, как C++ указывает последний элемент массива, Как вы уже знаете, программы на C++ представляют конец символьной строки с помощью символа NULL, который в C++ изображается как специальный символ '\0'. Когда вы присваиваете символы символьной строке, вы должны поместить символ NULL ('\0') после последнего символа в строке. Например, следующая программа ALPHABET. CPP присваивает буквы от А до Я переменной alphabet, используя цикл for. Затем программа добавляет символ NULL в эту переменную и выводит ее с помощью cout.
#include <iostream.h>
void main(void)
{

   char alphabet [34]; // 33 буквы плюс NULL char letter;

   int index;

   for (letter = 'A', index = 0; letter <= 'Я';

   letter++, index++) alphabet[index] = letter;

   alphabet[index] = NULL;

   cout << "Буквы " << alphabet;

}
Как видите, программа присваивает строке символ NULL, чтобы указать последний символ строки:
alphabet[index] = NULL;
Когда выходной поток cout выводит символьную строку, он по одному выводит символы строки, пока не встретит символ NULL. Короче говоря, cимвол NULL указывает программе последний символ в строке.

Обратите внимание на цикл for, который появляется в предыдущей программе. Как видите, цикл инициализирует и увеличивает две переменные (letter и index). Когда цикл for инициализирует или увеличивает несколько переменных, разделяйте операции запятой (запятая тоже является оператором C++):
for (letter = 'A', index = 0; letter <= 'Я'; letter++, index++)

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

"Это строковая константа"

При создании символьной строковой константы компилятор C++ автоматически добавляет символ NULL, как показано на рис. 17.2.



Рис. 17.2. Компилятор C++ автоматически добавляет символ NULL к строковым константам.

Когда ваши программы выводят символьные строковые константы с помощью выходного потока cout, cout использует символ NULL (который компилятор добавляет к строке) для определения последнего символа вывода.






3.1 Использование символа NULL
Символьная строка представляет собой массив символов, за которыми следует символ NULL ('\0'). При объявлении символьной строки вы объявляете массив типа char. Когда программа позднее присваивает символы строке, она отвечает за добавление символа NULL, который представляет конец строки.

Если вы используете строковые константы, заключенные в двойные кавычки, компилятор C++ автоматически добавляет символ NULL. Большинство функций C++ используют символ NULL для определения последнего символа строки.
Следующая программа LOOPNULL.CPP слегка изменяет предыдущую программу, используя цикл for для вывода содержимого строки:
#include <iostream.h>
void main(void)
{

   char alphabet[34]; //33 символа плюс NULL char letter;

   int index;

   for (letter = 'A', index = 0; letter <= 'Я'; letter++, index++) alphabet[index] = letter;

   alphabet[index] = NULL;

   for (index = 0; alphabet[index] 1= NULL; index++) cout << alphabet[index];

   cout << endl;

}
Как видите, цикл for по одному исследует символы строки. Если символ не NULL (не последний символ строки), цикл выводит символ, увеличивает индекс, и процесс продолжается.
Как 'А' отличается от "А"

При рассмотрении программ на C++ вы можете встретить символы, заключенные в одинарные кавычки (например, 'А') и символы, заключенные в



Рис. 17.3. Как компилятор C++ хранит символьную константу 'А' и строковую константу "А".

двойные кавычки ("А"). Символ внутри одинарных кавычек представляет собой символьную константу. Компилятор C++ выделяет только один байт памяти для хранения символьной константы. Однако символ в двойных кавычках представляет собой строковую константу — указанный символ и символ NULL (добавляемый компилятором). Таким образом, компилятор будет выделять два байта для символьной строки. Рисунок 17.3 иллюстрирует, как компилятор C++ хранит символьную константу 'А' и строковую константу "А".






4. Инициализация символьной строки
Как вы уже знаете из урока 16, C++ позволяет вам инициализировать массивы при объявлении. Символьные строки C++ не являются исключением. Для инициализации символьной строки при объявлении укажите требуемую строку внутри двойных кавычек, как показано ниже:

char title[64] = "Учимся программировать на языке C++";
Если количество символов, присваиваемое строке, меньше размера массива, большинство компиляторов C++ будут присваивать символы NULL остающимся элементам строкового массива. Как и в случае с массивами других типов, если вы не указываете размер массива, который инициализируете при объявлении, компилятор C++ распределит достаточно памяти для размещения указанных букв и символа NULL:

char title[] = "Учимся программировать на языке C++";

Следующая программа INIT_STR.CPP инициализирует символьную строку при объявлении:
#include <iostream.h>
void main(void)
{

   char title[64] = "Учимся программировать на языке C++";

   char lesson[64] = "Символьные строки";

   cout << "Книга: " << title << endl;

   cout << "Урок: " << lesson << endl;

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






5. Передача строк в функции
Передача символьной строки в функцию подобна передаче любого массива в качестве параметра. Внутри функции вам нужно просто указать тип массива (char) и левую и правую скобки массива. Вам не надо указывать размер строки. Например, следующая программа SHOW_STR.CPP использует функцию show_ string для вывода символьной строки на экран:
#include <iostream.h>
void show_string(char string[])
{

   cout << string << endl;

}
void main(void)
{

   show_string("Привет, C++!");

   show_string("Учусь программировать на C++");

}
Как видите, функция show_string трактует параметр символьной строки как массив:

void show_string(char string[])
Так как символ NULL указывает конец строки, функция не требует параметр, который задает количество элементов в массиве. Вместо этого функция может определить последний элемент, просто найдя в массиве символ NULL.

Как вы уже знаете, функции C++ часто используют символ NULL для определения конца строки. Следующая программа STR_LEN.CPP создает функцию с именем string_length, которая ищет символ NULL в строке для определения количества символов, содержащихся в строке. Далее функция использует оператор return для возврата длины строки вызвавшей функции. Программа передает несколько различных символьных строк в функцию, отображая длину каждой из них на экране:
#include <iostream.h>
int string_length(char string[])
{

   int i;

   for (i = 0; string[] != '\0'; i++); // Ничего не делать, но перейти к

                                                  // следующему символу return(i); Длина строки

}
void main(void)
{

   char title[] = "Учимся программировать на языке C++";

   char lesson[] = "Символьные строки";

   cout << "Строка " << title << " содержит " << string_length(title) << " символов" << endl;

   cout << "Строка " << lesson << " содержит " << string_length(lesson) << " символов" << endl;

}
Как видите, функция запускается с первого символа строки (элемент 0) и затем исследует каждый элемент до тех пор, пока не встретит NULL. Рассматривая программы на C++, вы встретите целый ряд функций, которые подобным образом просматривают символьные строки в поисках символа NULL.






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

1.    Символьная строка представляет собой массив символов, завершающийся 0 (символом NULL).

2.    Вы создаете символьную строку, объявляя массив типа char.

3.    Ваша программа ответственна за размещение символа NULL за последним символом строки.

4.    Если программа использует строковые константы, заключенные в

5.    двойные кавычки, компилятор C++ автоматически добавляет символ NULL.

6.    C++ позволяет вам инициализировать строки при объявлении, указывая требуемые символы внутри двойных кавычек.

7.    Большинство компиляторов C++ в своих библиотеках этапа выполнения обеспечивают широкий набор функций для манипулирования строками.
Следует помнить, что в C++ нет принципиальной разницы между массивом массивов произвольной размерности и обычным одномерным массивом.





Список литературы
1.       Подбельский В.В. Язык СИ++. – М., 2005 г.

2.       “Язык программирования Си.”  Б.В. Керниган, Д. Ритчи, А. Фьюэр.     Русский перевод: Москва: Финансы и Статистика. 1985 г.

3.       “Языки программирования” кн.5, Ваулин А.С., 1993 г.

4.       “Языки программирования высокого уровня”,        Хротко Г., 1982 г.

5.       “Языки программирования”,      Малютин Э.А., Малютина Л.В., 1982 г.

6.       “Новые языки программирования и тенденции их развития”,  Ушкова В., 1982 г.

7.       “Языки программирования: разработка и реализация”,      П. Терренс, 1979 г.