Тип, определенный как , class является ссылочным типом. Во время выполнения при объявлении переменной ссылочного типа переменная содержит значение null , пока вы явно не создадите экземпляр класса с помощью new оператора или не назначите ему объект совместимого типа, который может быть создан в другом месте, как показано в следующем примере:
//Declaring an object of type MyClass. MyClass mc = new MyClass(); //Declaring another object of the same type, assigning it the value of the first object. MyClass mc2 = mc;
При создании объекта выделяется достаточный объем памяти для этого объекта в управляемой куче, и переменная хранит только ссылку на расположение данного объекта.
Память, используемая объектом, освобождается с помощью функции автоматического управления памятью среды CLR, которая называется сборкой мусора. Дополнительные сведения о сборке мусора см. в разделе Автоматическое управление памятью и сборка мусора.
Объявление классов
Классы объявляются с помощью class ключевое слово за которым следует уникальный идентификатор, как показано в следующем примере:
Понятие класса и объекта в ООП
//[access modifier] — [class] — [identifier] public class Customer < // Fields, properties, methods and events go here. >
Дополнительный модификатор class доступа предшествует ключевое слово. Так как public используется в этом случае, любой пользователь может создавать экземпляры этого класса. За именем класса следует ключевое слово class . Имя класса должно быть допустимым именем идентификатора C#.
Оставшаяся часть определения — это тело класса, в котором задаются данные и поведение. Поля, свойства, методы и события в классе собирательно называются членами класса.
Создание объектов
Хотя они иногда используются взаимозаменяемо, класс и объект — это разные вещи. Класс определяет тип объекта, но сам по себе он не является объектом. Объект — это конкретная сущность, основанная на классе, которую иногда называют экземпляром класса.
Объекты можно создать с помощью new ключевое слово за которым следует имя класса, как показано ниже:
Customer object1 = new Customer();
При создании экземпляра класса ссылка на объект передается программисту. В предыдущем примере object1 представляет собой ссылку на объект, который основан на Customer . Эта ссылка ссылается на новый объект , но не содержит сами данные объекта. Фактически, можно создать ссылку на объект без создания собственно объекта:
Customer object2;
Не рекомендуется создавать ссылки на объекты, которые не ссылаются на объект, так как попытка получить доступ к объекту через такую ссылку завершается сбоем во время выполнения. Ссылку можно сделать для ссылки на объект, создав новый объект или назначив ему существующий объект, например:
Customer object3 = new Customer(); Customer object4 = object3;
В этом коде создаются две ссылки на объект, которые указывают на один и тот же объект. Таким образом, любые изменения объекта, выполненные посредством object3 , отражаются при последующем использовании object4 . Поскольку на объекты, основанные на классах, указывают ссылки, классы называют ссылочными типами.
Python с нуля. Урок 10 | Классы и объекты
Конструкторы и инициализация
В предыдущих разделах представлен синтаксис для объявления типа класса и создания экземпляра этого типа. При создании экземпляра типа необходимо убедиться, что его поля и свойства инициализированы полезными значениями. Существует несколько способов инициализации значений.
- Принятие значений по умолчанию
- Инициализаторы полей
- Параметры конструктора
- Инициализаторы объектов
Каждый тип .NET имеет значение по умолчанию. Как правило, это значение равно 0 для числовых типов и null для всех ссылочных типов. Вы можете использовать это значение по умолчанию, если это целесообразно в приложении.
Если значение по умолчанию .NET не является правильным, можно задать начальное значение с помощью инициализатора поля:
public class Container < // Initialize capacity field to a default value of 10: private int _capacity = 10; >
Вы можете потребовать, чтобы вызывающие стороны предоставляли начальное значение, определив конструктор , который отвечает за установку этого начального значения:
public class Container < private int _capacity; public Container(int capacity) =>_capacity = capacity; >
Начиная с C# 12, можно определить основной конструктор как часть объявления класса:
public class Container(int capacity)
Добавление параметров в имя класса определяет основной конструктор. Эти параметры доступны в теле класса, который включает его члены. Их можно использовать для инициализации полей или в любом другом месте, где они необходимы.
Вы также можете использовать модификатор required для свойства и разрешить вызывающим объектам использовать инициализатор объекта для задания начального значения свойства:
public class Person < public required string LastName < get; set; >public required string FirstName < get; set; >>
Добавление required ключевое слово требует, чтобы вызывающие объекты должны задавать эти свойства как часть new выражения:
var p1 = new Person(); // Error! Required properties not set var p2 = new Person() < FirstName = «Grace», LastName = «Hopper» >;
Наследование классов
Классы полностью поддерживают наследование, фундаментальный механизм объектно ориентированного программирования.
При создании класса можно наследовать от любого другого класса, который не определен как sealed . Другие классы могут наследовать от класса и переопределять виртуальные методы класса. Кроме того, можно реализовать один или несколько интерфейсов.
При наследовании создается производный класс, то есть класс объявляется с помощью базового класса, от которого он наследует данные и поведение. Базовый класс задается добавлением после имени производного класса двоеточия и имени базового класса, как показано далее:
public class Manager : Employee < // Employee fields, properties, methods and events are inherited // New Manager fields, properties, methods and events go here. >
Когда объявление класса включает базовый класс, оно наследует все члены базового класса, кроме конструкторов. Дополнительные сведения см. в разделе Наследование.
Класс в C# может напрямую наследовать только от одного базового класса. Однако поскольку базовый класс может сам наследовать от другого класса, класс может косвенно наследовать несколько базовых классов. Кроме того, класс может напрямую реализовать несколько интерфейсов. Дополнительные сведения см. в разделе Интерфейсы.
Класс можно объявить как abstract . Абстрактный класс содержит абстрактные методы, которые имеют определение сигнатуры, но не имеют реализации. Не удается создать экземпляр абстрактных классов. Они могут использоваться только через производные классы, реализующие абстрактные методы. В отличие от этого, запечатанный класс не позволяет другим классам наследоваться от него. Дополнительные сведения см. в статье Абстрактные и запечатанные классы и члены классов.
Определения классов можно разделить между различными исходными файлами. Дополнительные сведения см. в разделе Разделяемые классы и методы.
Спецификация языка C#
Дополнительные сведения см. в спецификации языка C#. Спецификация языка является предписывающим источником информации о синтаксисе и использовании языка C#.
Источник: learn.microsoft.com
Классы в языке C++
Класс в C++ — это пользовательский тип данных, позволяющий группировать в себе данные в виде переменных различных типов, а также функции-методы для работы с этими данными.
Объявление классов
Класс в языке C++ объявляется с помощью ключевого слова class.
class Person < int id; short age; public: std::string name; void setAge(short _age) < this->age = _age; > short getAge() < return age; >>;
Обращение к членам класса
Доступ к членам класса осуществляется через точку, если переменная класса — экземпляр класса (объект).
Person person; person.name = «Jane»; person.setAge(20); std::cout
Если переменная — указатель на класс, то доступ к членам класса осуществляется через «->».
Person *person = new Person(); person->name = «Jane»; person->setAge(20); std::cout name.c_str() << std::endl; std::cout getAge()
Спецификаторы доступа
В отличие от структур, в классе все члены по-умолчанию объявляются как закрытые. Для изменения типа объявления используются спецификаторы доступа private, public и protected:
- private — закрытые (приватные) члены класса. К ним можно обращаться только из методов этого класса.
- protected — защищённые члены класса. К ним можно обращаться из методов этого класса, а также наследников этого класса.
- public — открытые члены класса. К ним можно обращаться через экземпляр класса, так же как к членам структур.
class Person < int id; protected: std::string name; public: short age; >;
Спецификаторы доступа работают на уровне класса, а не на уровне объекта. Это означает, что если метод имеет доступ к закрытым членам класса, то он также может обращаться и к закрытым членам любого объекта этого класса.
class Person < std::string name; public: void copyFrom(Person this->name = p.name; > >;
Инициализация классов
При создании экземпляра класса его члены изначально создаются неинициализированными, с неопределенными значениями.
Если все члены класса объявлены как открытые, то класс можно инициализировать так же как и структуры — либо списком значений, либо через универсальную инициализацию.
class Person < public: int id; std::string name; >; // Инициализация каждого члена класса по-отдельности Person person1; person1.id = 1; person1.name = «Person #1 name»; // Инициализация списком значений Person person2 = < 2, «Person #2 name» >; // Универсальная инициализация Person person3 < 3, «Person #3 name» >;
Начиная со стандарта C++11 при объявлении класса для еге членов можно указать значения по-умолчанию.
class Person < int std::string name = «Default name»; >;
В остальных случаях инициализация производится только через конструктор класса.
Инициализация в конструкторе может делаться как прямым присваиванием членам класса нужных значений, либо через использование списка инициализации. Список инициализации указывается сразу после параметров конструктора через двоеточие. В списке через запятую перечисляются переменные класса с указанием в скобках их значений.
class Person < short age; std::string name; public: Person(short _age) // Конструктор с простым присваиванием < age = _age; name = «Default name»; >Person() : name(«Default name»), age(0) <> // Конструктор по-умолчанию со списком инициализации Person(short _age = 0, std::string _name = «Default name») : age(_age), name(_name) <> // Конструктор со списком инициализации >;
Начиная со стандарта C++11 в списке инициализации лучше использовать универсальную инициализацию, когда значения переменных указываются не в круглых, а в фигурных скобках.
class Person < short age; std::string name; public: Person() : name< «Default name» >, age < 0 ><> // Конструктор по-умолчанию со списком инициализации Person(short _age, std::string _name = «Default name») : age< _age >, name < _name ><> // Конструктор со списком инициализации >;
Переменные указанные в списке инициализации инициализируются в том порядке, в котором они объявлены в классе, а не в том, в котором они были указаны в списке.
Члены класса, являющиеся объектами других классов, можно также инициализировать через списки инициализации. При этом их конструкторы могут использовать параметры, переданные в конструктор класса-контейнера.
class A < public: A(int _a) < std::cout >; class B < A a; public: B(int _b) : a< _b — 1 > < std::cout >; B b(5); // Выведет A=4, а затем B=5
Конструктор
Конструктор — это особый метод класса, который вызывается при создании (конструировании) объекта класса.
В языке C++ конструктор всегда должен иметь такое же имя, как и сам класс. Также конструктор не должен иметь возвращаемого типа (даже void).
В классе может быть несколько перегруженных конструкторов (принимающих разные типы переменных).
Если конструктор не имеет параметров или для всех его параметров указаны значения по-умолчанию, то такой конструктор называется конструктором по-умолчанию. В классе может быть только один конструктор по-умолчанию. Если никакой конструктор не задан, то у класса автоматически создается скрытый конструктор по-умолчанию.
class Person < short age; public: std::string name; public: Person() < age = 0; name = «Default»; >// Конструктор по-умолчанию Person(short _age, const char* _name) < age = _age; name = _name; >// Перегруженный конструктор auto getAge() < return age; >>; Person person1; // Инициализация с помощью конструктора по-умолчанию Person person2(20, «Jane»);
Если в классе есть переменные других классов, то их конструктор по-умолчанию будет вызван до вызова конструктора самого класса-контейнера.
class Address < public: Address() < std::cout >; class Person < Address address; public: Person() < std::cout >; Person person; // Выведется сначала «Address constructor», а затем «Person constructor»
Начиная с C++11, конструкторам разрешено вызывать другие конструкторы. Этот процесс называется делегированием конструкторов.
Чтобы один конструктор сначала вызывал другой, нужно просто сделать вызов этого конструктора в списке инициализации членов. При этом использовать инициализацию списком в таком конструкторе уже нельзя.
class A < int v; public: A(int _v) : v< _v ><> A() : A(10) <> >;
Деструктор
Деструктор — это особый метод класса, который вызывается при уничтожении объекта класса.
Назначение деструктора — выполнить освобождение динамических ресурсов, выделенных при работе класса. Если этого не требуется, то деструктор создавать необязательно.
В языке C++ деструктор всегда должен иметь такое же имя, как и сам класс, но с символом ~ (тильда) перед ним. Также как и конструктор, деструктор не должен иметь возвращаемого типа. Кроме того, деструктор не может иметь никакие параметры.
В классе может быть только один деструктор.
class Person < short age; std::string name; Address *pAddr; public: Person() < pAddr = new Address(); >// Конструктор ~Person() < delete pAddr; >// Деструктор >;
Отделение объявления класса от реализации
Язык C++ позволяет отделить объявление класса от реализации его методов.
Объявление класса делается в заголовочных файлах с расширением .h (header).
// Person.h class Person < short age; std::string name; public: short getAge(); >;
Параметры по-умолчанию у методов класса должны быть объявлены в заголовочном файле.
Реализация методов класса делается в файлах с расширением .cpp.
// Person.cpp #include «Person.h» short Person::getAge() < return this->age; >
Использование заголовочных файлов позволяет ускорить компиляцию программ за счет того, что реализации классов компилируется как отдельные файлы и не требуют перекомпиляции в случае изменения других частей программы.
Также использование заголовочных файлов позволяет использовать сторонние предварительно скомпилированные библиотеки на этапе линковки программы.
Константные объекты и методы классов
Если объект класса объявляется с помощью ключевого слова const, то этот экземпляр класса можно инициализировать с помощью конструктора, но нельзя изменить его содержимое. Запрещается как изменение переменных-членов напрямую (если они являются открытыми), так и вызов методов, с помощью которых можно установить значения переменным-членам. Позволяется только вызов константных методов класса.
class Person < int id; short age; public: std::string name; void setAge(short _age) < this->age = _age; > short getAge() const; >; short Person::getAge() const < return this->age; > const Person person(20, «Jane»); person.name = «John»; // Ошибка компиляции person.setAge(30); // Ошибка компиляции std::cout
Константный метод, который попытается изменить переменную-член класса или вызвать неконстантный метод класса также вызовет ошибку компиляции.
Если объект передается в функцию по константной ссылке, то он также становится константным, и к нему применяются те же правила, что и для константных объектов.
Константные методы можно перегружать их неконстантными версиями. При этом константная версия функции будет вызываться для константных классов, а неконстантная — для неконстантных.
Статические члены класса
В классах можно использовать статические переменные, которые будут общими для всех объектов данного класса.
Объявление статической переменной
В таких случаях, в классе делается объявление об использовании статической переменной, а кроме того, делается объявление этой переменной вне класса и, при необходимости, там же делается и её инициализация.
class Person < int id; public: static std::string s_type; // Объявление об использовании статической переменной в классе >; // Объявление и инициализация статической переменной класса Person // Без ключевого слова static std::string Person::s_type = «Default type»;
Инициализировать таким образом статические переменные можно, даже если они закрытые и защищенные. Если статическая переменная объявлена без инициализации, то она автоматически инициализируется значением 0.
Объявлять и инициализировать статическую переменную следует не в заголовочном файле, а в файле *.cpp, иначе при многократном подключении заголовочного файла в разных частях программы получится многократное объявление переменной, что вызовет ошибку при компиляции.
Константную статическую переменную целочисленного типа (int, char, bool, enum) можно инициализировать внутри класса.
class Person < int id; public: static const enum sex = Person::Female; // Инициализация статической переменной в классе >;
Начиная со стандарта C++11, позволяется в классе инициализировать статические члены constexpr любого типа, поддерживающего инициализацию constexpr.
class Person < int id; public: static constexpr double val = 1.25; // Инициализация статической переменной constexpr в классе >;
Использование статической переменной
К статической переменной можно обращаться как через объекты класса, так и через сам класс, используя оператор разрешения области видимости :: (два двоеточия).
Person person1, person2; // К статической переменной можно обращаться как через объект std::cout
Для доступа к закрытой статической переменной класса используются статические методы класса.
Особенностью статических методов является то, что у них нет указателя this на свой класс, а также то, что они не могут обращаться к нестатическим членам класса.
Дружественные функции, методы и классы
Если в виде исключения требуется дать доступ к защищенным и закрытым членам класса какой-то сторонней функции, то можно использовать механизм объявления дружественных функций. Для объявления дружественных функций используется ключевое слово friend.
class Person < int id; short age; friend bool checkAge(Person // Функция checkAge является дружественной для класса Person >; bool checkAge(Person return person.age >18; >
Функция может быть объявлена дружественной одновременно для нескольких классов.
Можно объявить дружественным другой класс, чтобы все его методы могли свободно обращаться к переменным данного класса. Для этого используется выражение friend class.
class Person < int id; short age; friend class Checker; // Класс Checker является дружественным для класса Person >; class Checker < public: bool checkAge(Person return person.age >18; > >;
Объявить дружественным можно и отдельный метод стороннего класса, но это делается несколько сложнее из-за того, что классу требуется видеть полное объявление дружественного класса до своего объявления.
class Person; class Checker < public: bool checkAge(Person >; class Person < int id; short age; friend bool Checker::checkAge(Person // Класс Checker является дружественным для класса Person >; bool Checker::checkAge(Person return person.age >18; >
Это объявление делается проще, если использовать для него заголовочные файлы.
Источник: sysprog.ru
Классы C++
Начиная изучать классы, мы подошли к важному этапу – изучению объектно-ориентированного программирования (ООП) в C++. Классы – довольно обширная тема. Поэтому я разобью её на несколько частей. Таким образом, начинающим будет достаточно просто освоить информацию и разобраться с основами этой темы.
В данном уроке мы познакомимся с синтаксисом классов C++, со спецификаторами доступа к членам (полям) класса ( private и public ). Узнаем, что такое методы класса и как обращаться к членам класса из программы.
Классы C++ похожи на структуры, но обладают своими особенностями и преимуществами. До этого в программах мы определяли структуры и функции отдельно. В классах они объединены в одно целое, чтобы к закрытым данным класса могли обращаться только функции этого класса. Мне понравилась иллюстрация из книги Объектно-ориентированное программирование в С++” Р. Лафоре
В наших первых уроках об ООП мы будем рассматривать простые для понимания классы. Сложные примеры будут только отвлекать от важных деталей, которые касаются определения классов и объектов. В заключительном уроке о классах мы подытожим все изученное и ответим на вопросы – зачем нужны классы и в чём заключаются основные принципы ООП.
Сейчас напишем и разберём следующий код:
Классы в C++, public, private, методы класса
using namespace std ;
class Number
int number ;
void setNumber ( )
cout << «Введите число: » ;
cin >> number ;
void getNumber ( )
cout << number << endl ;
setlocale ( LC_ALL , «rus» ) ;
Number object ;
object . setNumber ( ) ;
object . getNumber ( ) ;
В строках 4 – 19 находится определение класса. Чтобы объявить класс надо использовать ключевое слово class и дать ему имя. В фигурных скобках описать его и, в конце поставить ; точку с запятой.
После объявления имени класса, оно становится именем нового типа данных. С этим типом будут создаваться объекты класса.
В теле класса (между фигурными скобками) могут находиться данные (переменные базовых типов и строки ), функции, принадлежащие классу, структуры, классы… Всё это чаще называют членами или полями класса. Функции, которые объявлены и/или определены в теле класса – это методы класса. Далее так их и будем называть. Просто надо запомнить: методы класса – это функции, специально созданные для работы с данными (членами) этого класса.
Рассмотрим новые для вас ключевые слова – private и public . В С++ принято защищать некоторые данные класса от внешнего вмешательства. То есть, чтобы из главной функции, например, никто не мог напрямую обратиться к этим данным через объект и внести какие-либо изменения.
Чтобы сделать данные “закрытыми” надо разместить их в поле private . По умолчанию, всё что объявлено в классе, становится закрытым от прямого доступа и доступно только для других членов или методов класса. Так что, если такие данные объявляются в самом верху тела класса, слово private можно не использовать.
Чтобы объявить открытые члены класса, надо применить ключевое слово public . В этом поле зачастую находятся методы класса, которые и будут работать с приватными (закрытыми) данными. Публичные (открытые) методы и другие члены класса доступны из любой другой части кода/программы, в которой определен класс. Иногда для работы вам возможно понадобится объявить публичный член класса или приватный метод.
Обратите внимание на определение методов класса. Мы не передаем в них параметры. При этом вносим изменение в переменную number и показываем её на экран. Дело в том, что члены и методы класса находятся в одной области видимости. И методы класса свободно обращаются к данным-членам класса.
В нашем коде мы разместили определение методов прямо в теле класса, так как определение занимает очень мало места. Но чаще придётся выносить его за пределы тела класса или даже в другой файл, а в самом классе оставлять только прототипы методов. Посмотрите, как выглядит определение методов вне класса:
Источник: purecodecpp.com