Массивы и строки

30 неделя . muzoic.com .

Массив (array) — это коллекция переменных одинакового типа, обращение к которым происходит с применением общего для всех имени. В C++ массивы могут быть одно- или многомерными, хотя в основном используются одномерные массивы. Массивы представляют собой удобное средство группирования связанных переменных.
Чаще всего используются символьные массивы, в которых хранятся строки. Как упоминалось выше, в C++ не определен встроенный тип данных для хранения строк. Поэтому строки реализуются как массивы символов. Такой подход к реализации строк дает С++-программисту больше «рычагов» управления по сравнению с теми языками, в которых используется отдельный строковый тип данных.


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

тип имя_массива [размер];
Здесь с помощью элемента записи тип объявляется базовый тип массива. Базовый тип определяет тип данных каждого элемента, составляющего массив. Количество элементов, которые будут храниться в массиве, определяется элементом размер. Например, при выполнении приведенной ниже инструкции объявляется int-массив (состоящий из 10 элементов) с именем sample.

int sample[10];
Индекс идентифицирует конкретный элемент массива.
Доступ к отдельному элементу массива осуществляется с помощью индекса. Индекс описывает позицию элемента внутри массива. В C++ первый элемент массива имеет нулевой индекс. Поскольку массив sample содержит 10 элементов, его индексы изменяются от 0 до 9. Чтобы получить доступ к элементу массива по индексу, достаточно указать нужный номер элемента в квадратных скобках. Так, первым элементом массива sample является sample[0], а последним — sample[9]. Например, следующая программа помещает в массив sample числа от 0 до 9.

#include <iostream>

using namespace std;

int main ()

{

int sample[10]; // Эта инструкция резервирует область памяти для 10 элементов типа int.

int t;

// Помещаем в массив значения.

for (t=0; t<10; ++t) sample[t]=t;

// Отображаем массив.

for (t=0; t<10; ++t)

cout << sample[t] << ' ';

return 0;

}
В C++ все массивы занимают смежные ячейки памяти. (Другими словами, элементы массива в памяти расположены последовательно друг за другом.) Ячейка с наименьшим адресом относится к первому элементу массива, а с наибольшим — к последнему. Например, после выполнения этого фрагмента кода

int i [7];

int j;

for (j=0; j<7; j++) i[j]=j;
массив i будет выглядеть следующим образом.
Для одномерных массивов общий размер массива в байтах вычисляется так:
всего байтов = размер типа в байтах х количество элементов.
Массивы часто используются в программировании, поскольку позволяют легко обрабатывать большое количество связанных переменных. Например, в следующей программе создается массив из десяти элементов, каждому элементу присваивается случайное число, а затем на экране отображаются минимальное и максимальное значения.

#include <iostream>

#include <cstdlib>

using namespace std;

int main ()

{

int i, min_value, max_value;

int list [10];

for (i=0; i<10; i++) list[i] = rand ();

// Находим минимальное значение.

min_value = list[0];

for (i=1; i<10; i++)

if (min_value > list[i]) min_value = list[i];

cout << "Минимальное значение: " << min_value << ' \n';

// Находим максимальное значение.

max_value = list[0];

for (i=1; i<10; i++)

if (max_value < list[i]) max_value = list[i];

cout << "Максимальное значение: " << max_value << '\n';

return 0;

}
В C++ нельзя присвоить один массив другому. В следующем фрагменте кода, например, присваивание а = b; недопустимо.

int а[10], b[10];

// ...

а = b; // Ошибка!!!
Чтобы поместить содержимое одного массива в другой, необходимо отдельно выполнить присваивание каждого значения.
На границах массивов погранзаставы нет
В C++ не выполняется никакой проверки «нарушения границ» массивов, т.е. ничего не может помешать программисту обратиться к массиву за его пределами. Если это происходит при выполнении инструкции присваивания, могут быть изменены значения в ячейках памяти, выделенных некоторым другим переменным или даже вашей программе. Другими словами, обращение к массиву (размером N элементов) за границей N-гo элемента может привести к разрушению программы при отсутствии каких-либо замечаний со стороны компилятора и без выдачи сообщений об ошибках во время работы программы. Это означает, что вся ответственность за соблюдение границ массивов лежит только на программистах, которые должны гарантировать корректную работу с массивами. Другими словами, программист обязан использовать массивы достаточно большого размера, чтобы в них можно было без осложнений помещать данные, но лучше всего в программе предусмотреть проверку пересечения границ массивов.
Например, С++-компилятор «молча» скомпилирует и позволит запустить следующую программу на выполнение, несмотря на то, что в ней происходит выход за границы массива crash.
Осторожно! Не выполняйте следующий пример программы. Это может разрушить вашу систему.

