Структуры в С++. Продолжаем знакомиться
Продолжаем знакомиться со структурами. Начало знакомства описано в теме:
Структуры могут содержать внутри себя не только собранные вместе переменные, но и функции. Функции помогают нам взаимодействовать с объектами структуры: заполнить структуру, считать значение из структуры, найти что-то в структуре и т. п.
- В структурах можно описывать функции
Влепленные в структуру функции использовать иногда намного удобнее, чем чуждые для структуры функции.
Самый стандартный способ взаимодействия со структурой — это задание значений атрибутам и получение значений из атрибутов структуры. Сейчас я покажу код, в котором будут использованы две функции, описанные внутри структуры.
Для понимания темы следует знать:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 |
#include <iostream> using namespace std; struct MyStruct{ //Структура MyStruct int x; //Атрибут x представляет собой целое число int int get_x(){ //Функция для считывания значения атрибута x return x; //отдаём значение атрибута x } void set_x(const int value){ //Функция для установки значения в атрибут x x = value; //копируем в x структуры значение пришедшего в функцию параметра value } }; int main(){ MyStruct T; //Объявлен объект Т с типом MyStruct //T = 100; //Так сейчас нельзя T.set_x(200); //Записываем в атрибут x объекта T значение 200 cout << T.get_x(); //Считываем значение атрибута x объекта T выводом на экран cin.get(); } |
Вообще, использовать присваивание знаком присваивания можно, но нужны дополнительные телодвижения: требуется перегружать операцию =, но многие мои читатели ещё не дошли до перегрузок операций, поэтому считаем, что так нельзя.
Атрибут в написанной структуре только один: x, поэтому код должно быть не очень сложно понять. Мы влияем сейчас только на этот единственный атрибут.
Внутри структуры существует, так сказать, внутренний мир, и все атрибуты внутри структуры внутри этого мира самые обычные переменные, но за пределами структуры эти переменные закрыты границей структуры. Поскольку внутри структуры любые её атрибуты самые обычные переменные (очень напоминают глобальные, но глобальны они только в пределах собственной структуры), то их внутри структуры можно легко использовать в любом месте. Но поскольку они закрыты структурой от внешнего мира, то чтобы получить взаимодействие внешнего мира и скрываемых структурой атрибутов, нам нужен своего рода "посол-посредник". Таким "послом-посредником" может замечательно работать значение, относящееся к функции: параметр, приходящий в функцию или значение, уходящее из функции. Мы можем нагрузить таких "посредников" нужной информацией и информация будет передаваться цепочкой как эстафетная палочка. Функции, используемие для получения информации или установки значений, обычно называют геттерами и сеттерами (от англ. get — получать и set — устанавливать), что стараются обозначить в названиях функций.
В показанном примере атрибут x внутри своей структуры в некотором роде напоминает глобальную переменную, поэтому он легко видим в любой функции той же области, в которой сам находится. Так и получается, что когда мы устанавливали параметр, вовнутрь функции было внедрено значение путём приёма значения из внешнего мира в параметр функции get_x. И внутри функции оказалось видно две сущности: сам параметр функции и атрибут структуры, атрибут x. Поскольку две сущности оказались в одной области, то они легко могут обмениваться информацией. Таким образом x впитывает в себя значение, которое пришло в параметр value. И это вот и есть весь механизм передачи значения в атрибут структуры.
Чтобы отдать значение во внешний мир, можно использовать return, только нужно следить, чтобы тип функции соответствовал отдаваемому из функции значению. В большинстве случаев вы будете видеть именно такой способ. Его, по крайней мере, удобно использовать, если значение какого-атрибута структуры нужно сохранять в перемменные внешнего для структуры мира. Можно бы было не использовать return, а задать параметру функции, отдающей информацию об атрибуте, ссылочный характер. Тогда можно бы было этот параметр изменять внутри внутриструктурной функции, чем можно было напрямую влиять на какой-то объект внешнего мира.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 |
#include <iostream> using namespace std; struct MyStruct{ //Структура MyStruct int x; //Атрибут x представляет собой целое число int void get_x(int &value){ //Функция для считывания значения атрибута x value = x; //влияем на внешний объект путём изменения ссылочного параметра функции } void set_x(const int value){ //Функция для установки значения в атрибут x x = value; //копируем в x структуры значение пришедшего в функцию параметра value } }; int main(){ MyStruct T; //Объявлен объект Т с типом MyStruct int atribut; //В эту переменную будем записывать значение атрибута x, подбираемого из объекта T T.set_x(200); //Записываем в атрибут x объекта T значение 200 T.get_x(atribut); //Записываем в а значение атрибута x cout << atribut << '\n'; cin.get(); } |
Первое время вы можете использовать наиболее понятный вам способ, но привыкнуть в любом случае придётся к обоим вариантам. Это не относится к структурам, а относится к параметрам функций. Можно и немного иначе, но об этом позднее.
В показанном сейчас варианте смысл в том, что мы моделируем некоторого рода посредничество между внешним миром и миром структуры. Берём посредника, наделяем его информацией и передаём информацию или вовнутрь структуры или вовне.
Перед дальнейшим чтением вам необходимо переварить уже прочитанное, понять. Потому что дальше всё, что в статье будет написано, происходит из этого.
Конечно, структуру, содержащую только один атрибут, использовать если и стоит, то в редком случае. Структуры нужны для более сложных сущностей. И обрабатывать их удобно комплексно. Т. е. если у объекта много атрибутов, то можно создать, например, для заполнения всех атрибутов одну функцию.
Для примера возьмём простую программу, в которой опишем структуру "TFilm".
Какие атрибуты можно задать фильму? Название, жанр, оценка. Нам трёх сейчас хватит. На основе этого и создадим структуру, а структура, сооружённая нами, в свою очередь, станет основой объектам.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 |
#include <iostream> using namespace std; struct TFilm{ //Структура TFilm static const int N = 255; //длина строк, для массивов char caption[N] = ""; //Название фильма char genre[N] = ""; //Жанр int rank; //Оценка void set_caption(){ cout << "input film caption: "; //Диалог: введите название фильма cin.getline(caption, N); //считываем название с клавиатуры } const char* get_caption(){ return caption; //отдаём название } void set_genre(){ cout << "input film genre: "; //Диалог: введите жанр фильма cin.getline(genre, N); //считываем название с клавиатуры } const char* get_genre(){ return genre; //отдаём название жанра } void set_rank(){ cout << "input rank: "; //Диалог: введите название фильма cin >> rank; //считываем название с клавиатуры } int get_rank(){ return rank; //отдаём название } /////////////////////////////////////////////////////////////////////////////// // После того как создали отдельно для каждого атрибута запись и чтение // // мы можем объединить все чтения в одну функци и всю запись в другую // /////////////////////////////////////////////////////////////////////////////// void set(){ set_caption(); set_genre(); set_rank(); } void get(){ cout << "\n=== film info ===\n"; cout << "caption: " << get_caption() << '\n'; cout << "genre: " << get_genre() << '\n'; cout << "rank: " << get_rank() << '\n'; cout << "===== ==== ==== ====" << endl; } }; int main(){ TFilm film1; film1.set(); //Записываем в объект фильм значения film1.get(); //Выводим значения из объекта cin.get(); } |
Теперь можно манипулировать чуть более сложными объектами, чем совсем в простые, очень удобным способом. Например, если надо создать ещё один объект, то создаётся он также, как и обычная переменная: ему даётся тип, созданная нами структура, имя и поcле мы получаем возможность непринуждённого и несложного управления, что можно понять по показанному примеру.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
int main(){ TFilm film1, film2, film3; film1.set(); //Записываем в объект фильм значения film2.set(); //Записываем в объект фильм значения film3.set(); //Записываем в объект фильм значения film1.get(); //Выводим значения из объекта film2.get(); //Выводим значения из объекта film3.get(); //Выводим значения из объекта cin.get(); } |
На самом деле эту созданную нами структуру можно немного развить, перегрузив внутренние функции, чтобы была возможность не только задавать значения посредством клавиатуры, но и, например, прямо из исходного кода.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 |
#include <iostream> #include <cstring> //для cstring using namespace std; struct TFilm{ //Структура TFilm static const int N = 255; //длина строк, для массивов char caption[N] = ""; //Название фильма char genre[N] = ""; //Жанр int rank; //Оценка void set_caption(){ cout << "input film caption: "; //Диалог: введите название фильма cin.getline(caption, N); //считываем название с клавиатуры } void set_caption(const char* S){ strcpy(caption, S); //скопировали пришедшее извне название в основное внутренне название } const char* get_caption(){ return caption; //отдаём название } void set_genre(){ cout << "input film genre: "; //Диалог: введите жанр фильма cin.getline(genre, N); //считываем название с клавиатуры } void set_genre(const char* S){ strcpy(genre, S); //скопировали пришедшее извне название в основное внутренне название } const char* get_genre(){ return genre; //отдаём название жанра } void set_rank(){ cout << "input rank: "; //Диалог: введите название фильма cin >> rank; //считываем название с клавиатуры } void set_rank(const int value){ rank = value; //скопировали пришедшее значение во внутренню оценку } int get_rank(){ return rank; //отдаём название } /////////////////////////////////////////////////////////////////////////////// // После того как создали отдельно для каждого атрибута запись и чтение // // мы можем объединить все чтения в одну функци и всю запись в другую // /////////////////////////////////////////////////////////////////////////////// void set(){ set_caption(); set_genre(); set_rank(); } void set(const char* caption_, const char* genre_, const int rank_){ set_caption(caption_); set_genre(genre_); set_rank(rank_); } void get(){ cout << "\n=== film info ===\n"; cout << "caption: " << get_caption() << '\n'; cout << "genre: " << get_genre() << '\n'; cout << "rank: " << get_rank() << '\n'; cout << "===== ==== ==== ====" << endl; } }; int main(){ TFilm film1; // film1.set(); //Записываем в объект фильм значения // film1.get(); //Выводим значения из объекта film1.set("Terminator","fantastic",10); //Теперь можно и так film1.get(); cin.get(); } |
Одиночные структуры не очень интересны. Чаще используют массивы структур, при этом добавляют дополнительной функциональности. Но для начала нужно научиться писать простенькие структуры, под которые создавать объкты, которыми манипулировать в ходе работы программы.
2 комментария на «“Структуры в С++. Продолжаем знакомиться”»
Добавить комментарий
Случайная книга в электронном формате
Дорогой автор,скажите,пожалуйста,почему на последней и пред пред последней картинках с кодом(номера листингов не указаны )’: ) в заголовках некоторых функций есть звездочки?Они находятся после типов возвращаемых переменных и до названий функций.Зачем они там нужны???Не понимаю.Это вроде и не указатели на функции.там же скобки должны быть.заранее спасибо за ответ,Алексей!Да и за сайт спасибо.Он классный 😀
const char* get_genre()
Чтобы функция отдавала символьную строку, а не один символ, используется тип возвращаемого значения указатель на символьную строку. Это с языка С, когда не было в С++ типа string
Это не указатели на функции, а тип значения, которое отдаётся функцией. Указатели.