В данном уроке мы познакомимся со структурами, для чего они нужны и как мы их можем использовать в наших программах.
Нередко в программе может потребоваться объединить несколько переменных различного типа в какой-то один набор для достижения той или иной общей цели. Например, нам нужно описать какой-нибудь товар и создать для него какую-то переменную, которая могла бы хранить ряд его свойств — наименование полное, наименование краткое, вес, цену, количество, единицу измерения и так далее. Эти свойства здесь имеют, как мы видим, различный тип данных, здесь есть и строки, есть и числа с плавающей точкой, могут быть и другие типы данных, а объединить мы их все хотим в какую-то общую группу, присвоить ей какое-то своё отдельное имя, создавать потом с этим именем переменные и обращаться к ним по данному имени, чтобы получить затем вышеперечисленные значения, а также их изменять в ходе нашей программы.
Вот именно в такой ситуации нам на помощь и приходят структуры.
Структура в языке C — это сгруппированные (ая) под одним именем одна или несколько переменных (возможно, различных типов). В качестве этих переменных могут быть также массивы данных, указатели на различные типы данных, также переменные других типов структур и т.д.
struct Basics | C Programming Tutorial
Вот общий вид объявления структуры
Это самое классическое объявление структур, но используется часто.
Вот так например, мы можем описать структуру для какого-то товара
struct goods
char nm [60];
float amount ;
char measure [20];
float price ;
float wieght ;
Затем в коде мы можем объявлять переменные типа нашей структуры вот таким образом
struct goods st1;
Затем мы можем обращаться к данным нашей структуры через точку.
Давайте проинициализируем переменные нашей структуры, которые, кстати, называются ещё полями
strcpy (st1. nm , «Цемент» );
st1. amount = 551.;
strcpy (st1. measure , «мешок» );
st1. price = 350.35;
st1. wieght = 50.;
Объявлять наши структуры мы можем также и через стандартное объявление типов с помощью директивы typedef, тогда уже имя типа данных нашей структуры будет следовать после блока с переменными
typedef struct
char nm [60];
float amount ;
char measure [20];
float price ;
float wieght ;
> goods ;
Переменные типов таких структур мы уже объявляем без ключевого слова struct
goods st1;
После этого мы с данной переменной работаем таким же образом, как и с переменными типов структур, объявленных классическим способом.
Также не лишним будет упомянуть, что переменные наших структур могут использоваться в функциях в качестве возврата. Это один из способов вернуть сразу несколько значений разного типа из функции.
Инициализировать поля переменных типов структур мы можем также и во время их объявления.
C structs
Например, наш товар мы можем описать вот таким способом
Также структуры можно объявлять с помощью создания указателей на них, но это будет рассмотрено в более поздних уроках, когда мы познакомимся с указателями и их использованием.
А, думаю, что пока нам теории по структурам вполне достаточно.
Давайте теперь поработаем со структурами практически.
Создадим проект с именем MYPROG25, который был сделан на основе проекта прошлого урока с именем MYPROG24.
Откроем наш проект в Eclipse, произведём его первоначальную настройку и удалим весь наш код из функции main() за исключением возврата, а то больно много там всего набралось. Функция main() приобретёт вот такой вид
int main()
return 0; //Return an integer from a function
Удалим также объявление перечисления, в том числе и закомментированное, также объявление переменной пользовательского типа. Удалим функции print_res и my_counter с их телами, а также прототипы на них.
Представим, что у нас есть задача описать несколько студентов, у которых будут ФИО, возраст и информация о том, на каком курсе данный студент обучается, так сказать, минимальная информация.
Объявим вот такую глобальную структуру (хотя если мы с данной структурой хотим работать только в рамках какого-то блока, то она вполне имеет право быть и локальной)
Источник: narodstream.ru
struct (C++)
Ключевое struct слово определяет тип структуры и (или) переменную типа структуры.
Синтаксис
[template-spec] struct [ms-decl-spec] [tag [: base-list ]] < member-list >[declarators]; [struct] tag declarators;
Параметры
спецификация шаблона
Необязательные спецификации шаблона. Дополнительные сведения см. в разделе Спецификации шаблонов.
struct
ключевое слово struct ;
ms-decl-spec
Необязательная спецификация класса хранения. Дополнительные сведения см. в ключевом слове __declspec .
Тег
Имя типа, присваиваемое структуре. Тег становится зарезервированным ключевым словом в области структуры. Тег является необязательным. Если он опущен, определяется анонимная структура. Дополнительные сведения см. в разделе Анонимные типы классов.
base-list
Необязательный список классов или структур, из которых эта структура будет наследовать члены. Дополнительные сведения см. в разделе Базовые классы . Перед именем каждого базового класса или структуры может предшествовать описатель доступа (public, private, protected) и ключевое слово virtual . Дополнительные сведения см. в таблице доступа к членам статьи Управление доступом к членам класса .
список членов
Список членов структуры. Дополнительные сведения см. в статье Общие сведения о членах класса . Единственное отличие заключается в том, что struct используется вместо class .
declarators
Список деклараторов, указывающий имена структуры. В списках деклараторов объявляются один или несколько экземпляров типа структуры. Деклараторы могут включать списки инициализаторов, если все элементы данных структуры являются public . Списки инициализаторов часто используются в структурах, так как по умолчанию являются public элементами данных. Дополнительные сведения см. в разделе Обзор деклараторов .
Комментарии
Тип структуры — это пользовательский составной тип. Он состоит из полей или членов, которые могут иметь разные типы.
В C++ структура совпадает с классом, за исключением того, что ее члены по умолчанию. public
Сведения об управляемых классах и структуре в C++/CLI см. в разделе Классы и структуры.
Использование структуры
В C для объявления структуры необходимо явно использовать ключевое struct слово . В C++ не нужно использовать ключевое struct слово после определения типа.
Если тип структуры определен путем размещения одной или нескольких разделенных запятыми имен переменных между закрывающей фигурной скобкой и точкой с запятой, имеется возможность объявления переменных.
Переменные структуры можно инициализировать. Инициализация каждой переменной должна быть заключена в скобки.
Пример
#include using namespace std; struct PERSON < // Declare PERSON struct type int age; // Declare member types long ss; float weight; char name[25]; >family_member; // Define object of type PERSON struct CELL < // Declare CELL bit field unsigned short character : 8; // 00000000 . unsigned short foreground : 3; // 00000. 00000000 unsigned short intensity : 1; // 0000?000 00000000 unsigned short background : 3; // 0. 0000 00000000 unsigned short blink : 1; // ?0000000 00000000 >screen[25][80]; // Array of bit fields int main() < struct PERSON sister; // C style structure declaration PERSON brother; // C++ style structure declaration sister.age = 13; // assign values to members brother.age = 7; cout // Output: // sister.age = 13 // brother.age = 7 // my_cell.character = 1
Источник: learn.microsoft.com
Struct declaration
Структура-это тип,состоящий из последовательности членов,хранение которых распределено в упорядоченной последовательности (в отличие от объединения,которое является типом,состоящим из последовательности членов,хранение которых пересекается).
Спецификатор типа для структуры идентичен спецификатору типа union за исключением используемого ключевого слова:
Syntax
| struct attr-spec-seq(optional)name(optional) | (1) |
| struct attr-spec-seq(optional)name | (2) |
1)Определение структуры:вводит новое имя структуры типа и определяет ее значение
2) Если используется в отдельной строке, как в имени struct ; , declares но не определяет name структуры (см. предварительное объявление ниже). В других контекстах именует ранее объявленную структуру, а атрибут attr-spec-seq не допускается.
| name | — | название структуры,которая определяется. |
| struct-declaration-list | — | любое количество объявлений переменных, объявлений битовых полей и объявлений статических утверждений . Члены неполного типа и члены типа функции не допускаются (за исключением элемента гибкого массива, описанного ниже) |
| attr-spec-seq | — | (C23) необязательный список атрибутов , применяемых к типу структуры |
Explanation
Внутри объекта структуры увеличиваются адреса его элементов (и адреса единиц распределения битовых полей)в порядке,в котором были определены члены.Указатель на структуру может быть приведен к указателю на ее первый член (или,если членом является битовое поле,к единице его распределения).Аналогично,указатель на первый член структуры может быть приведен к указателю на входящую в структуру.Между любыми двумя членами структуры может существовать безымянная подкладка или после последнего члена,но не перед первым членом.Размер структуры как минимум равен сумме размеров ее членов.
Если в структуре определен хотя бы один именованный член, допускается дополнительно объявлять его последний член с типом неполного массива. При доступе к элементу члена гибкого массива (в выражении, использующем оператор . или -> с именем члена гибкого массива в качестве правого операнда), структура ведет себя так, как если бы член массива имел самый длинный размер помещается в памяти, выделенной для этого объекта. Если дополнительное хранилище не было выделено, он ведет себя как массив с 1 элементом, за исключением того, что поведение не определено, если к этому элементу осуществляется доступ или создается указатель, следующий за этим элементом. Инициализация и оператор присваивания игнорируют член гибкого массива. sizeof опускает его, но может иметь большее количество завершающих отступов, чем подразумевает пропуск. Структуры с гибкими элементами массива (или объединения, которые имеют рекурсивно-возможно, элемент структуры с гибким элементом массива) не могут отображаться как элементы массива или как члены других структур.
struct s < int n; double d[]; >; // sd — гибкий член массива struct s t1 = < 0 >; // Хорошо, d как если бы double d [1], но UB для доступа struct s t2 = < 1, < 4.2 > >; // ошибка: инициализация игнорирует гибкий массив // если sizeof (double) == 8 struct s *s1 = malloc(sizeof (struct s) + 64); // как если бы d было двойным d [8] struct s *s2 = malloc(sizeof (struct s) + 40); // как если бы d было двойным d [5] s1 = malloc(sizeof (struct s) + 10); // теперь, как если бы d было двойным d [1].
Превышение на два байта. double *dp = d[0]); // OK *dp = 42; // OK s1->d[1]++; // Неопределенное поведение. 2 лишних байта недоступны // как double.
s2 = malloc(sizeof (struct s) + 6); // то же самое, но UB для доступа, потому что 2 байта // не хватает для завершения 1 двойной dp = d[0]); // Хорошо, можно просто взять адрес *dp = 42; // неопределенное поведение *s1 = *s2; // копирует только sn, а не любой элемент sd // кроме тех, которые попали в sizeof (struct s)
Подобно союзу,неназванный член структуры,тип которой является структурой без названия,известен как anonymous struct , Каждый член анонимной структуры считается членом включающей структуры или объединения. Это применяется рекурсивно, если включающая структура или объединение также являются анонимными.
struct v < union < // анонимный союз struct < int i, j; >; // анонимная структура struct < long k, l; > w; >; int m; > v1; v1.i = 2; // valid v1.k = 3; // неверно: внутренняя структура не анонимна v1.w.k = 5; // valid
Как и в случае с объединением,поведение программы не определено,если структура определена без каких-либо именованных членов (включая тех,которые получены через анонимные вложенные структуры или союзы).
Forward declaration
Заявление в следующей форме.
| struct attr-spec-seq(optional)name ; |
скрывает любое ранее объявленное значение имени name в пространстве имен тегов и объявляет name как новое имя структуры в текущей области, которая будет определена позже. Пока не появится определение, это имя структуры имеет неполный тип .
Это позволяет создавать структуры,которые ссылаются друг на друга:
struct y; struct x < struct y *p; /* . */ >; struct y < struct x *q; /* . */ >;
Обратите внимание, что новое имя структуры также может быть введено просто с помощью тега структуры в другом объявлении, но если в пространстве имен тегов существует ранее объявленная структура с тем же именем , тег будет ссылаться на это имя.
struct s* p = NULL; // тег, называющий неизвестную структуру, объявляет ее struct s < int a; >; // определение структуры, на которую указывает p void g(void) < struct s; // прямое объявление новой локальной структуры s // это скрывает глобальную структуру до конца этого блока struct s *p; // указатель на локальную структуру s // без предварительного объявления выше, // это будет указывать на область видимости файла s struct s < char* p; >; // определения локальной структуры s >
Keywords
Notes
См. Инициализация структуры для правил, касающихся инициализаторов для структур.
Поскольку члены неполного типа не допускаются,а тип структуры не является полным до конца определения,структура не может иметь члена своего собственного типа.Допускается указатель на собственный тип,который обычно используется для реализации узлов в связанных списках или деревьях.
Поскольку объявление структуры не устанавливает область видимости , вложенные типы, перечисления и перечислители, представленные объявлениями в списке структуры объявления, видны в окружающей области, где определена структура.
Example
#include #include int main(void) < struct car < char *make; char *model; int year; >; // объявляет тип структуры // объявляет и инициализирует объект ранее объявленного типа структуры struct car c = 1923, .make=»Nash», .model=»48 Sports Touring Car»>; printf(«car: %d %s %sn», c.year, c.make, c.model); // объявляет тип структуры, объект этого типа и указатель на него struct spaceship < char *make; char *model; char *year; > ship = «Incom Corporation», «T-65 X-wing starfighter», «128 ABY»>, *pship = &ship; printf(«spaceship: %s %s %sn», ship.year, ship.make, ship.model); // адреса увеличиваются в порядке определения // может быть вставлено заполнение struct A < char a; double b; char c;>; printf(«offset of char a = %zunoffset of double b = %zunoffset of char c = %zun» «sizeof(struct A) = %zun», offsetof(struct A, a), offsetof(struct A, b), offsetof(struct A, c), sizeof(struct A)); struct B < char a; char b; double c;>; printf(«offset of char a = %zunoffset of char b = %zunoffset of double c = %zun» «sizeof(struct B) = %zun», offsetof(struct B, a), offsetof(struct B, b), offsetof(struct B, c), sizeof(struct B)); // Указатель на структуру может быть приведен к указателю на ее первый член и наоборот char* pmake = (char*)pship; pship = (struct spaceship *)pmake; >
car: 1923 Nash 48 Sports Touring Car spaceship: 128 ABY Incom Corporation T-65 X-wing starfighter offset of char a = 0 offset of double b = 8 offset of char c = 16 sizeof(struct A) = 24 offset of char a = 0 offset of char b = 1 offset of double c = 8 sizeof(struct B) = 16
References
- Стандарт С17 (ISO/IEC 9899:2018):
- 6.7.2.1 Спецификаторы структуры и объединения (стр:81-84)
- 6.7.2.1 Структура и спецификаторы союза (стр.112-117)
- 6.7.2.1 Структура и спецификаторы союза (стр.101-104)
- 3.5.2.1 Структура и спецификаторы союза
See also
- структурирование и доступ членов профсоюзов
- bit field
- struct initialization
| Документация C++ для объявления класса |
Источник: runebook.dev