// Некорректная программа. Не выполняйте ее!

int main ()

{

int crash[10], i;

for (i=0; i<100; i++) crash[i]=i;

return 1;

}
В данном случае цикл for выполнит 100 итераций, несмотря на то, что массив crash предназначен для хранения лишь десяти элементов. При выполнении этой программы возможна перезапись важной информации, что может привести к аварийной остановке программы.
Вас, возможно, удивляет такая «непредусмотрительность» C++, которая выражается в отсутствии встроенных средств динамической проверки на «неприкосновенность» границ массивов. Напомню, однако, что язык C++ предназначен для профессиональных программистов, и его задача — предоставить им возможность создавать максимально эффективный код. Любая проверка корректности доступа средствами C++ существенно замедляет выполнение программы. Поэтому подобные действия оставлены на рассмотрение программистам. Как будет показано ниже в этой книге, при необходимости программист может сам определить тип массива и заложить в него проверку нерушимости границ.
Сортировка массива
Одной из самых распространенных операций, выполняемых над массивами, является сортировка. Существует множество различных алгоритмов сортировки. Широко применяется, например, сортировка перемешиванием и сортировка методом Шелла. Известен также алгоритм Quicksort (быстрая сортировка с разбиением исходного набора данных на две половины так, что любой элемент первой половины упорядочен относительно любого элемента второй половины). Однако самым простым считается алгоритм сортировки пузырьковым методом. Несмотря на то что пузырьковая сортировка не отличается высокой эффективностью (и в самом деле, его производительность неприемлема для сортировки больших массивов), его вполне успешно можно применять для сортировки массивов малого размера.
Алгоритм сортировки пузырьковым методом получил свое название от способа, используемого для упорядочивания элементов массива. Здесь выполняются повторяющиеся операции сравнения и при необходимости меняются местами смежные элементы. При этом элементы с меньшими значениями постепенно перемещаются к одному концу массива, а элементы с большими значениями — к другому. Этот процесс напоминает поведение пузырьков воздуха в резервуаре с водой. Пузырьковая сортировка выполняется путем нескольких проходов по массиву, во время которых при необходимости осуществляется перестановка элементов, оказавшихся «не на своем месте». Количество проходов, гарантирующих получение отсортированного массива, равно количеству элементов в массиве, уменьшенному на единицу.
В следующей программе реализована сортировка массива (целочисленного типа), содержащего случайные числа. Эта программа заслуживает внимательного разбора.

// Использование метода пузырьковой сортировки

// для упорядочения массива.

#include <iostream>

#include <cstdlib>

using namespace std;

int main ()

{

int nums[10];

int a, b, t;

int size;

size = 10; // Количество элементов, подлежащих сортировке.

// Помещаем в массив случайные числа.

for (t=0; t<size; t++) nums[t] = rand ();

// Отображаем исходный массив.

cout << "Исходный массив: ";

for (t=0; t<size; t++) cout << nums[t] << ' ';

cout << '\n';

// Реализация метода пузырьковой сортировки.

for (a=1; a<size; а++)

for (b=size-1; b>=a; b--) {

if (nums[b-1] > nums[b]) { // Элементы неупорядочены.

// Меняем элементы местами.

t = nums[b-1];

nums[b-1] = nums[b];

nums[b] = t;

}

}

}

// Конец пузырьковой сортировки.

// Отображаем отсортированный массив.

cout << "Отсортированный массив: ";

for (t=0; t<size; t++)

cout << nums[t] << ' ';

return 0;

}
Хотя алгоритм пузырьковой сортировки пригоден для небольших массивов, для массивов большого размера он становится неэффективным. Более универсальным считается алгоритм Quicksort. В стандартную библиотеку C++ включена функция qsort (), которая реализует одну из версий этого алгоритма. Но, прежде чем использовать ее, вам необходимо изучить больше средств C++. (Подробно функция qsort () рассмотрена в главе 20.)
Строки
Чаще всего одномерные массивы используются для создания символьных строк. В C++ строка определяется как символьный массив, который завершается нулевым символом ('\0'). При определении длины символьного массива необходимо учитывать признак ее завершения и задавать его длину на единицу больше длины самой большой строки из тех, которые предполагается хранить в этом массиве.
Строка — это символьный массив, который завершается нулевым символом.
Например, объявляя массив str, предназначенный для хранения 10-символьной строки, следует использовать следующую инструкцию.

