ВУЗ: Не указан
Категория: Не указан
Дисциплина: Не указана
Добавлен: 31.03.2021
Просмотров: 192
Скачиваний: 2
Массивы и строки
Массив (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.
Сортировка массива
Одной из самых распространенных операций, выполняемых над массивами, является сортировка. Существует множество различных алгоритмов сортировки. Широко применяется, например, сортировка перемешиванием и сортировка методом Шелла. Известен также алгоритм 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++ строка определяется как символьный массив, который завершается нулевым символом ('\0'). При определении длины символьного массива необходимо учитывать признак ее завершения и задавать его длину на единицу больше длины самой большой строки из тех, которые предполагается хранить в этом массиве.
Строка — это символьный массив, который завершается нулевым символом.
Например, объявляя массив str, предназначенный для хранения 10-символьной строки, следует использовать следующую инструкцию.
char str [11];
Заданный здесь размер (11) позволяет зарезервировать место для нулевого символа в конце строки.
""
Строка, приведенная последней (""), называется нулевой. Она состоит только из одного нулевого символа (признака завершения строки). Нулевые строки используются для представления пустых строк.
Вам не нужно вручную добавлять в конец строковых констант нулевые символы. С++-компилятор делает это автоматически. Следовательно, строка "ПРИВЕТ" в памяти размещается так, как показано на этом рисунке:
Считывание строк с клавиатуры
Проще всего считать строку с клавиатуры, создав массив, который примет эту строку с помощью инструкции 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() не выполняют граничной проверки (на отсутствие нарушения границ массива). Поэтому, если пользователь введет строку, длина которой превышает размер массива, возможны неприятности, о которых упоминалось выше. Из сказанного следует, что оба описанных здесь варианта считывания строк с клавиатуры потенциально опасны.
Некоторые библиотечные функции обработки строк
Язык 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. При подсчете символов, составляющих заданную строку, признак завершения строки (нулевой символ) не учитывается.