ВУЗ: Не указан
Категория: Не указан
Дисциплина: Не указана
Добавлен: 31.03.2021
Просмотров: 193
Скачиваний: 2
А при выполнении этой программы строка, введенная с клавиатуры, будет отображена на экране в обратном порядке. Например, при вводе слова "привет" программа отобразит слово "тевирп". Помните, что строки представляют собой символьные массивы, которые позволяют ссылаться на каждый элемент (символ) в отдельности.
// Отображение строки в обратном порядке.
#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
Строки не равны
привет всем
всем и всем теперь равны
Следующий пример позволяет убедиться в том, насколько простой код требуется для замены всех символов строки их прописными эквивалентами.
// Преобразование символов строки в их прописные эквиваленты.
#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++ можно использовать многомерные массивы. Простейший многомерный массив — двумерный. Двумерный массив, по сути, представляет собой список одномерных массивов. Чтобы объявить двумерный массив целочисленных значений размером 10x20 с именем 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.
В двумерном массиве позиция любого элемента определяется двумя индексами. Если представить двумерный массив в виде таблицы данных, то один индекс означает строку, а второй — столбец. Из этого следует, что, если к доступ элементам массива предоставить в порядке, в котором они реально хранятся в памяти, то правый индекс будет изменяться быстрее, чем левый.
Необходимо помнить, что место хранения для всех элементов массива определяется во время компиляции. Кроме того, память, выделенная для хранения массива, используется в течение всего времени существования массива. Для определения количества байтов памяти, занимаемой двумерным массивом, используйте следующую формулу.
число байтов = число строк х число столбцов х размер типа в байтах
Следовательно, двумерный целочисленный массив размерностью 10x5 занимает в памяти 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';
}
}
Полностью программа базы данных служащих приведена ниже. Обратите особое внимание на то, как реализуется доступ к каждому массиву. Эта версия программы ведения базы данных служащих еще далека от совершенства, поскольку введенная в нее информация теряется сразу же по выходу из программы. Ниже в этой книге мы научимся сохранять информацию в дисковом файле.