char str [11];
Заданный здесь размер (11) позволяет зарезервировать место для нулевого символа в конце строки.
Как упоминалось выше в этой книге, C++ позволяет определять строковые литералы. Вспомним, что строковый литерал — это список символов, заключенный в двойные кавычки. Вот несколько примеров.

«Привет»

«Мне нравится C++»

«#$%@@#$»

""
Строка, приведенная последней (""), называется нулевой. Она состоит только из одного нулевого символа (признака завершения строки). Нулевые строки используются для представления пустых строк.
Вам не нужно вручную добавлять в конец строковых констант нулевые символы. С++-компилятор делает это автоматически. Следовательно, строка «ПРИВЕТ» в памяти размещается так, как показано на этом рисунке:
Считывание строк с клавиатуры
Проще всего считать строку с клавиатуры, создав массив, который примет эту строку с помощью инструкции cin. Считывание строки, введенной пользователем с клавиатуры, отображено в следующей программе.

// Использование cin-инструкции для считывания строки с клавиатуры.

#include <iostream>

using namespace std;

int main ()

{

char str[80];

cout << "Введите строку: ";

cin >> str; // Считываем строку с клавиатуры.

cout << "Вот ваша строка: ";

cout << str;

return 0;

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

Введите строку: Это проверка

Вот ваша строка: Это
Как видите, при выводе строки, введенной с клавиатуры, программа отображает только слово «Это», а не всю строку. Дело в том, что оператор «>>» прекращает считывание строки, как только встречает символ пробела, табуляции или новой строки (будем называть эти символы пробельными).
Для решения этой проблемы можно использовать еще одну библиотечную функцию gets (). Общий формат ее вызова таков.

gets (имя_массива);
Если в программе необходимо считать строку с клавиатуры, вызовите функцию gets (), а в качестве аргумента передайте имя массива, не указывая индекса. После выполнения этой функции заданный массив будет содержать текст, введенный с клавиатуры. Функция gets () считывает вводимые пользователем символы до тех пор, пока он не нажмет клавишу <Enter>. Для вызова функции gets () в программу необходимо включить заголовок <cstdio>.
В следующей версии предыдущей программы демонстрируется использование функции gets (), которая позволяет ввести в массив строку символов, содержащую пробелы.

// Использование функции gets () для считывания строки с клавиатуры.

#include <iostream>

#include <cstdio>

using namespace std;

int main ()

{

char str[80];

cout << "Введите строку: ";

gets (str); // Считываем строку с клавиатуры.

cout << "Вот ваша строка: ";

cout << str;

return 0;

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

Введите строку: Это простой тест

Вот ваша строка: Это простой тест
В этой программе следует обратить внимание на следующую инструкцию.

cout << str;
Здесь (вместо привычного литерала) используется имя строкового массива. И хотя причина такого использования инструкции cout вам станет ясной после прочтения еще нескольких глав этой книги, пока кратко заметим, что имя символьного массива, который содержит строку, можно использовать везде, где допустимо применение строкового литерала.
При этом имейте в виду, что ни оператор «>>», ни функция gets () не выполняют граничной проверки (на отсутствие нарушения границ массива). Поэтому, если пользователь введет строку, длина которой превышает размер массива, возможны неприятности, о которых упоминалось выше. Из сказанного следует, что оба описанных здесь варианта считывания строк с клавиатуры потенциально опасны. Однако после подробного рассмотрения С++-возможностей ввода-вывода в главе 18 мы узнаем способы, позволяющие обойти эту проблему.
Некоторые библиотечные функции обработки строк
Язык C++ поддерживает множество функций обработки строк. Самыми распространенными из них являются следующие.

strcpy ()

strcat ()

strlen ()

strcmp ()
Для вызова всех этих функций в программу необходимо включить заголовок <cstring>. Теперь познакомимся с каждой функцией в отдельности.
Функция strcpy ()
Общий формат вызова функции strcpy () таков:

strcpy (to, from);
Функция strcpy () копирует содержимое строки from в строку to. Помните, что массив, используемый для хранения строки to, должен быть достаточно большим, чтобы в него можно было поместить строку из массива from. В противном случае массив to переполнится, т.е. произойдет выход за его границы, что может привести к разрушению программы.
Использование функции strcpy () демонстрируется в следующей программе, которая копирует строку «Привет» в строку str.

#include <iostream>

#include <cstring>

using namespace std;

int main ()

{

char str[80];

strcpy (str, «Привет»);

cout << str;

return 0;

}
Функция strcat ()
Обращение к функции strcat () имеет следующий формат.

strcat (s1, s2);
Функция strcat () присоединяет строку s2 к концу строки s1, при этом строка s2 не изменяется. Обе строки должны завершаться нулевым символом. Результат вызова этой функции, т.е. результирующая строка s1 также будет завершаться нулевым символом. Использование функции strcat () демонстрируется в следующей программе, которая должна вывести на экран строку «Привет всем!».

#include <iostream>

#include <cstring>

using namespace std;

int main ()

{

char s1[20], s2[10];

strcpy (s1, «Привет»);

strcpy (s2, « всем!»);

strcat (s1, s2);

cout << s1;

return 0;

}
Функция strcmp ()
Обращение к функции strcmp () имеет следующий формат:

strcmp (s1, s2);
Функция strcmp () сравнивает строку s2 со строкой s1 и возвращает значение 0, если они равны. Если строка s1 лексикографически (т.е. в соответствии с алфавитным порядком) больше строки s2, возвращается положительное число. Если строка s1 лексикографически меньше строки s2, возвращается отрицательное число.
Использование функции strcmp () демонстрируется в следующей программе, которая служит для проверки правильности пароля, введенного пользователем (для ввода пароля с клавиатуры и его верификации служит функция password ()).

#include <iostream>

#include <cstring>

#include <cstdio>

using namespace std;

bool password ();

int main ()

{

if (password ()) cout << «Вход разрешен.\n»;

else cout << «В доступе отказано.\n»;

return 0;

}

// Функция возвращает значение true, если пароль принят, и значение false в противном случае.

bool password ()

{

char s[80];

cout << "Введите пароль: ";

gets (s);

if (strcmp (s, «пароль»)) { // Строки различны.

cout << «Пароль недействителен.\n»;

return false;

}

// Сравниваемые строки совпадают.

return true;

}
При использовании функции strcmp () важно помнить, что она возвращает число 0 (т.е. значение false), если сравниваемые строки равны. Следовательно, если вам необходимо выполнить определенные действия при условии совпадения строк, вы должны использовать оператор НЕ (!). Например, при выполнении следующей программы запрос входных данных продолжается до тех пор, пока пользователь не введет слово «Выход».

#include <iostream>

#include <cstdio>

#include <cstring>

using namespace std;

int main ()

{

char s [80];

for (;;) {

cout << "Введите строку: ";

gets (s);

if (!strcmp («Выход», s)) break;

}

return 0;

}
Функция strlen ()
Общий формат вызова функции strlen () таков:

strlen (s);
Здесь s — строка. Функция strlen () возвращает длину строки, указанной аргументом s.
При выполнении следующей программы будет показана длина строки, введенной с клавиатуры.

#include <iostream>

#include <cstdio>

#include <cstring>

using namespace std;

int main ()

{

char str[80];

cout << "Введите строку: "; gets (str);

cout << "Длина строки равна: " << strlen (str);

return 0;

}
Если пользователь введет строку «Привет всем!», программа выведет на экране число 12. При подсчете символов, составляющих заданную строку, признак завершения строки (нулевой символ) не учитывается.
А при выполнении этой программы строка, введенная с клавиатуры, будет отображена на экране в обратном порядке. Например, при вводе слова «привет» программа отобразит слово «тевирп». Помните, что строки представляют собой символьные массивы, которые позволяют ссылаться на каждый элемент (символ) в отдельности.

// Отображение строки в обратном порядке.

#include <iostream>

#include <cstdio>

#include <cstring>

using namespace std;

int main ()

{

char str[80];

int i;

cout << "Введите строку: ";

gets (str);

for (i=strlen (str) -1; i>=0; i--)

cout << str[i];

return 0;

}
В следующем примере продемонстрируем использование всех этих четырех строковых функций.

#include <iostream>

#include <cstdio>

#include <cstring>

using namespace std;

int main ()

{

char s1[80], s2 [80];

cout << "Введите две строки: ";

gets (s1); gets (s2);

cout << "Их длины равны: " << strlen (s1);

cout << ' '<< strlen (s2) << '\n';

if (!strcmp (s1, s2)) cout << «Строки равны \n»;

else cout << «Строки не равны \n»;

strcat (s1, s2);

cout << s1 << '\n';

strcpy (s1, s2);

cout << s1 << " и " << s2 << ' ';

cout << «теперь равны\n»;

return 0;

}
Если запустить эту программу на выполнение и по приглашению ввести строки «привет» и «всем», то она отобразит на экране следующие результаты:

Их длины равны: 6 4

Строки не равны

привет всем

всем и всем теперь равны
Последнее напоминание: не забывайте, что функция strcmp () возвращает значение false, если строки равны. Поэтому, если вы проверяете равенство строк, необходимо использовать оператор «!» (НЕ), чтобы реверсировать условие (т.е. изменить его на обратное), как было показано в предыдущей программе.
Использование признака завершения строки
Факт завершения нулевыми символами всех С++-строк можно использовать для упрощения различных операций над ними. Следующий пример позволяет убедиться в том, насколько простой код требуется для замены всех символов строки их прописными эквивалентами.

// Преобразование символов строки в их прописные эквиваленты.

#include <iostream>

#include <cstring>

#include <cctype>

using namespace std;

int main ()

{

char str[80];

int i;

strcpy (str, «test»);

for (i=0; str[i]; i++) str[i] = toupper (str[i]);

cout << str;

return 0;

}
Эта программа при выполнении выведет на экран слово TEST. Здесь используется библиотечная функция toupper (), которая возвращает прописной эквивалент своего символьного аргумента. Для вызова функции toupper () необходимо включить в программу заголовок <cctype>.
Обратите внимание на то, что в качестве условия завершения цикла for используется массив str, индексируемый управляющей переменной i (str[i]). Такой способ управления циклом вполне приемлем, поскольку за истинное значение в C++ принимается любое ненулевое значение. Вспомните, что все печатные символы представляются значениями, не равными нулю, и только символ, завершающий строку, равен нулю. Следовательно, этот цикл работает до тех пор, пока индекс не укажет на нулевой признак конца строки, т.е. пока значение str[i] не станет нулевым. Поскольку нулевой символ отмечает конец строки, цикл останавливается в точности там, где нужно. При дальнейшей работе с этой книгой вы увидите множество примеров, в которых нулевой признак конца строки используется подобным образом.
Важно! Помимо функции toupper (), стандартная библиотека C++ содержит много других функций обработки символов. Например, функцию toupper () дополняет функция tolower (), которая возвращает строчный эквивалент своего символьного аргумента. Часто используются такие функции, как isalpha (), isdigit (), isspace () и ispunct (), которые принимают символьный аргумент и определяют, принадлежит ли он к соответствующей категории. Например, функция isalpha () возвращает значение ИСТИНА, если ее аргументом является буква (элемент алфавита).
Двумерные массивы
В C++ можно использовать многомерные массивы. Простейший многомерный массив — двумерный. Двумерный массив, по сути, представляет собой список одномерных массивов. Чтобы объявить двумерный массив целочисленных значений размером 10×20 с именем twod, достаточно записать следующее:

int twod[10][20];
Обратите особое внимание на это объявление. В отличие от многих других языков программирования, в которых при объявлении массива значения размерностей отделяются запятыми, в C++ каждая размерность заключается в собственную пару квадратных скобок.
Чтобы получить доступ к элементу массива twod с координатами 3,5 , необходимо использовать запись twod[3][5]. В следующем примере в двумерный массив помещаются последовательные числа от 1 до 12.

#include <iostream>

using namespace std;

int main ()

{

int t,i, num[3] [4];

for (t=0; t<3; ++t) {

for (i=0; i<4; ++i) {

num[t][i] = (t*4)+i+l;

cout << num[t][i] << ' ';

}

cout << '\n';

}

return 0;

}
В этом примере элемент num[0][0] получит значение 1, элемент num[0][1] — значение 2, элемент num[0][2] — значение 3 и т.д. Значение элемента num[2][3] будет равно числу 12. Схематически этот массив можно представить, как показано на рис. 5.1.
В двумерном массиве позиция любого элемента определяется двумя индексами. Если представить двумерный массив в виде таблицы данных, то один индекс означает строку, а второй — столбец. Из этого следует, что, если к доступ элементам массива предоставить в порядке, в котором они реально хранятся в памяти, то правый индекс будет изменяться быстрее, чем левый.
Необходимо помнить, что место хранения для всех элементов массива определяется во время компиляции. Кроме того, память, выделенная для хранения массива, используется в течение всего времени существования массива. Для определения количества байтов памяти, занимаемой двумерным массивом, используйте следующую формулу.
число байтов = число строк х число столбцов х размер типа в байтах
Следовательно, двумерный целочисленный массив размерностью 10×5 занимает в памяти 10x5x2, т.е. 100 байт (если целочисленный тип имеет размер 2 байт).
Многомерные массивы
В C++, помимо двумерных, можно определять массивы трех и более измерений. Вот как объявляется многомерный массив.

тип имя[размер1] [размер2]... [размерN];
Например, с помощью следующего объявления создается трехмерный целочисленный массив размером 4x10x3.

int multidim[4][10][3];
Как упоминалось выше, память, выделенная для хранения всех элементов массива, используется в течение всего времени существования массива. Массивы с числом измерений, превышающим три, используются нечасто, хотя бы потому, что для их хранения требуется большой объем памяти. Например, хранение элементов четырехмерного символьного массива размером 10x6x9x4 займет 2 160 байт. А если каждую размерность увеличить в 10 раз, то занимаемая массивом память возрастет до 21 600 000 байт. Как видите, большие многомерные массивы способны «съесть» большой объем памяти, а программа, которая их использует, может очень быстро столкнуться с проблемой нехватки памяти.
Инициализация массивов
В C++ предусмотрена возможность инициализации массивов. Формат инициализации массивов подобен формату инициализации других переменных.

тип имя_массива [размер] = {список_значений};
Здесь элемент список_значений представляет собой список значений инициализации элементов массива, разделенных запятыми. Тип каждого значения инициализации должен быть совместим с базовым типом массива (элементом тип). Первое значение инициализации будет сохранено в первой позиции массива, второе значение — во второй и т.д. Обратите внимание на то, что точка с запятой ставится после закрывающей фигурной скобки (}).
Например, в следующем примере 10-элементный целочисленный массив инициализируется числами от 1 до 10.

int i [ 10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
После выполнения этой инструкции элемент i[0] получит значение 1, а элемент i[9] —значение 10.
Для символьных массивов, предназначенных для хранения строк, предусмотрен сокращенный вариант инициализации, который имеет такую форму,

char имя_массива[размер] = «строка»;
Например, следующий фрагмент кода инициализирует массив str фразой «привет»,

char str[7] = «привет»;
Это равнозначно поэлементной инициализации.

char str [7] = {'п', 'р', 'и', 'в', 'е', 'т', '\0'};
Поскольку в C++ строки должны завершаться нулевым символом, убедитесь, что при объявлении массива его размер указан с учетом признака конца. Именно поэтому в предыдущем примере массив str объявлен как 7-элементный, несмотря на то, что в слове «привет» только шесть букв. При использовании строкового литерала компилятор добавляет нулевой признак конца строки автоматически.
Многомерные массивы инициализируются по аналогии с одномерными. Например, в следующем фрагменте программы массив sqrs инициализируется числами от 1 до 10 и квадратами этих чисел.

int sqrs[10][2] = {

1, 1,

2, 4,

3, 9,

4, 16,

5, 25,

6, 36,

7, 49,

8, 64,

9, 81,

10, 100

};
Теперь рассмотрим, как элементы массива sqrs располагаются в памяти (рис. 5.2).
При инициализации многомерного массива список инициализаторов каждой размерности (подгруппу инициализаторов) можно заключить в фигурные скобки. Вот, например, как выглядит еще один вариант записи предыдущего объявления.

int sqrs[10][2] = {

{1, 1},

{2, 4},

{3, 9},

{4, 16},

{5, 25},

{6, 36},

{7, 49},

{8, 64},

{9, 81},

{10, 100}

};
При использовании подгрупп инициализаторов недостающие члены подгруппы будут инициализированы нулевыми значениями автоматически.
В следующей программе массив sqrs используется для поиска квадрата числа, введенного пользователем. Программа сначала выполняет поиск заданного числа в массиве, а затем выводит соответствующее ему значение квадрата.

#include <iostream>

using namespace std;

int sqrs[10][2] = {

{1, 1},

{2, 4},

{3, 9},

{4, 16},

{5, 25},

{6, 36},

{7, 49},

{8, 64},

{9, 81},

{10, 100}

};

int main ()

{

int i, j;

cout << "Введите число от 1 до 10: ";

cin >> i;

// Поиск значения i.

for (j=0; j<10; j++)

if (sqrs[j][0]==i) break;

cout << "Квадрат числа " << i << « равен „;

cout << sqrs[j][1];

return 0;

}
Глобальные массивы инициализируются в начале выполнения программы, а локальные — при каждом вызове функции, в которой они содержатся. Рассмотрим пример.

#include <iostream>

#include <cstring>

using namespace std;

void f1 ();

int main ()

{

f1 ();

f1 ();

return 0;

}

void f1 ()

{

char s[80]=“Этo просто тест\n»;

cout << s;

strcpy (s, «ИЗМЕНЕНО\n»); // Изменяем значение строки s.

cout << s;

}
При выполнении этой программы получаем такие результаты.

Это просто тест

ИЗМЕНЕНО

Это просто тест

ИЗМЕНЕНО
В этой программе массив s инициализируется при каждом вызове функции f1 (). Тот факт, что при ее выполнении массив s изменяется, никак не влияет на его повторную инициализацию при последующих вызовах функции f1 (). Поэтому при каждом входе в нее на экране отображается следующий текст.

Это просто тест
«Безразмерная» инициализация массивов
Предположим, что мы используем следующий вариант инициализации массивов для построения таблицы сообщений об ошибках.

char e1[14] = «Деление на 0\n»;

char е2[23] = «Конец файла\n»;

char еЗ[21] = «В доступе отказано\п»;
Нетрудно предположить, что вручную неудобно подсчитывать символы в каждом сообщении, чтобы определить корректный размер массива. К счастью, в C++ предусмотрена возможность автоматического определения длины массивов путем использования их «безразмерного» формата. Если в инструкции инициализации массива не указан его размер, C++ автоматически создаст массив, размер которого будет достаточным для хранения всех значений инициализаторов. При таком подходе предыдущий вариант инициализации массивов для построения таблицы сообщений об ошибках можно переписать так.

char е1[] = «Деление на 0\n»;

char е2[] = «Конец файла\n»;

char еЗ[] = «В доступе отказано\n»;
Помимо удобства в первоначальном определении массивов, метод «безразмерной» инициализации позволяет изменить любое сообщение без пересчета его длины. Тем самым устраняется возможность внесения ошибок, вызванных случайным просчетом.
«Безразмерная» инициализация массивов не ограничивается одномерными массивами. При инициализации многомерных массивов вам необходимо указать все данные, за исключением крайней слева размерности, чтобы С++-компилятор мог должным образом индексировать массив. Используя «безразмерную» инициализацию массивов, можно создавать таблицы различной длины, позволяя компилятору автоматически выделять область памяти, достаточную для их хранения.
В следующем примере массив sqrs объявляется как «безразмерный».

int sqrs[][2] = {

1, 1,

2, 4,

3, 9,

4, 16,

5, 25,

6, 36,

7, 49,

8, 64,

9, 81,

10, 100

};
Преимущество такой формы объявления перед «габаритной» (с точным указанием всех размерностей) состоит в том, что программист может удлинять или укорачивать таблицу значений инициализации, не изменяя размерности массива.
Массивы строк
Существует специальная форма двумерного символьного массива, которая представляет собой массив строк. В использовании массивов строк нет ничего необычного. Например, в программировании баз данных для выяснения корректности вводимых пользователем команд входные данные сравниваются с содержимым массива строк, в котором записаны допустимые в данном приложении команды. Для создания массива строк используется двумерный символьный массив, в котором размер левого индекса определяет количество строк, а размер правого — максимальную длину каждой строки. Например, при выполнении следующей инструкции объявляется массив, предназначенный для хранения 30 строк длиной 80 символов,

char str_array[30][80];
Массив строк — это специальная форма двумерного массива символов.
Получить доступ к отдельной строке довольно просто: достаточно указать только левый индекс. Например, следующая инструкция вызывает функцию gets () для записи третьей строки массива str_array.

gets (str_array[2]);
Чтобы лучше понять, как следует обращаться с массивами строк, рассмотрим следующую короткую программу, которая принимает строки текста, вводимые с клавиатуры, и отображает их на экране после ввода пустой строки.

// Вводим строки текста и отображаем их на экране.

#include <iostream>

#include <cstdio>

using namespace std;

int main ()

{

int t, i;

char text[100][80];

for (t=0; t<100; t++) {

cout << t << ": ";

gets (text[t]);

if (!text[t] [0]) break; // Выход из цикла по пустой строке.

}

// Отображение строк на экране.

for (i=0; i<t; i++)

cout << text[i] << ' \n';

return 0;

}
Обратите внимание на то, как в программе выполняется проверка на ввод пустой строки. Функция gets () возвращает строку нулевой длины, если единственной нажатой клавишей оказалась клавиша <Enter>. Это означает, что первым байтом в строке будет нулевой символ. Нулевое значение всегда интерпретируется как ложное, но взятое с отрицанием (!) дает значение ИСТИНА, которое позволяет выполнить немедленный выход из цикла с помощью инструкции break.
Пример использования массивов строк
Массивы строк обычно используются для обработки таблиц данных. Рассмотрим, например, упрощенную базу данных служащих, в которой хранится имя, номер телефона, количество часов, отработанных служащим за отчетный период, и размер почасового оклада для каждого служащего. Чтобы создать такую программу для коллектива, состоящего из десяти служащих, определим четыре массива (из них первые два будут массивами строк).

char name[10][80]; // Массив имен служащих.

char phone[10][20]; // Массив телефонных номеров служащих.

float hours[10]; // Массив часов, отработанных за неделю.

float wage[10]; // Массив окладов.
Чтобы ввести информацию о каждом служащем, воспользуемся следующей функцией enter ().

// Функция ввода информации в базу данных.

void enter ()

{

int i;

char temp[80];

for (i=0; i<10; i++) {

cout << "Введите фамилию: ";

cin >> name[i];

cout << "Введите номер телефона: ";

cin >> phone[i];

cout << "Введите количество отработанных часов: ";

cin >> hours[i];

cout << "Введите оклад: ";

cin >> wage[i];

}

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

// Отображение отчета.

void report ()

{

int i;

for (i=0; i<10; i++) {

cout << name[i] << ' ' << phone[i] << '\n';

cout << "Заработная плата за неделю: "<< wage[i] * hours[i];

cout << '\n';

}

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

// Простая программа ведения базы данных служащих.

#include <iostream>

using namespace std;

char name[10][80]; // Массив имен служащих.

char phone[10] [20]; // Массив телефонных номеров служащих.

float hours[10]; // Массив часов, отработанных за неделю.

float wage[10]; // Массив окладов.

int menu ();

void enter (), report ();

int main ()

{

int choice;

do {

choice = menu (); // Получаем команду, выбранную пользователем.

switch (choice) {

case 0: break;

case 1: enter ();

break;

case 2: report ();

break;

default: cout << «Попробуйте еще раз.\n\n»;

}

}while (choice != 0);

return 0;

}

// Функция возвращает команду, выбранную пользователем.

int menu ()

{

int choice;

cout << «0. Выход из программы\n»;

cout << «1. Ввод информации\n»;

cout << «2. Генерирование отчета\n»;

cout << "\n Выберите команду: ";

cin >> choice;

return choice;

}

// Функция ввода информации в базу данных.

void enter ()

{

int i;

char temp[80];

for (i=0; i<10; i++) {

cout << "Введите фамилию: ";

cin >> name[i];

cout << "Введите номер телефона: ";

cin >> phone[i];

cout << "Введите количество отработанных часов: ";

cin >> hours[i];

cout << "Введите оклад: ";

cin >> wage[i];

}

}

// Отображение отчета.

void report ()

{

int i;

for (i=0; i<10; i++) {

cout << name[i] << ' ' << phone[i] << '\n';

cout << "Заработная плата за неделю: "<< wage[i] * hours[i];

cout << '\n';

}

}

Комментирование и размещение ссылок запрещено.

Комментарии закрыты.