Структуры в C++
В этой статье вы узнаете о структурах в программировании на C++: что это такое, как определить и использовать в своей программе.
Структура в C++ – это совокупность переменных разных типов данных под одним именем.
Например: вы хотите сохранить некоторую информацию о человеке: его или ее имя, гражданство и зарплату. Вы можете легко создать различные имена переменных, чтобы хранить эту информацию отдельно.
Однако в будущем вы захотите хранить информацию о нескольких людях. Теперь вам нужно создать разные переменные для каждой информации для каждого человека: name1, citNo1, salary1, name2, citNo2, salary2.
Вы можете легко представить себе, насколько большим и беспорядочным будет выглядеть код. Кроме того, поскольку не существует связи между переменными (информацией), это будет непростой задачей.
Лучшим подходом будет иметь коллекцию всей связанной информации под одним именем Person и использовать ее для каждого человека. Теперь код выглядит намного чище, удобочитаемым и эффективным.
Язык Си для начинающих / #7 — Структуры данных
Этот набор всей связанной информации под одним именем Person представляет собой структуру.
Как объявить структуру в программировании C++?
Ключевое слово struct определяет тип структуры в С++, за которым следует идентификатор (имя структуры).
Затем внутри фигурных скобок вы можете объявить один или несколько членов (объявить переменные внутри фигурных скобок) этой структуры. Например:
struct Person < char name[50]; int age; float salary; >;
Здесь определяется структурное лицо, состоящее из трех членов: имя , возраст и зарплата .
Операторы в C++
При создании структуры, память не выделяется.
Определение структуры – это всего лишь план для создания переменных. Вы можете представить это как тип данных, когда вы определяете целое число, как показано ниже:
int foo;
Int указывает, что переменная foo может содержать только целочисленный элемент. Точно так же определение структуры указывает какое свойство имеет структурная переменная при ее определении.
Примечание: не забудьте заканчивать объявление точкой с запятой (;).
Как определить структурную переменную?
Как только вы объявите структурное лицо (Person), как указано выше. Вы можете определить структурную переменную как:
Person bill;
Здесь определяется структурная переменная bill, которая имеет структуру типа Person.
Когда структурная переменная определена, компилятор выделяет необходимую память.
Учитывая, что у вас 32-битная или 64-битная система, память типа float составляет 4 байта, память int – 4 байта, а память char – 1 байт.
Следовательно, для структурной переменной bill выделено 58 байт памяти.
Как получить доступ к членам структуры?
Доступ к членам структурной переменной осуществляется с помощью оператора точки (.).
Предположим, вы хотите получить доступ к возрасту (age) структурной переменной bill и присвоить ей значение 50. Вы можете выполнить эту задачу, используя следующий код:
Структуры в C++ | struct C++. Разница между структурой и классом. Изучение С++ для начинающих.#129
bill.age = 50;
Пример
Программа си++ для присвоения данных членам структурной переменной и их отображения.
#include using namespace std; struct Person < char name[50]; int age; float salary; >; int main() < Person p1; cout > p1.age; cout > p1.salary; cout
Enter Full name: Magdalena Dankova Enter age: 27 Enter salary: 1024.4 Displaying Information. Name: Magdalena Dankova Age: 27 Salary: 1024.4
Здесь объявляется структура Person , состоящая из трех членов: имя (Name), возраст (Age) и зарплата (Salary).
Оператор switch в C++
Внутри функции main() определяется структурная переменная p1 . Затем пользователя просят ввести информацию, после чего отображаются данные, введенные пользователем.
- Цикл for в C++
- Преобразование типов в C++
- Оператор if … else в C++
Источник: calmsen.ru
Общая структура программы C#
Программа на языке C# состоит из одного или нескольких файлов. Каждый файл может содержать или не содержать пространства имен. Пространство имен может содержать типы, такие как классы, структуры, интерфейсы, перечисления и делегаты или другие пространства имен. Ниже приведен пример структуры программы на C#, содержащей все эти элементы.
// A skeleton of a C# program using System; // Your program starts here: Console.WriteLine(«Hello world!»); namespace YourNamespace < class YourClass < >struct YourStruct < >interface IYourInterface < >delegate int YourDelegate(); enum YourEnum < >namespace YourNestedNamespace < struct YourStruct < >> >
В предыдущем примере для точки входа программы используются инструкции верхнего уровня. Эта функция была добавлена в C# 9. До версии C# 9 точка входа была статическим методом с именем Main , как показано в следующем примере:
// A skeleton of a C# program using System; namespace YourNamespace < class YourClass < >struct YourStruct < >interface IYourInterface < >delegate int YourDelegate(); enum YourEnum < >namespace YourNestedNamespace < struct YourStruct < >> class Program < static void Main(string[] args) < //Your program starts here. Console.WriteLine(«Hello world!»); >> >
Связанные разделы
Сведения об этих элементах программы см. в разделе о типах в руководстве по основам:
Спецификация языка C#
Дополнительные сведения см. в разделе Основные понятия в Спецификации языка C#. Спецификация языка является предписывающим источником информации о синтаксисе и использовании языка C#.
Источник: learn.microsoft.com
Структура c что это за программа
Ранее для определения классов мы использовали ключевое слово class . Однако C++ предоставляет еще один способ для определения пользовательских типов, который заключается в использовании структур. Данный способ был унаследован языком С++ еще от языка Си.
Структура в языке C++ представляет собой производный тип данных, который представляет какую-то определенную сущность, также как и класс. Нередко структуры применителько к С++ также называют классами. И в реальности различия между ними не такие большие.
Для определения структуры применяется ключевое слово struct , а сам формат определения выглядит следующим образом:
struct имя_структуры < компоненты_структуры >;
Имя_структуры представляет произвольный идентификатор, к которому применяются те же правила, что и при наименовании переменных.
После имени структуры в фигурных скобках помещаются Компоненты_структуры , которые представляют набор описаний объектов и функций, которые составляют структуру.
Например, определим простейшую структуру:
#include #include struct person < int age; std::string name; >; int main()
Здесь определена структура person , которая имеет два элемента: age (представляет тип int) и name (представляет тип string).
После определения структуры мы можем ее использовать. Для начала мы можем определить объект структуры — по сути обычную переменную, которая будет представлять выше созданный тип. Также после создания переменной структуры можно обращаться к ее элементам — получать их значения или, наоборот, присваивать им новые значения. Для обращения к элементам структуры используется операция «точка»:
имя_переменной_структуры.имя_элемента
По сути структура похожа на класс, то есть с помощью структур также можно определять сущности для использования в программе. В то же время все члены структуры, для которых не используется спецификатор доступа (public, private), по умолчанию являются открытыми (public). Тогда как в классе все его члены, для которых не указан спецификатор доступа, являются закрытыми (private).
Кроме того мы можем инициализировать структуру, присвоив ее переменным значения с помощью синтаксиса инициализации:
person tom = < 34, «Tom» >;
Инициализация структур аналогична инициализации массивов: в фигурных скобках передаются значения для элементов структуры по порядку. Так как в структуре person первым определено свойство, которое представляет тип int — число, то в фигурных скобках вначале идет число. И так далее для всех элементов структуры по порядку.
При этом любой класс мы можем представить в виде структуры и наоборот. Возьмем, к примеру, следующий класс:
class Person < public: Person(std::string n, int a) < name = n; age = a; >void move() < std::cout void setAge(int a) < if (a >0 a < 100) age = a; >std::string getName() < return name; >int getAge() < return age; >private: std::string name; int age; >;
Данный класс определяет сущность человека и содержит ряд приватных и публичных переменных и функции. Вместо класса для определения той же сущности мы могли бы использовать структуру:
#include #include struct user < public: user(std::string n, int a) < name = n; age = a; >void move() < std::cout void setAge(int a) < if (a >0 a < 100) age = a; >std::string getName() < return name; >int getAge() < return age; >private: std::string name; int age; >; int main()
И в плане конечного результата программы мы не увидели бы никакой разницы.
Когда использовать структуры? Как правило, структуры используются для описания таких данных, которые имеют только набор публичных атрибутов — открытых переменных. Например, как та же структура person, которая была определена в начале статьи. Иногда подобные сущности еще называют аггрегатными классами (aggregate classes).
Источник: metanit.com
9.4 – Структуры
В программировании есть много случаев, когда нам для представления объекта необходимо более одной переменной. Например, чтобы представить себя, вы можете сохранить свое имя, дату рождения, рост, вес или любое другое количество характеристик о себе. Сделать это можно так:
std::string myName<>; int myBirthYear<>; int myBirthMonth<>; int myBirthDay<>; int myHeightInches<>; int myWeightPounds<>;
Однако теперь у вас есть 6 независимых переменных, которые никак не сгруппированы. Если вы хотите передать информацию о себе в функцию, вам придется передавать каждую переменную отдельно. Кроме того, если вы хотите сохранить информацию о ком-то еще, то для каждого дополнительного человека вам нужно будет объявить еще 6 переменных! Как видите, это может быстро выйти из-под контроля.
К счастью, C++ позволяет нам создавать собственные пользовательские агрегированные типы данных. Агрегированный тип данных – это тип данных, который группирует вместе несколько отдельных переменных. Одним из простейших агрегированных типов данных является структура. Структура (сокращенно struct ) позволяет нам группировать переменные смешанных типов данных вместе в единое целое.
Объявление и определение структур
Поскольку структуры определяются пользователем, мы сначала должны сообщить компилятору, как выглядит наша структура, прежде чем мы сможем начать ее использовать. Для этого мы объявляем нашу структуру с помощью ключевого слова struct . Вот пример объявления структуры:
struct Employee < int id<>; int age<>; double wage<>; >;
Это сообщает компилятору, что мы определяем структуру с именем Employee . Структура Employee содержит внутри 3 переменных: int с именем id , int с именем age и double с именем wage . Эти переменные, которые являются частью структуры, называются членами (или полями). Имейте в виду, что Employee – это просто объявление – даже несмотря на то, что мы сообщаем компилятору, что структура будет иметь переменные-члены, в это время память не выделяется. По соглашению имена структур начинаются с заглавной буквы, чтобы отличать их от имен переменных.
Предупреждение
Одна из самых простых ошибок C++ – это забыть о точке с запятой в конце объявления структуры. Это вызовет ошибку компилятора в следующей строке кода. Современные компиляторы, такие как Visual Studio 2010, укажут вам, что вы, возможно, забыли точку с запятой, но более старые или менее сложные компиляторы могут этого не делать, что может затруднить обнаружение реальной ошибки.
Чтобы использовать структуру Employee , мы просто объявляем переменную типа Employee :
Employee joe<>; // структура Employee пишется с заглавной буквы, а переменная joe — нет
Это определяет переменную типа Employee с именем joe . Как и в случае с обычными переменными, определение переменной типа структуры выделяет память для этой переменной.
Можно определить несколько переменных одного и того же типа структуры:
Employee joe<>; // создаем структуру Employee для Джо Employee frank<>; // создаем структуру Employee для Фрэнка
Доступ к членам структуры
Когда мы определяем переменную, такую как Employee joe , joe относится ко всей структуре (которая содержит переменные-члены). Чтобы получить доступ к отдельным членам, мы используем оператор выбора члена (который представляет собой точку). Вот пример использования оператора выбора члена для инициализации каждой переменной-члена:
Employee joe<>; // создаем структуру Employee для Джо joe.id = 14; // присваиваем значение члену id в структуре joe joe.age = 32; // присваиваем значение члену age в структуре joe joe.wage = 24.15; // присваиваем значение члену wage в структуре joe Employee frank<>; // создаем структуру Employee для Фрэнка frank.id = 15; // присваиваем значение члену id в структуреt frank frank.age = 28; // присваиваем значение члену age в структуре frank frank.wage = 18.27; // присваиваем значение члену wage в структуре frank
Как и обычные переменные, переменные-члены структуры не инициализируются и обычно содержат мусор. Мы должны инициализировать их вручную.
В приведенном выше примере очень легко определить, какие переменные-члены принадлежат Джо, а какие – Фрэнку. Это обеспечивает гораздо более высокий уровень организации, чем отдельные переменные. Более того, поскольку переменные-члены Джо и Фрэнка имеют одинаковые имена, это обеспечивает согласованность для нескольких переменных одного и того же типа структуры.
Переменные-члены структуры действуют как обычные переменные, поэтому с ними можно выполнять обычные операции:
int totalAge< joe.age + frank.age >; if (joe.wage > frank.wage) std::cout
Инициализация структур
Инициализация структур путем присвоения значений каждому члену поочередно может быть немного утомительной, поэтому C++ поддерживает более быстрый способ инициализации структур с использованием списка инициализаторов. Это позволяет вам во время объявления инициализировать некоторые или все члены структуры.
struct Employee < int id<>; int age<>; double wage<>; >; // joe.id = 1, joe.age = 32, joe.wage = 60000.0 Employee joe< 1, 32, 60000.0 >; // frank.id = 2, frank.age = 28, frank.wage = 0.0 (инициализация по умолчанию) Employee frank< 2, 28 >;
Если список инициализаторов не содержит инициализатора для некоторых элементов, эти элементы инициализируются значением по умолчанию (которое обычно соответствует нулевому состоянию для этого типа). В приведенном выше примере мы видим, что frank.wage по умолчанию инициализируется значением 0.0 , поскольку мы не указали для него явное значение инициализации.
Инициализация нестатического члена
Нестатическим (обычным) членам структуры можно дать значение по умолчанию:
struct Rectangle < double length< 1.0 >; double width< 1.0 >; >; int main() < Rectangle x<>; // length = 1.0, width = 1.0 x.length = 2.0; // вы можете присваивать другие значения, как обычно return 0; >
Если представлены и инициализатор нестатического члена, и инициализация списком, то инициализация списком имеет больший приоритет.
struct Rectangle < double length< 1.0 >; double width< 1.0 >; >; int main() < Rectangle x< 2.0, 2.0 >; return 0; >
В приведенном выше примере Rectangle x будет инициализирован с длиной и шириной 2,0.
О том, что такое статические члены, мы поговорим в следующей главе. А пока не беспокойтесь о них.
Присваивание структурам
Если мы хотим присвоить значения членам структур, мы можем сделать это по отдельности:
struct Employee < int id<>; int age<>; double wage<>; >; Employee joe<>; joe.id = 1; joe.age = 32; joe.wage = 60000.0;
Если вы хотите присвоить новые значения всем членам, это будет утомительно, особенно для структур с большим количеством членов. Присваивать значения членам структур вы можете так же, используя список инициализаторов:
struct Employee < int id<>; int age<>; double wage<>; >; Employee joe<>; joe = < 1, 32, 60000.0 >; // То же, что и joe = Employee< 1, 32, 60000.0 >; // Также возможно скопировать все члены из одной переменной в другую Employee emma< joe >;
Структуры и функции
Большим преимуществом использования структур вместо отдельных переменных является то, что мы можем передать всю структуру в функцию, которая должна работать с ее членами:
#include struct Employee < int id<>; int age<>; double wage<>; >; void printInformation(Employee employee) < std::cout int main() < Employee joe < 14, 32, 24.15 >; Employee frank < 15, 28, 18.27 >; // Распечатать информацию о Джо printInformation(joe); std::cout
В приведенном выше примере мы передаем всю структуру Employee в printInformation() (по значению, что означает, что аргумент копируется в параметр). Это избавляет нас от необходимости передавать каждую переменную отдельно. Более того, если мы когда-нибудь решим добавить новые члены в нашу структуру Employee , нам не придется изменять объявление или вызов функции!
Приведенная выше программа выводит:
ID: 14 Age: 32 Wage: 24.15 ID: 15 Age: 28 Wage: 18.27
Функция также может возвращать структуру, что является одним из немногих способов вернуть функцией несколько переменных.
#include struct Point3d < double x<>; double y<>; double z<>; >; Point3d getZeroPoint() < // Мы можем создать переменную и вернуть ее. Point3d temp < 0.0, 0.0, 0.0 >; return temp; > Point3d getZeroPoint2() < // Мы можем вернуться напрямую. Мы уже указали тип // при объявлении функции (Point3d), поэтому нам не нужно // делать это здесь снова. return < 0.0, 0.0, 0.0 >; > Point3d getZeroPoint3() < // Мы можем использовать пустые фигурные скобки для // инициализации нулями всех членов ‘Point3d’. return <>; > int main() < Point3d zero< getZeroPoint() >; if (zero.x == 0.0 zero.y == 0.0 zero.z == 0.0) std::cout
Эта программа печатает:
The point is zero
Вложенные структуры
Структуры могут содержать другие структуры. Например:
struct Employee < int id<>; int age<>; double wage<>; >; struct Company < Employee CEO<>; // Employee (сотрудник) — структура внутри структуры Company (компания) int numberOfEmployees<>; >; Company myCompany;
В этом случае, если мы хотим узнать, какова зарплата генерального директора (CEO), мы просто дважды используем оператор выбора члена: myCompany.CEO.wage;
Это выбирает член CEO из myCompany , а затем выбирает член wage из CEO .
Для вложенных структур вы можете использовать вложенные списки инициализаторов:
struct Employee < int id; int age; double wage; >; struct Company < Employee CEO; // Employee — это структура внутри структуры struct int numberOfEmployees; >; Company myCompany, 5 >;
Размер структуры и выравнивание структуры данных
Обычно размер структуры – это сумма размеров всех ее членов, но не всегда!
Рассмотрим структуру Employee , но с целочисленными типами фиксированного размера и размером id , равным половине размера age . На многих платформах размер double составляет 8 байтов, поэтому мы ожидаем, что Employee будет 2 + 4 + 8 = 14 байтов. Чтобы узнать точный размер Employee , мы можем использовать оператор sizeof :
#include #include struct Employee < // Целочисленные типы фиксированной ширины мы используем для примера. // Избегайте их в реальном коде. std::int16_t id<>; std::int32_t age<>; double wage<>; >; int main()
На машине автора эта программа печатает:
The size of a double is 8 The size of Employee is 16
Оказывается, мы можем сказать только то, что размер структуры будет не меньше размера всех содержащихся в ней переменных. Но может быть и больше! По соображениям производительности компилятор иногда добавляет разрывы в структуры (это называется заполнением).
В приведенной выше структуре Employee компилятор невидимо добавляет 2 байта заполнения после члена id , делая размер структуры равным 16 байтов вместо 14. Причина, по которой он это делает, выходит за рамки этого руководства, но читатели, которые хотят узнать подробнее о выравнивании структур, данных могут прочитать об этом в Википедии. Это необязательный материал и не требуется для понимания структур или C++!
Доступ к структурам в нескольких файлах
Поскольку объявления структуры не занимают никакой памяти, если вы хотите использовать объявление структуры в нескольких файлах (чтобы можно было создавать экземпляры переменных этого типа структуры в нескольких файлах), поместите объявление структуры в заголовочный файл и включите с помощью #include этот файл везде, где вам это нужно.
Переменные структур подчиняются тем же правилам, что и обычные переменные. Следовательно, чтобы сделать переменную структуры доступной для нескольких файлов, вы можете использовать ключевое слово extern в объявлении в заголовке и определить переменную в исходном файле.
Заключительные примечания по структурам
Структуры в C++ очень важны, поскольку понимание структур – первый важный шаг к объектно-ориентированному программированию! Позже в этой серии обучающих статей вы узнаете о другом агрегированном типе данных, называемом классом, который построен на основе структур. Хорошее понимание структур поможет значительно упростить переход к классам.
Структуры, представленные в этом уроке, иногда называют простыми старыми структурами данных (или структурами POD, plain old data struct), поскольку все члены являются членами данных (переменными). В будущем (когда мы будем обсуждать классы) мы поговорим о других типах членов.
Небольшой тест
Вопрос 1
У вас есть веб-сайт, и вы пытаетесь отслеживать, сколько денег вы зарабатываете в день на рекламе. Объявите структуру advertising (реклама), которая отслеживает, сколько объявлений вы показали читателям, на какой процент объявлений нажимали пользователи, и сколько вы в среднем зарабатывали на каждом клике по объявлению. Значения для каждого из этих полей заполните данными, вводимыми пользователем. Передайте структуру advertising функции, которая печатает каждое из значений, а затем вычисляет, сколько вы заработали за этот день (умножьте все 3 поля вместе).
#include // Сначала нам нужно определить нашу структуру Advertising struct Advertising < int adsShown<>; double clickThroughRatePercentage<>; double averageEarningsPerClick<>; >; Advertising getAdvertising() < Advertising temp<>; std::cout > temp.adsShown; std::cout > temp.clickThroughRatePercentage; std::cout > temp.averageEarningsPerClick; return temp; > void printAdvertising(Advertising ad) < std::cout int main() < // Объявление переменной структуры Advertising Advertising ad< getAdvertising() >; printAdvertising(ad); return 0; >
Вопрос 2
Создайте структуру для хранения дроби. Структура должна иметь целочисленный числитель и целочисленный знаменатель. Объявите 2 переменные дробей и заполните их данными, введенными пользователем. Напишите функцию под названием multiply , которая берет обе дроби, умножает их вместе и возвращает результат в виде числа с плавающей запятой.
Вам не нужно сокращать дробь до наименьшего значения. Выведите результат умножения двух переменных дробей.
#include struct Fraction < int numerator<>; int denominator<>; >; Fraction getFraction() < Fraction temp<>; std::cout > temp.numerator; std::cout > temp.denominator; std::cout double multiply(Fraction f1, Fraction f2) < // Не забудьте приведение static_cast, иначе компилятор будет выполнять целочисленное деление! return (static_cast(f1.numerator * f2.numerator) / (f1.denominator * f2.denominator)); > int main() < // Создаем нашу первую дробь const Fraction f1< getFraction() >; const Fraction f2< getFraction() >; const double result< multiply(f1, f2) >; std::cout
Источник: radioprog.ru
Урок 22. Структуры C#
На двадцать втором и заключительном уроке учебника по объектно-ориентированному программированию на языке C# рассматривается использование структур. Структуры предоставляют аналогичные функциональные возможности классам, но когда экземпляры результирующих переменных являются типами значений, а не ссылочными типами.
Что такое структура?
Структура подобна по функциональности и синтаксису классу. Структуры — это составные типы данных, содержащие свойства, методы и другие элементы, которые могут быть созданы как переменные. Ключевое различие между структурами и классами заключается в том, что, хотя классы используются для создания переменных ссылочного типа, экземпляры структур всегда являются типами значений.
Члены структуры
- Конструкторы. В структуре можно создать несколько конструкторов. Однако конструктор по умолчанию, не содержащий параметров, не может быть определен. Конструктор по умолчанию является неявным для всех структур и не может быть переопределен. Он просто устанавливает все поля в структуре к их значениям по умолчанию.
- Константы. В структуре могут быть определены как константы, так и перечисления.
- Поля. Поля — это переменные, определенные в блоке кода структуры, которые доступны всем ее членам. Поля могут быть объявлены как публичные или частные, хотя публичные поля не поощряются, поскольку они ограничивают инкапсуляцию. В отличие от полей внутри классов, структурные поля не могут быть инициализированы в их коде объявления. Если требуется инициализация, это должно быть выполнено в конструкторе.
- Индексаторы. Структура может включать индексатор для обеспечения функциональности, подобной массиву.
- Операторы. Чтобы разрешить структурам вести себя как собственные типы данных, можно перегружать их операторы. Это позволяет операторам, таким как + и -, использоваться с экземплярами структуры.
- События. Структуры могут включать объявления о событиях, позволяющие структуре направлять уведомления о принятых мерах или достигнутых состояниях. При использовании событий внутри структур необходимо соблюдать осторожность. Поскольку структуры являются типами значений, можно подписаться на событие в пределах копии экземпляра структуры, которая позже выходит за пределы области действия. Это может привести к тому, что вызванное событие неожиданно не будет захвачено.
В дополнение к вышеуказанным ограничениям структур по сравнению с классами существуют некоторые дополнительные ограничения. Наиболее важным из них является то, что структуры не поддерживают наследование. Одна структура не может наследовать функциональность от другой структуры или класса; также структуры не могут использоваться в качестве основы для наследования. Поэтому члены не могут быть объявлены защищенными, абстрактными или виртуальными, поскольку это было бы бессмысленно. Единственным исключением из этого правила является то, что структуры действительно наследуют от объекта, как и все другие типы.
Отсутствие наследования несколько компенсируется тем, что структуры могут реализовать один или несколько интерфейсов. Это допускает определенную степень полиморфизма.
Еще одним ограничением структур является то, что они не могут включать деструктор. Деструктор не нужен, так как компилятор автоматически уничтожает экземпляры структур.
Когда использовать структуры
Вы можете спросить, почему вы будете использовать структуры, учитывая, что они являются более ограниченными, чем классы. Ответ заключается в том, что в некоторых случаях структуры могут быть более эффективными, чем классы, и могут привести к повышению производительности и использованию ресурсов. Это, как правило, ситуации, когда структуры просты, содержат мало свойств и используются в большом количестве.
Облегченный класс находится в неблагоприятном положении по сравнению с аналогичной структурой в двух отношениях. Во-первых, больше памяти используется одним экземпляром класса, потому что и данные, и ссылка на эти данные должны быть сохранены. Структурная переменная не нуждается в хранении дополнительной справочной информации, поэтому имеет меньший объем памяти «следа».
Во-вторых, весь доступ к свойствам структуры может быть сделан непосредственно. С объектом, основанным на классе, доступ является косвенным, используя сначала ссылку. Каждый из этих недостатков является незначительным для использования отдельных переменных. Однако при выполнении многих тысяч или миллионов операций совокупный эффект может быть значительным.
Повышение производительности и меньшее использование ресурсов структур ограничено теми, которые являются легкими. По мере роста сложности структуры относительные улучшения по сравнению с использованием класса сводятся к минимуму. Когда структура содержит много свойств или несколько конструкторов, событий, индексаторов или операторов, часто более целесообразно использовать класс.
Создание структуры
Чтобы продемонстрировать использование структур, мы создадим тот, который представляет собой вектор. Эта простая структура будет включать свойства X и Y и метод, который вычисляет длину вектора. Для начала создайте новое консольное приложение с именем «CSharpStructures «и добавьте в проект новый файл класса с именем» Vector».
Синтаксис для объявления структуры аналогичен синтаксису класса. Однако вместо использования ключевого слова class имя структуры имеет префикс «struct». Таким образом, общий синтаксис для простой структуры является:
struct структура-имя <>
Как описано выше, структуры могут реализовывать один или несколько интерфейсов. При необходимости имена интерфейсов добавляются к объявлению в виде списка, разделенного запятыми. Имя первого интерфейса имеет префикс в виде двоеточия (:).
структура структуры-имя: interface-1, interface-2. интерфейс-x <>
В зависимости от предпочтительной среды разработки, созданный векторный кодовый файл может содержать определение класса. Если это так, удалите его. Добавьте новое определение структуры в файл кода следующим образом:
struct Vector
Добавление свойств
Новая структура требует свойств для хранения координат X и Y. Они будут содержать целочисленные значения. Синтаксис для создания свойства идентичен синтаксису для создания свойства класса. Однако, если связать свойство с частным полем, как показано ниже, поле не может быть инициализировано в его объявлении.
Чтобы создать эти два свойства, добавьте следующий код в блок кода структуры:
private int _x, _y; public int X < get < return _x; >set < _x = value; >> public int Y < get < return _y; >set < _y = value; >>
Добавление метода
Теперь мы можем добавить в структуру метод, который вычисляет длину вектора, используя теорему Пифагора и значения двух координат. Чтобы определить этот метод, добавьте следующий код:
public double CalculateLength()
Создание экземпляра структуры
Существует два способа, с помощью которых можно создать экземпляр структуры и создать переменную. Первый способ — использовать оператор «new» и создать переменную, используя тот же синтаксис, что и при создании объекта класса. Новое ключевое слово вызывает выполнение конструктора в соответствии с используемыми параметрами. В следующем примере новый вектор создается с помощью конструктора по умолчанию. Это означает, что при первом создании поля _x и _y присваиваются их значения по умолчанию равны нулю, пока не будут изменены.
Vector v = new Vector(); Console.WriteLine(«X: tY: «, v.X, v.Y); Console.WriteLine(«Length: «, v.CalculateLength()); v.X = 30; v.Y = 40; Console.WriteLine(«X: tY: «, v.X, v.Y); Console.WriteLine(«Length: «, v.CalculateLength()); /* X: 0 Y: 0 Length: 0 X: 30 Y: 40 Length: 50 */
Создание экземпляра структуры без оператора new
Переменная типа структуры может быть создана без использования ключевого слова new. В этом случае все поля в структуре остаются неназначенными до тех пор, пока не будут установлены их значения. Кроме того, компилятор видит всю переменную как неназначенную, если каждому полю не было присвоено значение. Если полям не присвоено значение, код компилироваться не будет.
Это несколько ограничительно, поскольку означает, что все поля в структуре должны быть общедоступными, ограничивая хорошие эффекты инкапсуляции. Однако для очень простых конструкций это можно считать приемлемым.
Чтобы показать этот второй метод создания экземпляра, структура должна быть обновлена, чтобы использовать открытые поля, а не свойства. Измените код следующим образом:
struct Vector < public int X, Y; public double CalculateLength() < return Math.Sqrt(X * X + Y * Y); >>
Теперь мы можем создать экземпляр векторной структуры без нового ключевого слова следующим образом:
Vector v; v.X = 30; v.Y = 40; Console.WriteLine(«X: tY: «, v.X, v.Y); Console.WriteLine(«Length: «, v.CalculateLength()); /* X: 30 Y: 40 Length: 50 */
Добавление конструктора
Последний тип элемента, который мы продемонстрируем на этом уроке, является конструктором. Как и в случае с классами, в структуру можно добавить несколько конструкторов, чтобы инициализировать ее различными способами. Выбор конструктора для выполнения при создании экземпляра класса зависит от сигнатуры, используемой с ключевым словом «new».
Чтобы показать использование нового конструктора, добавьте следующее объявление в блок кода структуры. Этот конструктор позволит установить две координаты при создании экземпляра:
public Vector(int x, int y)
Мы можем протестировать новый конструктор, используя следующий код:
Vector v = new Vector(30, 40); Console.WriteLine(«X: tY: «, v.X, v.Y); Console.WriteLine(«Length: «, v.CalculateLength()); /* X: 30 Y: 40 Length: 50 */
Примечание: в отличие от определений классов, добавление нового конструктора не удаляет доступность конструктора по умолчанию.
Структуры — это типы значений
Как было описано ранее, основное различие между классами и структурами заключается в том, что структуры являются типами значений. Теперь, когда у нас есть структура, это можно продемонстрировать. В следующем коде создается экземпляр вектора и создается его копия. Когда поля копии изменяются, это никак не влияет на исходную структуру.
Это отличается от использования классов и их объектов, так как каждая переменная будет ссылкой на одни и те же данные. Если бы данные в одном объекте должны были измениться, данные в другом объекте также были бы изменены.
Vector v1 = new Vector(30, 40); Vector v2 = v1; v2.X = 10; v2.Y = 15; Console.WriteLine(«X1: tY1: «, v1.X, v1.Y); Console.WriteLine(«X2: tY2: «, v2.X, v2.Y); /* Вывод X1: 30 Y1: 40 X2: 10 Y2: 15 */
Автор этого материала — я — Пахолков Юрий. Я оказываю услуги по написанию программ на языках Java, C++, C# (а также консультирую по ним) и созданию сайтов. Работаю с сайтами на CMS OpenCart, WordPress, ModX и самописными. Кроме этого, работаю напрямую с JavaScript, PHP, CSS, HTML — то есть могу доработать ваш сайт или помочь с веб-программированием. Пишите сюда.
статьи IT, си шарп, ООП
Источник: upread.ru