Структура в Си - тип данных, предназначенный для размещения значения разного типа в одном объекте. Полезен, когда необходимо объединить несколько переменных с разными типами под одним именем. Делают программу более компактной, ею удобней управлять. Структура имеет схожие особенности с массивами и классами.
Массивы
Прежде чем говорить о структуре в Си, нужно описать массив.
Существуют массивы одномерные, двумерные, трехмерные. Одномерный - это такой, у которого есть только одна строка с заполненными значениями. Двумерный - одномерный массив, внутри которого находятся другие одномерные массивы.
Обычный массив в Си записывается так: int a = {1, 2, 3, 4}.
Видим, что a - имя, int - тип данных, внутри фигурных скобок { } находятся значения, между квадратными скобками указывается длина, то есть количество элементов. Количество элементов является статическим, равняется 4. Это означает, что если в этом примере пользователь добавит пятое значение, компилятор выдаст ошибку. Если изначально не известно количество, они могут быть добавлены позже, но в квадратных скобках не ставится значение.
Двумерный объявляется похожим образом. Например, массив, который содержит 5 элементов-массивов, при этом каждый содержит по 3 элемента объявляется так: int a.По аналогии с одномерным добавлять ничего нельзя, чтобы не получить ошибку компилирования.
Различают динамические и статические. Статический - это такой, который вмещает фиксированное количество данных, то есть имеет постоянную длину. Под динамическим понимается тот, размер которого не ограничивается, он может меняться во время выполнения программы. Инициализация динамического массива происходит без указания точного количества.
Классы
Класс и структура похожи по между собой, но отличаются некоторыми нюансами. Что это такое? Это абстракция, описывающая методы еще не существующего объекта. После создания объект или, как он называется по-другому, экземпляр класса имеет конкретные свойства. Методы могут использоваться внутри, снаружи или при наследовании.
Класс объявляется так:
class /*class name*/
/* спецификатор доступа private обозначает, что управление методами возможно только внутри класса*/
/* делает свойства доступными для других частей кода */
/* наследуемые классы получают возможность использовать эти свойства */
Что такое структура в языке Си
Предназначена для хранения несколько типов данных. Например, чтобы создать каталог журналов, нужно иметь список с такими параметрами:
- дата издания;
- номер выпуска;
- название;
- стоимость.
Для решения этой задачи можно было бы применить массивы.
Объявляем массив с датами int date, номерами int number, названиями char title, стоимостью int price.
Обращаясь по индексу, мы получаем требуемую информацию. Вывод информации о произведении под номером 3 выглядит так: cout << “дата выпуска: ” date “, номер: ” number “, название: ” title “, стоимость: “ price).
Структура упрощает запись, описывается следующим образом:
Видим одно из главных преимуществ - присутствуют разные типы переменных. Программист не просто экономит время - он упрощает код, в дальнейшем ему будет намного проще работать.
Объявление
Структуры в Си играют очень важную роль - объединение данных различного типа.
Для начала нужно указать имя структуры и свойства.
Struct - ключевое слово, оно начинает объявление, name - имя, type - тип данных, member - имя элемента.
Объявляется так:
name name2, где name - заданное при создании структуры имя, а name2 - имя переменной.
Объявить переменные можно на этапе создания.
Первый и второй пример равносильны друг другу.
Если есть необходимость объявить несколько переменных, они перечисляются через запятую.
} name2, name3, name4.
Инициализация
После объявления структуру в Си необходимо инициализировать.
name2.member=”a”;
Инициазация может происходить при создании.
char member = “a”;
У структуры такой же синтаксис, как у класса. У них практически одинаковое поведение, возможности. Все, что находится в теле класса, по умолчанию недоступно для использования другими объектами.
У структуры все наоборот - все поля и методы являются публичными. Вручную можно задать модификатор доступа private и таким образом открыть доступ другим функциям или классам.
Массивы - это множество компонентов одного типа. Они располагаются рядом с друг другом, обращение к каждому из них осуществляется по числовому индексу. Существуют одномерные массивы, двумерные, трехмерные.
У одномерного только одна строка и n-e количество элементов. Объявление выглядит так:
Массив структур в Си объявляется так:
В этом примере мы создали MyStruct с элементом целочисленного типа под именем "а". Объявляем переменную obj1 - она является массивом, состоит из 10 элементов.
При объявлении нескольких массивов одного типа используется MyStruct obj1, obj2, инициализация происходит во время объявления. Выглядит так:
Создание массива структур с динамическим выделением памяти выглядит точно также, как создание простого динамического массива. Для этого применяется указатель на структуру Си.
Указатель - это переменная, которая не содержит значения, а указывает на ту переменную, которая имеет какое-то значение. Соответственно, указатель содержит адрес этой переменной, на которую ссылается. Например, ptr = &var1 означает, что переменной со знаком амперсанда присвоен только адрес на переменную, но не само значение. Теперь все значения var1 доступны через переменную-указатель ptr.
Операция * отсылает к содержимому ячейки, на которую указывает переменная после этого символа. Например, *ptr говорит о том, что здесь содержатся значения, взятые из ячейки с адресом к ptr.
Чтобы выделить память для динамических переменных, используют операцию new.
У нас есть
Выделяем участок памяти, заносим туда некое значение MyStruct * point = new MyStruct;
Для удаления динамических переменных используем операцию delete. Чтобы освободить место, вводим delete p;
Доступ
Все элементы по умолчанию являются публичными, поэтому другие классы их могут использовать. Чтобы задать или изменить некоторые значения, сначала нужно обратиться к элементу и только потом произвести соответствующие действия.
Создаем myStruct с именем переменной b.
struct myStruct {
Обращаемся к fio:
и задаем произвольное значение. Например, b.fio = “Ivanov”.
Рассмотрим такой пример.
struct myStruct {
{ "Иванов", 456756 },
{ "Петров", 632345 }
В данном примере у нас есть массив структур со строками и числами. Чтобы вывести на экран фамилию Иванов, используем следующее:
cout << myStruct tel.fio;
Когда захотим получить значение 456756, выполняем cout << myStruct tel.num.
Структура и функции
Может использоваться, как аргумент функция в структуре в Си.
struct myStruct {
Имеем переменную value, строку text на 100 символов. Создаем переменную menu типа myStruct: myStruct menu. В следующем примере функция принимает указатель на структуру как аргумент, а в теле безымянной функции происходит инициализация этих переменных.
void item(myStruct menu)
sprintf(menu.text,"One item");
Заключение
Структура - это такой набор, наподобие массива, но при этом все элементы могут быть разного типа. Очень похожа на класс, но отличается тем, что свойства по умолчанию доступны для использования другими классами, то есть имеют спецификатор public.
Создается с помощью ключевого слова struct, а внутри фигурных скобок { } указываются свойства.
Объявление происходит на этапе создания или после.
Пока мы рассматривали одну сложную структуру (сложный тип) - массив; одним из основных свойств массива является однотипность его компонент. Многие информационно-логические задачи связаны с обработкой документов, содержащих в себе информация разного типа (числовую, символьную и т. д.) Примеры таких документов: платежные ведомости (фамилии и имена - символьная информация, денежные суммы - числовая), карточки больных в поликлинике, библиотечная информация. Для программирования алгоритмов обработки такой информации необходимо иметь сложный тип, объединяющий разнотипные компоненты. Таким типом является структура в Си (в Паскале запись).
Структурная переменная, или просто структура, состоит из нескольких переменных (называемых полями), возможно, разного типа.
Структура
|
тип "структура" (шаблон) |
переменная типа "структура " |
|
Описание шаблона : |
Описание структурной переменной |
|
typedef struct { Тип1 Список1ИменПолей; |
struct ИмяШаблона ИмяПеременной |
|
Тип2 Список2ИменПолей; | |
|
ТипN СписокNИменПолей; |
ключевое struct слово не нужно пpи |
|
} ИмяШаблона |
использовании typedef |
|
или struct ИмяШаблона | |
|
{ Тип1 Список1ИменПолей;¦ | |
|
Тип2 Список2ИменПолей; | |
|
ТипN СписокNИменПолей; | |
typedef struct {char author; char title;/*описание*/
int year; float price} BOOK; /*шаблона BOOK*/
/*или можно описать тот же самый шаблон так:
struct BOOK {char author; char title;
int year; float price} ;*/
struct BOOK b;/*описание структурной переменной b*/
Память, занимаемая структурой, равна сумме объемов памяти полей (если исключить из рассмотрения особенности, связанные с выравниванием). В любом случае для определения размера памяти структуры можно использовать операцию sizeof(). Шаблон ВООК, например, описывает структуру размером памяти 70.
Обращение к полю структурной переменной:
ИмяСтруктуры.ИмяПоля или АдресСтруктуры ->ИмяПоля
. (точка) и ->являются операциями, соответственно, прямого и косвенного выбора компоненты структурированной переменной.
Например,
struct BOOK a,*pnta=&a;...
a.author="Byron"; pnta->author="Byron"; /*эквивалентные операторы*/
Пример. Задача примера 2 п.3.1.4 в нижеприведенной программе выполнена с использованием структур (а не строк).
#include
#include
#include
{ /*структура сведений об игрушках*/
typedef struct {int nu;/*номер*/
char name;/*наименование*/
int minage,maxage;/*мин. и макс. возраст ребенка*/
double rub /*стоимость*/;}TOYS;
TOYS toy;/*переменная типа записьTOYS */
double max; /*максимальная стоимость*/
char namemax;/*название самого дорогого конструктора*/
int n /*число игрушек*/,i/*номер игрушки*/;
puts("Введите число наименований игpушек");
for (i=0;
i /*в
цикле ввод сведений об игрушках и
проверка условий*/ fflush(stdin); /*очистка буфера
устройства ввода послеscanf
*/ printf("
Введите сведения об игpушке с номеpом
%2d\n",toy.nu); puts("наименование"); puts("мин. и макс. возpаст и стоимость"); scanf("%d%d%lf",&toy.minage,&toy.maxage,&toy.rub); if
((strstr(toy.name,"констpуктоp")!=NULL || strstr(toy.name,"Констpуктоp")!=NULL) && (toy.maxage <= 7) && (toy.rub>max)) strcpy(namemax,toy.name); puts(" Констpуктоpов для детей до семи
лет нет"); {
printf("Cамый доpогой констpуктоp для
детей до семи лет\n"); printf(" %s стоит %8.0f pублей\n",namemax,max); В Си существует еще один сложный тип,
описание которого формально похоже на
структуру. Это тип (и переменная)
объединение
. Объединение - это переменная, содержащая
поля разного типа, помещаемые в одно и
то же место памяти. По существу объединение
дает способ различной интерпретация
содержимого памяти. Описание шаблона
(типа) объединения и переменной этого
типа выполняется также, как для структуры,
только вместо ключевого слова struct
используетсяunion
. Размер памяти,
занимаемой объединением, равен
максимальному из размеров полей. Структуры Как вам должно быть уже известно, классы относятся к ссылочным типам данных.
Это означает, что объекты конкретного класса доступны по ссылке, в отличие от значений простых типов, доступных непосредственно. Но иногда прямой доступ к объектам
как к значениям простых типов оказывается полезно иметь, например, ради повышения эффективности программы. Ведь каждый доступ к объектам (даже самым мелким)
по ссылке связан с дополнительными издержками на расход вычислительных ресурсов
и оперативной памяти. Для разрешения подобных затруднений в C# предусмотрена структура
, которая подобна классу, но относится к типу значения, а не к ссылочному
типу данных. Т.е. структуры отличаются от классов тем, как они сохраняются в памяти и как к ним
осуществляется доступ (классы - это ссылочные типы, размещаемые в куче, структуры - типы значений, размещаемые в стеке), а также некоторыми свойствами (например, структуры не поддерживают наследование). Из соображений производительности вы будете
использовать структуры для небольших типов данных. Однако в отношении синтаксиса
структуры очень похожи на классы. Главное отличие состоит в том, что при их объявлении используется ключевое слово struct
вместо class. Ниже приведена общая форма объявления структуры: struct имя: интерфейсы {
// объявления членов
}
где имя обозначает конкретное имя структуры. Как и у классов, у каждой структуры имеются свои члены: методы, поля, индексаторы, свойства, операторные методы и события. В структурах допускается также определять конструкторы, но не деструкторы. В то же время для структуры нельзя определить конструктор, используемый по умолчанию (т.е. конструктор без параметров). Дело в том, что конструктор, вызываемый по умолчанию, определяется для всех структур автоматически и не подлежит изменению. Такой конструктор инициализирует поля структуры значениями, задаваемыми по умолчанию.
А поскольку структуры не поддерживают наследование, то их члены нельзя указывать как abstract, virtual или protected. Объект структуры может быть создан с помощью оператора new
таким же образом, как и объект класса, но в этом нет особой необходимости. Ведь когда используется
оператор new, то вызывается конструктор, используемый по умолчанию. А когда этот оператор не используется, объект по-прежнему создается, хотя и не инициализируется.
В этом случае инициализацию любых членов структуры придется выполнить вручную. Давайте рассмотрим пример использования структур: Using System;
namespace ConsoleApplication1
{
// Создадим структуру
struct UserInfo
{
public string Name;
public byte Age;
public UserInfo(string Name, byte Age)
{
this.Name = Name;
this.Age = Age;
}
public void WriteUserInfo()
{
Console.WriteLine("Имя: {0}, возраст: {1}",Name,Age);
}
}
class Program
{
static void Main()
{
UserInfo user1 = new UserInfo("Alexandr", 26);
Console.Write("user1: ");
user1.WriteUserInfo();
UserInfo user2 = new UserInfo("Elena",22);
Console.Write("user2: ");
user2.WriteUserInfo();
// Показать главное отличие структур от классов
user1 = user2;
user2.Name = "Natalya";
user2.Age = 25;
Console.Write("\nuser1: ");
user1.WriteUserInfo();
Console.Write("user2: ");
user2.WriteUserInfo();
Console.ReadLine();
}
}
} Обратите внимание, когда одна структура присваивается другой, создается копия ее объекта. В этом заключается одно из главных отличий структуры от класса. Когда ссылка на один класс присваивается ссылке на другой класс, в итоге ссылка
в левой части оператора присваивания указывает на тот же самый объект, что и ссылка в правой его части. А когда переменная одной структуры присваивается переменной
другой структуры, создается копия объекта структуры из правой части оператора присваивания. Поэтому, если бы в предыдущем примере использовался класс UserInfo вместо структуры, получился бы следующий результат: В связи с изложенным выше возникает резонный вопрос: зачем в C# включена
структура, если она обладает более скромными возможностями, чем класс? Ответ на этот вопрос заключается в повышении эффективности и производительности программ. Структуры относятся к типам значений, и поэтому ими можно оперировать
непосредственно, а не по ссылке. Следовательно, для работы со структурой вообще не
требуется переменная ссылочного типа, а это означает в ряде случаев существенную
экономию оперативной памяти. Последнее обновление: 02.10.2018 Наряду с классами структуры представляют еще один способ создания обственных типов данных в C#. Более того многие примитивные типы, например,
int, double и т.д., по сути являются структурами. Например, определим структуру, которая представляет человека: Struct User
{
public string name;
public int age;
public void DisplayInfo()
{
Console.WriteLine($"Name: {name} Age: {age}");
}
}
Как и классы, структуры могут хранить состояние в виде переменных и определять поведение в виде методов. Так, в данном случае
определены две переменные - name и age для хранения соответственно имени и возраста человека и метод DisplayInfo для вывода информации о человеке. Используем эту структуру в программе: Using System;
namespace HelloApp
{
struct User
{
public string name;
public int age;
public void DisplayInfo()
{
Console.WriteLine($"Name: {name} Age: {age}");
}
}
class Program
{
static void Main(string args)
{
User tom;
tom.name = "Tom";
tom.age = 34;
tom.DisplayInfo();
Console.ReadKey();
}
}
}
В данном случае создается объект tom. У него устанавливаются значения глобальных переменных, и затем выводится
информация о нем. Как и класс, структура может определять констукторы. Но в отличие от класса нам не обязательно вызывать конструктор для создания объекта структуры: User tom;
Однако если мы таким образом создаем объект структуры, то обязательно надо проинициализировать все поля (глобальные переменные) структуры перед получением
их значений или перед вызовом методов структуры. То есть, например, в следующем случае мы получим ошибку, так как обращение к полям и методам происходит
до присвоения им начальных значений: User tom;
int x = tom.age; // Ошибка
tom.DisplayInfo(); // Ошибка
Также мы можем использовать для создания структуры конструктор по умолчанию, при вызове которого полям структуры будет
присвоено значение по умолчанию (например, для числовых типов это число 0): User tom = new User();
tom.DisplayInfo(); // Name: Age: 0
Также мы можем определить свои конструкторы. Например, изменим структуру User: Using System;
using System.Reflection;
namespace HelloApp
{
struct User
{
public string name;
public int age;
public User(string name, int age)
{
this.name = name;
this.age = age;
}
public void DisplayInfo()
{
Console.WriteLine($"Name: {name} Age: {age}");
}
}
class Program
{
static void Main(string args)
{
User tom = new User("Tom", 34);
tom.DisplayInfo();
User bob = new User();
bob.DisplayInfo();
Console.ReadKey();
}
}
}
Важно учитывать, что если мы определяем конструктор в структуре, то он должен инициализировать все поля структуры, как в данном случае устанавливаются
значения для переменных name и age. Также, как и для класса, можно использовать инициализатор для создания структуры: User person = new User { name = "Sam", age = 31 };
Но в отличие от класса нельзя инициализировать поля структуры напрямую при их объявлении, например, следующим образом: Struct User
{
public string name = "Sam"; // ! Ошибка
public int age = 23; // ! Ошибка
public void DisplayInfo()
{
Console.WriteLine($"Name: {name} Age: {age}");
}
}
Структура — это агрегатный тип данных, так как может содержать в себе разнотипные элементы. Синтаксис объявления структуры в С++ отличается от C. Хотя версия C остается правильной для C++. Получается, что в С++ можно двумя стилями объявления структур пользоваться, а в языке C — только одной. Смотрим синтаксис объявления структуры в языке С++: Struct Name
{
type atrib;
// остальные элементы структуры
} structVar1, structVar2, ...;
Объявление структуры всегда должно начинаться с ключевого слова struct . Необязательно, чтобы структура имела имя, но тогда такая структура обязательно должна иметь структурные переменные, объявленные между закрывающей фигурной скобкой и точкой с запятой, строка 5. Обязательно в объявлении структуры должны присутствовать фигурные скобочки, они обрамляют тело структуры, в котором объявляются её атрибуты (элементы), строка 3. Структурные переменные, при объявлении структуры, указывать необязательно, строка 5. Так как структура это тип данных, то, для того, чтобы использовать этот тип данных, необходимо объявить структурную переменную, а вместо типа данных указать имя структуры. Синтаксис объявления структуры в языке Си: Typedef struct name
{
type atrib1;
type atrib2;
// остальные элементы структуры...
} newStructName structVar;
Синтаксис объявления структуры в языке Си предполагает два варианта. Первый, опустить ключевое слово
typedef , при этом имя
newStructName тоже не используется, и имя структуры, тогда обязательно необходимо при объявлении структуры использовать структурные переменные —
structVar , строка 6. Смотрим пример:
Struct name structVar;
Или вы можете воспользоваться typedef , для объявления псевдонима структуры newStructName , псевдоним: NewStructName structVar;
В любом случае, если вы хотите, объявить указатель на структуру внутри структуры, вы должны использовать первый синтаксис: Struct name *struct_instance; // указатель на структуру
Синтаксис объявления указателя на структуру в Си неоднозначен. В Си, если вы не используете typedef при определении структуры, то, в обязательном порядке необходимо использовать структурные переменные, между закрывающейся фигурной скобочкой и точкой с запятой. StructName *structVar; // указатель на структуру structName
NewStructName *structVar; // newStructName должно быть объявлено с typedef
или так, тоже для СИ: Struct name *structVar;
Доступ к элементам структуры так же прост, как использование символа «точка». Предположим. что у нас есть структурная переменная с именем car и у нее есть элемент с именем speed , к которому, мы сейчас получим доступ: Car.speed;
Примечание: такой способ доступа к элементам структуры работает только в том случае, когда структура не является указателем на структуру. Чтобы получить доступ к элементам структуры, через указатель на структуру, вместо оператора «точка», используйте оператор стрелка -> : CarPtr->speed;
P.S.: Всем владельцам Android-смартфонов представляю хорошую подборку программ GPS навигаторов для android . В списке представлено около 20 программных продуктов, вы можете любой скачать и установить на свой девайс. Все программы абсолютно бесплатные.
Назначение структур
Конструкторы структуры
Объявление указателя на структуру
В C++, этого не требуется. Чтобы объявить указатель на структуру, в С++ вы просто перед именем структурной переменной ставите символ указателя — * .Доступ к элементам структуры
Доступ к элементам указателя на структуру
