Submitted by Игорь Юрьевич Дяжур on чт, 22/12/2011 - 22:13
Часть 3. Хранение информации с помощью массивов и структур
Урок 16. Хранение значений в массивах
Как вы уже знаете, ваши программы во время выполнения хранят информацию в переменных. До сих пор каждая переменная в программе хранила только одно значение в каждый момент времени. Однако в большинстве случаев программам необходимо хранить множество значений, например 50 тестовых очков, 100 названий книг или 1000 имен файлов. Если вашим программам необходимо хранить несколько значений, они должны использовать специальную структуру данных, называемую массивом. Для объявления массива необходимо указать имя, тип массива и количество значений, которые массив будет хранить. Этот урок описывает, как программы объявляют массивы, а затем сохраняют и обращаются к информации, содержащейся в массиве. К концу данного урока вы освоите следующие основные концепции:
5. Массив представляет собой структуру данных, которая позволяет одной переменной хранить несколько значений.
6. При объявлении массива вы должны указать тип значений, хранящихся в массиве, а также количество значений (называемых элементами массива).
7. Все элементы внутри массива должны быть одного и того же типа, например, int, float или char.
8. Для сохранения значения внутри массива вам следует указать номер элемента массива, в котором вы хотите сохранить свое значение.
9. Чтобы обратиться к значению, хранящемуся внутри массива, ваши программы указывают имя массива и номер элемента.
10. При объявлении массива программы могут использовать оператор присваивания для инициализации элементов массива.
11. Программы могут передавать переменные-массивы в функции точно так же, как они передают любой другой параметр.
Программы на C++ широко используют массивы. Когда в уроке 17 вы начнете работать с символьными строками (например, название книги, имя файла и т. д.), вы будете оперировать массивами символов.
ОБЪЯВЛЕНИЕ ПЕРЕМЕННОЙ МАССИВА
Массив представляет собой переменную, способную хранить одно или несколько значений. Подобно переменным, используемым вашими программами до сих пор, массив должен иметь тип (например, inl, char или float) и уникальное имя. В дополнение к этому вам следует указать количество значений, которые массив будет хранить. Все сохраняемые в массиве значения должны быть одного и того же типа. Другими словами, ваша программа не может поместить значения типа float, char и long в один и тот же массив. Следующее объявление создает массив с именем test_scores, который может вмещать 100 целых значений для тестовых очков:
———————————————— Тип массива
int test_scores [100] ; //------> Размер массива
Когда компилятор C++ встречает объявление этой переменной, он распределит достаточно памяти для хранения 100 значений типа int. Значения, хранящиеся в массиве, называются элементами массива.
Массивы хранят несколько значений одного и того же типа
По мере усложнения вашим программам потребуется работать с несколькими значениями одного и того же типа. Например, программы могут хранить возраст 100 служащих или стоимость 25 акций. Вместо того чтобы заставлять программу работать со 100 или с 25 переменными с уникальными именами, C++ позволяет вам определить одну переменную — массив —, которая может хранить несколько связанных значений.
Для объявления массива вы должны указать тип и уникальное имя массива, а также количество элементов, которые будет содержать массив. Например, следующие операторы объявляют три разных массива:
float part_cost[50];
int employee_age[100];
float stock_prices[25];
Обращение к элементам массива
Как вы уже знаете, массив позволяет вашим программам хранить несколько значений в одной и той же переменной. Для обращения к определенным значениям, хранящимся в массиве, используйте значение индекса, которое указывает на требуемый элемент. Например, для обращения к первому элементу массива test_scores вы должны использовать значение индекса 0. Для обращения ко второму элементу используйте индекс 1. Подобно этому, для обращения к третьему элементу используйте индекс 2. Как показано на рис. 16.1, первый элемент массива всегда имеет индекс 0, а значение индекса последнего элемента на единицу меньше размера массива:
Рис. 16.1. Как C++ индексирует элементы массива.
Важно помнить, что C++ всегда использует 0 для индекса первого элемента массива, а индекс последнего элемента на единицу меньше размера массива. Следующая программа ARRAY. CPP создает массив с именем values, который вмещает пять целочисленных значений. Далее программа присваивает элементам значения 100, 200, 300, 400 и 500:
Как видите, программа присваивает первое значение элементу 0 (va lues[0]).Она также присваивает последнее значение элементу 4 (размер Массива (5) минус 1).
Использование индекса для обращения к элементам массива
Массив позволяет вашим программам хранить несколько значений внутри одной и той же переменной. Для обращения к определенному значению внутри массива программы используют индекс. Говоря кратко, значение индекса указывает требуемый элемент массива. Все массивы C++ начинаются с элемента с индексом 0. Например, следующий оператор присваивает значение 100 первому элементу массива с именем scores:
scores[0] = 100;
Когда ваша программа объявляет массив, она указывает количество элементов, которые массив может хранить. Например, следующий оператор объявляет массив, способный хранить 100 значений типа int.
int scores[100];
В данном случае массив представляет собой элементы от scores[0] до scores[99].
Использование индексной переменной
Если ваши программы используют массив, обычной операцией является использование индексной переменной для обращения к элементам массива. Например, предположим, что переменная / содержит значение 3, следующий оператор присваивает значение 400 элементу values[3J:
values[i] = 400;
Следующая программа SHOWARRA.CPP использует индексную переменную i внутри цикла for для вывода элементов массива. Цикл for инициализирует i нулем, так что программа может обращаться к элементу values[O]. Цикл for завершается, когда i больше 4 (последний элемент массива):
Каждый раз, когда цикл for увеличивает переменную i, программа может обратиться к следующему элементу массива. Экспериментируйте с этой программой, изменяя цикл for следующим образом:
for (i = 4; i >= 0; i--) cout << values [i] << ' ';
В данном случае программа будет выводить элементы массива от большего к меньшему.
ИНИЦИАЛИЗАЦИЯ МАССИВА ПРИ ОБЪЯВЛЕНИИ
Как вы уже знаете, C++ позволяет вашим программам инициализировать переменные при объявлении. То же верно и для массивов. При объявлении массива вы можете указать первоначальные значения, поместив их между левой и правой фигурными скобками, следующими за знаком равенства. Например, следующий оператор инициализирует массив values:
int values[5] = { 100, 200, 300, 400, 500 };
Подобным образом следующее объявление инициализирует массив с плавающей точкой:
Если вы не указываете первоначальное значение для какого-либо элемента массива, большинство компиляторов C++ будут инициализировать такой элемент нулем. Например, следующее объявление инициализирует первые три из пяти элементов массива:
int values[5] = { 100, 200, 300 };
Программа не инициализирует элементы values[3] и values[4]. В зависимости от вашего компилятора, эти элементы могут содержать значение 0. Если вы не указываете размер массива, который вы инициализируете при объявлении, C++ распределит достаточно памяти, чтобы вместить все определяемые элементы. Например, следующее объявление создает массив, способяый хранить четыре целочисленных значения:
int numbers[] = { 1, 2, 3, 4 };
ПЕРЕДАЧА МАССИВОВ В ФУНКЦИИ
Ващи программы будут передавать массивы в функции точно так же, как и любые другие переменные. Функция может инициализировать массив, прибавить к массиву значения или вывести элементы массива на экран. Когда вы передаете массив в функцию, вы должны указать тип массива. Нет необходимости указывать размер массива. Вместо этого вы передаете параметр например number_of_elements, который содержит количество элементов в массиве:
void some_function(int array[], int number_of_elements);
Следующая программа ARRAYFUN.CPP передает массивы в функцию show_array, которая использует цикл for для вывода значений массивов:
#include <iostream.h>
void show_array (int array [] , int number_of_elements)
{
int i;
for (i = 0; i < number_of_elements; i++) cout << array[i] << ' '; cout << endl;
}
void main(void)
{
int little_numbers[5] ={1,2,3,4,5};
int big_numbers[3] = { 1000, 2000, 3000 };
show_array(little_numbers, 5);
show_array(big_numbers, 3);
}
Как видите, программа просто передает массив в функцию по имени, а также указывает параметр, который сообщает функции количество элементов, содержащихся в массиве:
show_array(little_numbers, 5);
Следующая программа GETARRAY.CPP использует функцию get_values, ч тобы присвоить три значения массиву numbers:
#include <iostream.h>
void get_values(int array[], int number_of_elements)
{
int numbers[3];
get_values(numbers, 3);
cout << "Значениямассива" << endl;
for (int i = 0; i < 3; i++)
cout << numbers [i] << endl;
}
Как видите, программа передает массив в функцию по имени. Функция в свою очередь присваивает массиву элементы. Из урока 10 вы узнали, что, пока ваша программа не передаст параметры в функцию с помощью адреса, функция не может изменить эти параметры. Однако, как можно заметить в данном случае, функция get_values изменяет параметр-массив numbers. Как вы узнаете из урока 20, C++ действительно передает массивы в функцию, используя указатели. Таким образом, функция может изменить элементы массива, если ей это нужно.
ЧТО ВАМ НЕОБХОДИМО ЗНАТЬ
Из этого урока вы узнали, что ваши программы могут хранить несколько значений одного и того же типа внутри массива. Программы на C++ широко используют массивы. Из урока 17 вы узнаете, что программы могут использовать массивы для хранения символьных строк. До изучения урока 17 убедитесь, что вы освоили следующие основные концепции:
7. Массив представляет собой переменную, которая может хранить одно или несколько значений одного и того же типа.
8. Для объявления массива вам следует указать тип, имя массива, а также количество значений, хранящихся в массиве.
9. Значения внутри массива называются элементами массива.
10. Первый элемент массива хранится как элемент 0 (array[OJ), индекс последнего элемента массива на единицу меньше размера массива.
11. Программы часто используют индексные переменные для обращения к элементам массива.
12. Если функция воспринимает массив как параметр, она должна указать тип и имя, но не размер массива.
13. Если программа передает массив в функцию, она, как правило, передает и параметр, который сообщает функции количество элементов содержащихся в массиве.
14. Так как C++ передает массив в функцию с помощью адреса массива функция может изменять значения, содержащиеся в массиве.
Урок 17. Символьные строки
Символьные строки хранят такую информацию, как имена файлов, названия книг, имена служащих и другие символьные сочетания. Большинство программ на C++ широко используют символьные строки. Далее вы узнаете, что в C++ символьные строки хранятся в массиве типа char, который заканчивается символом NULL (или ASCII 0). В данном уроке символьные строки рассматриваются более подробно. Вы узнаете, как хранить и обрабатывать символьные строки, а также как использовать функции библиотеки этапа выполнения, которые манипулируют символьными строками. К концу этого урока вы освоите следующие основные концепции:
15. Чтобы объявить символьную строку, вы должны объявить массив типа char,
16. Чтобы присвоить символы символьной строке, ваши программы просто присваивают символы элементам массива символьных строк.
17. Программы C++ используют символ NULL (ASCII 0), чтобы отметить последний символ строки.
18. C++ позволяет вашим программам инициализировать символьные строки при их объявлении.
19. Программы могут передавать символьные строки в функцию, как и любой массив.
20. Большинство библиотек этапа выполнения C++ обеспечивают набор функций, которые управляют символьными строками.
Программы на C++ хранят символьные строки как массив типа char. Большинство программ широко используют символьные строки. Экспериментируйте с каждой программой, представленной в этом уроке, чтобы освоиться с символьными строками. Вы обнаружите, что работа с символьными строками подобна работе с массивами, описанной в уроке 16.
ОБЪЯВЛЕНИЕ СИМВОЛЬНЫХ СТРОК В ПРОГРАММАХ
Программисты на 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 (который компилятор добавляет к строке) для определения последнего символа вывода.
Использование символа 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++ хранит символьную константу 'А' и строковую константу "А".
ИНИЦИАЛИЗАЦИЯ СИМВОЛЬНОЙ СТРОКИ
Как вы уже знаете из урока 16, C++ позволяет вам инициализировать массивы при объявлении. Символьные строки C++ не являются исключением. Для инициализации символьной строки при объявлении укажите требуемую строку внутри двойных кавычек, как показано ниже:
char title[64] = "Учимся программировать на языке C++";
Если количество символов, присваиваемое строке, меньше размера массива, большинство компиляторов C++ будут присваивать символы NULL остающимся элементам строкового массива. Как и в случае с массивами других типов, если вы не указываете размер массива, который инициализируете при объявлении, компилятор C++ распределит достаточно памяти для размещения указанных букв и символа NULL:
char title[] = "Учимся программировать на языке C++";
Следующая программа INIT_STR.CPP инициализирует символьную строку при объявлении:
Некоторые программы, представленные в оставшейся части книги, будут инициализировать символьные строки подобным способом. Найдите время для эксперимента с этой программой, изменяя символы, присваиваемые каждой строке.
ПЕРЕДАЧА СТРОК В ФУНКЦИИ
Передача символьной строки в функцию подобна передаче любого массива в качестве параметра. Внутри функции вам нужно просто указать тип массива (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.
ПРЕИМУЩЕСТВА ТОГО, ЧТО NULL ПРЕДСТАВЛЯЕТ СОБОЙ ASCII 0
Как вы уже знаете, символ NULL представляет собой символ ASCII 0. В уроке 7 вы изучали, что C++ использует значение 0, чтобы представлять ложь. Таким образом, поскольку символ NULL равен 0, ваши программы могут упростить многие операции цикла. Например, многие функции просматривают символьные строки символ за символом в поиске NULL. Следующий цикл for иллюстрирует, как программа может искать NULL в строке:
for (index = 0; string[index] != NULL; index++)
Поскольку символ NULL равен 0, многие программы упрощают циклы, которые ищут NULL, как показано ниже:
for (index = 0; string[index]; index++);
В данном случае пока символ, содержащийся в string[index] не NULL (0 или ложь), цикл продолжается.
ИСПОЛЬЗОВАНИЕ СТРОКОВЫХ ФУНКЦИЙ БИБЛИОТЕКИ ЭТАПА ВЫПОЛНЕНИЯ
Из урока 11 вы узнали, что большинство компиляторов C++ обеспечивает обширный набор функций, называемых библиотекой этапа выполнения. Рассматривая библиотеку этапа выполнения, вы обнаружите, что она содержат много разных функций, манипулирующих строками. Например, функция strupr преобразует символьную строку в строку верхнего регистра. Подобно этому, функция strlen возвращает количество символов в строке. Большинство библиотек этапа выполнения обеспечивают даже функции, которые позволяют вам просматривать строки в поисках определенного символа. Например, следующая программа STRUPR.CPP иллюстрирует использование функций strupr и strlwr библиотеки этапа выполнения:
#include <iostream.h>
#include <string.h> // Содержит прототипы
// функций strupr и strlwr
Использование библиотечных функций, манипулирующих строками может сохранить вам время, требуемое для программирования. Выберите время напечатать копию заголовочного файла STRING.H для определения функций манипулирования строками, которые поддерживаются библиотекой вашего компилятора.
Вы должны играть по правилам
Как вы уже знаете, большинство функций, которые манипулируют строками, полагаются на символ NULL как на конец строки. Если ваши программы присваивают строки символам, то следует убедиться, что они добавляют символ NULL в качестве последнего символа строки. Если ваши программы не используют NULL соответствующим образом, то функции, которые полагаются на символ NULL, будут сбиваться.
ЧТО ВАМ НЕОБХОДИМО ЗНАТЬ
Большинство программ на C++ широко использует символьные строки. Из этого урока вы узнали, как работать со строками. Из урока 18 вы узнаете, как сохранять связанную информацию различных типов в переменных, представляющих структуры C++. Используя структуру, вы можете хранить всю информацию о служащем, например его фамилию, возраст, оклад и номер телефона, в одной переменной. Однако, прежде чем приступить к уроку 18, убедитесь, что освоили следующие основные концепции:
6. Символьная строка представляет собой массив символов, завершающийся 0 (символом NULL).
7. Вы создаете символьную строку, объявляя массив типа char.
8. Ваша программа ответственна за размещение символа NULL за последним символом строки.
9. Если программа использует строковые константы, заключенные в
10. двойные кавычки, компилятор C++ автоматически добавляет символ NULL.
11. C++ позволяет вам инициализировать строки при объявлении, указывая требуемые символы внутри двойных кавычек.
12. Большинство компиляторов C++ в своих библиотеках этапа выполнения обеспечивают широкий набор функций для манипулирования строками.
Урок 18. Хранение связанной информации в структурах
Из урока 16 вы узнали, что C++ позволяет хранить в массиве связанную информацию одного и того же типа. Вы уже выяснили, что группировка связанных значений в массив очень удобна. В большинстве случаев программам необходимо группировать связанную информацию разного типа. Например предположим, что ваша программа работает с информацией о служащих. Она должна отслеживать данные о фамилии, возрасте, окладе, адресе, номере служащего и т. д. Для хранения этой информации программе потребуются переменные типа char, int, float, а также символьные строки.
Если вашей программе требуется хранить связанную информацию разных типов, она может использовать структуру. Вы узнаете, что структура представляет собой переменную, группирующую связанные части информации, называемые элементами, типы которых могут различаться. Группируя данные в одну переменную подобным образом, вы упрощаете ваши программы, снижая количество переменных, которыми необходимо управлять, передавать в функции и т. д. В данном уроке рассматривается создание и использование структур. К концу этого урока вы освоите следующие основные концепции:
13. Структуры позволяют вашим программам группировать в одной переменной связанные данные, типы которых могут различаться.
14. Структура состоит из одной или нескольких частей данных, называемых элементами.
15. Для определения структуры внутри программы следует указать имя структуры и ее элементы.
16. Каждый элемент структуры имеет тип, например char, int и float, и имя каждого элемента должно быть уникальным.
17. После того как ваша программа определит структуру, она может объявить переменные типа этой структуры.
18. Для изменения элементов структуры внутри функции ваши программы должны передать структуру в функцию с помощью адреса.
Ваше умение понимать структуры и работать с ними облегчит использование объектно-ориентированных классов C++ в части 4. Выберите время для эксперимента с программами, представленными в этом уроке.
ОБЪЯВЛЕНИЕ СТРУКТУРЫ
Структура определяет шаблон, с помощью которого ваша программа может позднее объявить одну или несколько переменных. Другими словами, ваша программа сначала определяет структуру, а затем объявляет переменные типа этой структуры. Для определения структуры ваши программы используют ключевое слово struct, за которым обычно следует имя и левая фигурная скобка. Следом за открывающей фигурной скобкой вы указываете тип и имя одного или нескольких элементов. За последним элементом вы размещаете правую закрывающую фигурную скобку. В этот момент вы можете (необязательно) объявить переменные данной структуры:
struct name
{
int member_name_l ; | —————— Объявления элементов структуры float member_name_2; } variable; | ——————————————— Объявление переменной }
Например, следующее определение создает структуру, содержащую информацию о служащем:
struct employee
{
char name [64] ;
long employee_id;
float salary;
char phone[10];
int office_number;
};
В данном случае определение не объявляет какие-либо переменные типа этой структуры. После того как вы определите структуру, ваша программа может объявить переменные типа этой структуры, используя имя структуры (иногда называемое структурным тэгом), как показано ниже:
В данном случае оператор создает три переменные структуры employee. В некоторых случаях вы можете увидеть объявление, в котором тэг структуры предваряется ключевым словом struct, как показано ниже:
struct employee boss, worker, new_employee;
Ключевое слово struct является обязательным при программировании на С, так что некоторые программисты могут включать его по привычке. Однако в C++ использовать ключевое слово struct необязательно.
Использование элементов структуры
Структура позволяет вашим программам группировать информацию, называемую элементами, в одной переменной. Чтобы присвоить значение элементу или обратиться к значению элемента, используйте оператор C++ точку (.). Например, следующие операторы присваивают значения различным элементам переменной с именем worker тута employee;
worker.employee_id = 12345;
worker.salary = 25000.00;
worker.оffice_number = 102;
Для обращения к элементу структуры укажите имя переменной, за которым следует точка и имя элемента. Следующая программа EMPLOYEE.CPP иллюстрирует использование структуры типа employee:
#include <iostream.h>
#include <string.h>
void main(void)
{
struct employee
{
char name [64];
long employee_id;
float salary;
char phone[10];
int office_number;
} worker;
// Копировать имя в строку strcpy(worker.name, "Джон Дой");
Как видите, присваивание целому элементу и элементу с плавающей точкой очень просто. Программа использует оператор присваивания, чтобы присвоить значение соответствующему элементу. Однако обратите внимание на использование функции strcpy для копирования символьной строки в элементы name и phone. Если вы не инициализируете элементы при объявлении переменной типа данной структуры, вы должны копировать символьные строки в символьно-строковые элементы.
Объявление переменных структуры
Структуры C++ позволяют вашим программам группировать в одну переменную связанную информацию различных типов. Структура определяет шаблон для объявлений будущих переменных вашей программы. Каждая структура имеет уникальное имя (иногда называемое тэгом). Используя имя структуры, вы можете объявить переменные типа данной структуры. Биты информации, хранящиеся в структуре, называются элементами. Чтобы использовать или присвоить значение элементу, используйте оператор C++ точку, как показано ниже:
Если функция не изменяет структуру, вы можете передать структуру в функцию по имени. Например, следующая программа SHOW_EMP.CPP использует функцию show_employee для вывода элементов структуры типа employee:
#include <iostream.h>
#include <string.h>
struct employee
{
char name[64];
long employee_id;
float salary;
char phone[10];
int office_number;
};
// Копировать номер телефона в строку strcpy(worker.phone, "555-1212");
show_employee(worker);
}
Как видите, программа передает переменную типа данной структуры worker в функцию show__employee по имени. Далее функция show_employee выводит элементы структуры. Однако обратите внимание, что программа теперь определяет структуру employee вне main и до функции show_employee. Поскольку функция объявляет переменную worker типа employee, определение структуры employee должно располагаться до функции.
Функции, изменяющие элементы структуры
Как вы знаете, если функция изменяет параметр, вам следует передавать этот параметр в функцию с помощью адреса. Если функция изменяет элемент структуры, вы должны передавать эту структуру в функцию с помощью адреса, Для передачи переменной типа структуры с помощью адреса вы просто предваряете имя переменной оператором адреса C++ (&), как показано ниже:
some_function(&worker);
Внутри функции, которая изменяет один или несколько элементов, вам следует работать с указателем. Если вы используете указатель на структуру, легче всего обращаться к элементам структуры, используя следующий синтаксис:
pointer_variable->member = some_value;
Например, следующая программа CHG_MBR.CPP передает структуру типа employee в функцию с именем get_employee_id, которая запрашивает у пользователя идентификационный номер служащего и затем присваивает этот номер элементу структуры employee_id. Чтобы изменить элемент, функция работает с указателем на структуру:
#include <iostream.h>
#include <string.h>
struct employee
{
char name[64];
long employee_id;
float salary;
char phone[10];
int office_number;
};
Как видите, внутри main программа передает переменную worker типа структуры в функцию get_employee_id с помощью адреса. Внутри функции gel_employee_id значение, введенное пользователем, присваивается элементу employee_id с помощью следующего оператора:
cin >> worker->employee_id;
Работа с указателями на структуры
Если функция изменяет элемент структуры, вызвавшая программа должна передать структуру в функцию с помощью адреса. Функция, в свою очередь, использует указатель на структуру. Для обращения к элементу структуры функции следует использовать следующий формат:
value = variable->member;
variable->other_member = some_value;
ЧТО ВАМ НЕОБХОДИМО ЗНАТЬ
Структуры позволяют вашим программам группировать связанные части информации различных типов в одной и той же переменной. Комбинируя подобным образом данные в одной переменной, ваши программы могут лучше представлять объекты, состоящие из двух или более частей, например, информацию о служащих, книгах и т. д. Из урока 19 вы узнаете, как использовать объединения C++, которые, подобно структурам, используют элементы, но в отличие от структур по-другому хранятся в памяти. Независимо от количества элементов объединение может хранить только одно значение в каждый момент времени. Прежде чем вы приступите к уроку 19, убедитесь, что освоили следующие основные концепции:
8. Структуры позволяют вашим программам группировать связанную информацию различных типов в одной переменной.
9. Части информации, из которых состоит структура, называются элементами.
10. Структура определяет шаблон, который ваши программы могут использовать для объявления переменных.
11. После определения структуры вы можете использовать ее имя (тэг) для объявления переменных типа данной структуры.
12. Чтобы присвоить значение или обратиться к значению элемента структуры, ваши программы используют оператор точку, например variable.member.
13. Если функция изменяет значение элемента структуры, переменная структуры должна быть передана в функцию с помощью адреса.
14. Если функция использует указатель на структуру, функция должна использовать формат variable->member для обращения к элементу структуры.
Урок 19. Объединения
Из урока 18 вы узнали, как группировать связанную информацию в одной переменной с помощью структур C++. По мере усложнения вашим программам могут потребоваться разные способы просмотра части информации. Кроме того, программе может потребоваться работать с двумя или несколькими значениями, используя при этом только одно значение в каждый момент времени. В таких случаях для хранения данных ваши программы могут использовать объединения. В данном уроке вы изучите, как создавать и использовать объединения для хранения информации. Как вы узнаете, объединения очень похожи на структуры, описанные в уроке 18. Прежде чем вы закончите этот урок, вы освоите следующие основные концепции:
15. Объединения C++ очень похожи на структуры, за исключением того, как C++ хранит их в памяти; кроме того, объединение может хранить значение только для одного элемента в каждый момент времени.
16. Объединение представляет собой структуру данных, подобную структуре C++, и состоит из частей, называемых элементами.
17. Объединение определяет шаблон, с помощью которого программы далее объявляют переменные.
18. Для обращения к определенному элементу объединения ваши программы используют оператор C++ точку.
19. Чтобы изменить значения элемента объединения внутри функции, ваша программа должна передать переменную объединения в функцию с помощью адреса.
20. Анонимное объединение представляет собой объединение, у которого нет имени (тэга).
Как вы узнаете, объединения очень похожи на структуры C++, однако способ, с помощью которого C++ хранит объединения, отличается от способа, с помощью которого C++ хранит структуры.
КАК C++ ХРАНИТ ОБЪЕДИНЕНИЯ
Внутри ваших программ объединения C++ очень похожи на структуры. Например, следующая структура определяет объединение с именем distance, содержащее два элемента:
union distance
{
int miles;
long meters;
};
Как и в случае со структурой, описание объединения не распределяет память. Вместо этого описание предоставляет шаблон для будущего объявления переменных. Чтобы объявить переменную объединения, вы можете использовать любой из следующих форматов:
union distance
{
union distance
{
int miles; int miles;
long meters; long meters;
} japan, germany, franee;
};
distance japan, germany, franee;
Как видите, данное объединение содержит два элемента: miles и meters. Эти объявления создают переменные, которые позволяют вам хранить расстояния до указанных стран. Как и для структуры, ваша программа может присвоить значение любому элементу. Однако в отличие от структуры значение может быть присвоено только одному элементу в каждый момент времени. Когда вы объявляете объединение, компилятор C++ распределяет память для хранения самого большого элемента объединения. В случае объединения distance компилятор распределяет достаточно памяти для хранения значения типа long, как показано на рис. 19.
Рис. 19. C++ распределяет память, достаточную для хранения только самого большого элемента объединения.
Предположим, что ваша программа присваивает значение элементу miles, как показано ниже:
japan.miles = 12123;
Если далее ваша программа присваивает значение элементу meters, значение, присвоенное элементу miles, теряется.
Следующая программа USEUNION.CPP иллюстрирует использование объединения distance. Сначала программа присваивает значение элементу
miles и выводит это значение. Затем программа присваивает значение элементу meters. При этом значение элемента miles теряется:
Как видите, программа обращается к элементам объединения с помощью точки, аналогичная запись использовалась при обращении к элементам структуры в уроке 18.
Объединение хранит значение только одного элемента в каждый момент времени
Объединение представляет собой структуру данных, которая, подобно структуре C++, позволяет вашим программам хранить связанные части информации внутри одной переменной. Однако в отличие от структуры объединение хранит значение только одного элемента в каждый момент времени. Другими словами, когда вы присваиваете значение элементу объединения, вы перезаписываете любое предыдущее присваивание.
Объединение определяет шаблон, с помощью которого ваши программы могут позднее объявлять переменные. Когда компилятор C++ встречает определение объединения, он распределяет количество памяти, достаточное для хранения только самого большого элемента объединения.
ПРЕДСТАВЛЕНИЕ ОБ АНОНИМНЫХ ОБЪЕДИНЕНИЯХ C++
Анонимное объединение представляет собой объединение, у которого нет имени. C++ предоставляет анонимные объединения, чтобы упростить использование элементов объединений, предназначенных для экономии памяти или создания псевдонимов для определенного значения. Например, предположим, что вашей программе требуются две переменные miles и meters. Кроме того, предположим, что программа использует только одну из них каждый данный момент времени. В этом случае программа могла бы использовать элементы объединения, подобного уже обсуждавшемуся объединению distance, а именно name.miles и name.meters. Следующий оператор создает анонимное (безымянное) объединение:
union
{
int miles;
long meters;
};
Как видите, объявление не использует имя объединения и не объявляет переменную объединения. Программа, в свою очередь, может обращаться к элементам с именами miles и meters без помощи точки. Следующая программа ANONYM.CPP создает анонимное объединение, которое содержит элементы miles и meters. Обратите внимание, что программа трактует элементы как обычные переменные. Однако различие между элементами и обычными переменными заключается в том, что, когда вы присваиваете значение любому из этих элементов, значение другого элемента теряется:
Как видите, с помощью анонимного объединения, программа может сэкономить память, не используя имя объединения и точку для обращения к значениям элементов.
Анонимные объединения позволяют вашим программам экономить пространство
Анонимное объединение представляет собой безымянное объединение. Анонимные объединения обеспечивают вашим программам способ экономии памяти, и при этом можно не использовать имя объединения и точку. Следующие олераторы определяют анонимное объединение, способное хранить две символьные строки:
union
{
char short_name[13];
char long_name[255];
};
ЧТО ВАМ НЕОБХОДИМО ЗНАТЬ
Из этого урока вы узнали, как создать объединение внутри вашей программы. Вы уже поняли, что формат объединения подобен формату структуры. Однако способ, с помощью которого C++ хранит объединения, очень отличается от способа хранения структуры. Из урока 10 вы впервые узнали, что для того, чтобы функция изменила параметр, вашей программе следует передать этот параметр в функцию с помощью указателя (или адреса памяти). Начиная с десятого урока, ваши программы использовали указатели для массивов и символьных строк. В уроке 20 вы рассмотрите операции с указателями C++ с другой стороны. До изучения урока 20 убедитесь, что вы освоили следующее:
6. Когда вы объявляете объединение, компилятор C++ распределяет память, достаточную для хранения только самого большого элемента объединения.
7. Описание объединения не распределяет память, вместо этого оно обеспечивает шаблон, с помощью которого программы могут позднее объявлять переменные.
8. Программы обращаются к элементам объединения, используя точку. Когда ваша программа присваивает значение элементу объединения, то значение, присвоенное, возможно, ранее другому элементу, теряется.
9. Анонимное объединение представляет собой объединение, у которого нет имени. Когда программа объявляет анонимное объединение, она может использовать элементы такого объединения подобно любым другим переменным без точки.
Урок 20. Указатели
Как вы уже знаете, программы на C++ хранят переменные в памяти. Указатель представляет собой адрес памяти, который указывает (или ссылается) на определенный участок. Из урока 10 вы узнали, что для изменения параметра внутри функции ваша программа должна передать адрес параметра (указатель) в функцию. Далее функция в свою очередь использует переменную-указатель для обращения к участку памяти. Некоторые программы, созданные вами в нескольких предыдущих уроках, использовали указатели на параметры. Аналогично этому, когда ваши программы работают с символьными строками и массивами, они обычно используют указатели, чтобы оперировать элементами массива. Так как применение указателей является общепринятым, очень важно, чтобы вы хорошо понимали их использование. Таким образом, этот урок рассматривает еще один аспект применения указателей. К концу данного урока вы освоите следующие основные концепции:
10. Для простоты (для уменьшения кода) многие программы трактуют символьную строку как указатель и манипулируют содержимым строки, используя операции с указателями.
11. Когда вы увеличиваете переменную-указатель (переменную, которая хранит адрес), C++ автоматически увеличивает адрес на требуемую величину (на 1 байт для char, на 2 байта для int, на 4 байта для float и т.д.).
12. Ваши программы могут использовать указатели для работы с массивами целочисленных значений или значений с плавающей точкой.
Операции с указателями широко используются в C++. Выберите время для эксперимента с программами, представленными в этом уроке.
ИСПОЛЬЗОВАНИЕ УКАЗАТЕЛЯ НА СИМВОЛЬНУЮ СТРОКУ
Как вы уже знаете, указатель содержит адрес памяти. Когда ваша программа передает массив (например, символьную строку) в функцию, C++ передает адрес первого элемента массива. В результате совершенно обычно для функции использовать указатель на символьную строку. Чтобы объявить указатель на символьную строку, функция просто предваряет имя переменной звездочкой, как показано ниже:
void some_function(char *string);
Звездочка, которая предваряет имя переменной, указывает C++, что переменная будет хранить адрес памяти — указатель. Следующая программа PTR_STR.CPP использует указатель на символьную строку внутри функции show_string для вывода содержимого строки по одному символу за один раз:
#include <iostream.h>
void show_string(char *string)
{
while (*string != '\0')
{
cout << *string;
string++;
}
}
void main(void)
{
show_string( "Учимся программировать на языке C++!");
}
Обратите внимание на цикл while внутри функции show_slring. Условие while (*string != '\0') проверяет, не является ли текущий символ, указываемый с помощью указателя string, символом NULL, который определяет последний символ строки. Если символ не NULL, цикл выводит текущий символ с помощью cout. Затем оператор string++; увеличивает указатель siring таким образом, что он указывает на следующий символ строки. Когда указатель string указывает на символ NULL, функция уже вывела строку и цикл завершается.
Рис. 20. Сканирование строки с помощью указателя.
Предположим, например, что строка, переданная в функцию, находится в памяти компьютера по адресу 1000. Каждый раз, когда функция увеличивает указатель string, он указывает на следующий символ (адрес 1001,1002, 1003 и т. д.), как показано на рис. 20.
Второй пример
Вы только что узнали, что, используя указатель, ваша функция может сканировать строку символов, пока не будет обнаружен символ NULL. Следующая программа PTR_LEN.CPP использует указатель на строку в функции string_length для определения количества символов в строке:
Как видите, функция string_length сканирует символы строки до тех пор, пока не встретит символ NULL.
Увеличение указателя на символьную строку
Когда программа передает массив в функцию, C++ передает адрес памяти первого элемента этого массива. Используя переменную-указатель, функция может перемещаться по содержимому массива, просто увеличивая значение указателя. Например, предположим, что программа передает в функцию символьную строку "Привет". Внутри функции переменная-указатель сначала указывает на участок памяти, который содержит букву 'П'. Когда функция увеличивает указатель, то он далее указывает на участок памяти, который содержит букву 'р'. По мере увеличения функцией значения указателя, он поочередно указывает на каждую букву в строке и наконец указывает на символ NULL.
Уменьшение количества операторов
Чтобы определить конец символьной строки, каждая из предыдущих программ использовала следующий цикл while:
while (*string != '\0')
Как уже обсуждалось, символ NULL ('\0') представляет собой значение ASCII 0. Так как C++ использует значение 0, чтобы представить ложь, ваши программы могут записать предыдущий цикл следующим образом:
while (*string)
В данном случае пока символ, определяемый указателем строки, не равен 0 (NULL), условие оценивается как истинное и цикл будет продолжаться. Из урока 5 вы узнали, что постфиксная операция увеличения C++ позволяет вам использовать значение переменной, а затем увеличивает это значение. Многие программы на C++ используют постфиксные операции увеличения и уменьшения, чтобы сканировать массивы с помощью указателей. Например, использование постфиксной операции увеличения делает следующие циклы while идентичными:
while (*string)
{
cout << *string++;
}
while (*string)
{
cout << *string;
string++;
}
Оператор cout << *string++, заставляет C++ вывести символ, указываемый указателем string, а затем увеличить текущее значение string, чтобы он указывал на следующий символ. С помощью этих методов следующая программа SMARTPTR.CPP иллюстрирует новую реализацию функций show_string и string_length:
#include <iostream.h>
void show_string(char *string)
{
while (*string) cout << *string++;
}
int string_length(char •string)
(
int length = 0;
while (*string++) length++;
return(length) ;
}
Если вы встретите функции C++, которые манипулируют строками с помощью указателей, то они с большой долей вероятности будут использовать подобную краткую запись.
Сканирование символьной строки
Одно из наиболее широко употребляемых использовании указателей в программах на C++ заключается в сканировании символьных строк. Для уменьшения количества кода многие программы используют следующие операторы для сканирования строки:
while (*string)
{
// операторы
string++;
// продвинуть к следующему символу
}
Следующая функция string_uppercase использует указатели для преобразования символов строки в символы верхнего регистра:
char *string_uppercase(char* string)
{
char *starting_address = string; //адресstring[0];
while (*string)
Эта функция сохраняет и возвращает начальный адрес строки, ко торый позволяет вашим программам использовать функцию следующим образом:
cout << Btring_uppercase("Привет,мир!")<< endl;
* Поскольку при переводе книги обрабатываемые символы заменены с английских на русские, то этот алгоритм работает не для всех кодировок кирилицы в DOS и Windows. — Прим. перев.
ИСПОЛЬЗОВАНИЕ УКАЗАТЕЛЕЙ С ДРУГИМИ ТИПАМИ МАССИВОВ
Несмотря на то что указатели широко используются с символьными строками, вы можете использовать указатели с массивами других типов. Например, следующая программа PTRFLOAT.CPP использует указатель на массив типа float для вывода значений с плавающей точкой:
#include <iostream.h>
void show_float(float *array, int number_of_elements)
{
int i;
for (i = 0; i < number_of_elements; i++) cout << *array++ << endl;
}
Как видите, внутри функции show_float цикл for использует значение, указываемое с помощью указателя array, а затем увеличивает этот указатель до следующего значения. В данном случае программа должна передать параметр, который задает количество элементов массива, поскольку в отличие от символьных строк массивы типа float (или int, long и т. д.) не используют символ NULL для определения последнего элемента.
О МАТЕМАТИКЕ УКАЗАТЕЛЯ
Как вы уже знаете, ваши программы могут использовать указатели на массивы любых типов. В предыдущей программе функция show_float увеличивала указатель для продвижения по массиву типа float. Указатель указывает на участок памяти, содержащий значение определенного типа, например char, int или float. Когда функция сканирует массив с помощью указателя, функция увеличивает указатель для продвижения от одного значения к следующему. Чтобы указатель указывал на следующий элемент массива, C++ должен знать размер каждого элемента (в байтах), чтобы определить, на сколько необходимо увеличить значение указателя. Например, для продвижения указа-
теля к следующему символу в массиве, C++ должен увеличить значение указателя на 1. Однако, чтобы указать следующее значение в массиве типа int C++ должен увеличить указатель на два байта (значение типа int занимает два байта памяти). Для значений типа. float C++ увеличивает указатель на 4 байта. Зная тип значения, на которое указывает указатель, C++ знает, на сколько необходимо увеличить значение этого указателя. В ваших программах вы просто используете оператор увеличения, например pointer++. Однако за кулисами C++ увеличивает реальное значение (адрес памяти), содержащееся в указателе, на корректную величину.
ЧТО ВАМ НЕОБХОДИМО ЗНАТЬ
Программы на C++ широко используют указатели, особенно для манипулирования строками. В данном уроке рассмотрен еще один широко используемый аспект при работе с указателями. В уроке 21 вы начнете использовать объектно-ориентированные возможности C++! Для начала вы создадите классы, подобные структурам. Ваши программы будут использовать класс для определения объекта, например file. Внутри класса вы укажете функции для манипулирования этим объектом, например print Jile или delete_file. До перехода к уроку 21 убедитесь, что вы изучили следующее:
8.
1. Указатели содержат адрес памяти. Когда вы передаете в функцию массив, C++ передает адрес первого элемента массива.
2. Увеличивая значение указателя, вы можете адресовать с его помощью следующий элемент массива.
3. Функции, которые манипулируют строками с помощью указателей, обычно сканируют строку до того момента, пока не найден символ NULL.
4. При использовании указателей с массивами других типов ваши функции должны знать количество элементов массива или специальный маркер конца массива.
5. При использовании указателей с массивами других типов C++ автоматически (за кулисами) увеличивает указатель (адрес памяти) на требуемую величину таким образом, чтобы данный указатель указывал на следующий элемент массива.
