Как создать много экземпляров класса c

Как создать много экземпляров класса c

Как гарантировать единичность экземпляра некоего класса?

1. Создать класс устройства, объявить его экземпляр в специальном файле globals.cpp, и обязать программистов использовать строго его (именно так я делал на заре карьеры; наш шеф под роспись давал нам «Меморандум о писании программ», там много было интересного).
2. Создать класс устройства, объявить в нем устройство статическим членом.
3. Реализовать в классе устройства подсчет экземпляров, ограничить максимальное количество единицей.
4. Создать «закрытый» класс устройства, создать смарт-указатель на него так, чтобы смарт следил за одиночеством класса устройства.

Первый вариант сразу на помойку. Второй более интересен, но есть несколько неприятных проблем, связанных со статическими и глобальными данными. Правила C/C++ не определяют порядок конструирования таких объектов, если они находятся в разных файлах. То есть, у Вас прога уже вовсю дышит, работает — а находятся такие объекты, которые даже еще не инициализировались! Получается, что глобальные и статические объекты не должны рассчитывать друг на друга. С другой стороны, если объявить статический член, его нужно инициализировать — а данные могут быть еще не готовы.

Третий вариант кажется подходящим, но только кажется. Мы получим ошибку создания во время исполнения. Вот радость то, конструируем объект, а он нам исключения выбрасывает, мы об этом уже говорили в Шаге 12.

В общем, как водится, приходим к смарт-указателю. Конечно, переменную-член указателя на живой, натуральный объект объявляем статической. Но указатель-то инициализируется нулем, NULL. Это потом конструктору передать можно какие угодно параметры. Далее нужно определить статическую функцию, которая при первом обращении создает одинокий объект, а потом возвращает указатель на него. Нужно еще определить так же и разрушающую функцию; проблема будет в том, когда ее вызвать. Теперь можно создавать море смартов — реально они будут указывать на единственный объект. Код для такого способа уже незачем писать.

Зато интересно сделать вот что: пусть класс одинокого устройства будет смарт-указателем на самого себя ([1])!

class CSingleton < public: static CSingleton* GetInstance (void); static void DestroyInstance (void) < if (m_instance) delete m_instance; >; private: static CSingleton* m_instance; protected: CSingleton()<>; >; CSingleton* CSingleton::m_instance = NULL; CSingleton* CSingleton::GetInstance()

Здесь доступ к единичному экземпляру осуществляется исключительно через статическую функцию GetInstance(). Код можно либо вставлять в каждое определение классов-одиночек, либо наследовать от базового класса и вести коллекцию одиночек. В любом случае, такое решение достаточно гибкое, чем объявление глобальных переменных.

[1] Э.Гамма, Р.Хелм, Р.Джонсон, Дж.Влиссидес. «Паттерны проектирования.»
Крайне интересная книжка, описывает 23 стандартных шаблона (паттерна) проектирования; предполагает определенную подготовку; охватывает более высокий уровень программирования и проектирования. Данный прием там именуется как «паттерн Singleton«.

Создание экземпляра класса в Python

Процесс создания экземпляра класса запускается всякий раз, когда происходит вызов объекта класса Python. Процесс создания экземпляра состоит из двух отдельных шагов, которые можно описать следующим образом:

• Создание нового экземпляра целевого класса;
• Инициализация нового экземпляра с соответствующим начальным состоянием.

Для выполнения первого шага в классах Python есть специальный метод .__new__() , который отвечает за создание и возврат нового пустого объекта. Затем другой специальный метод .__init__() , принимает результирующий объект вместе с аргументами конструктора класса.

Метод .__init__() принимает новый объект в качестве первого аргумента self . Затем он устанавливает любой требуемый атрибут экземпляра в допустимое состояние, используя аргументы, переданные ему конструктором класса.

Короче говоря, процесс создания экземпляра Python начинается с запуска создателя экземпляра .__new__() для создания нового пустого объекта. Процесс продолжается инициализатором экземпляра .__init__() , который принимает аргументы конструктора для инициализации вновь созданного объекта.

Чтобы изучить внутреннюю работу процесса создания экземпляров Python, рассмотрите следующий пример класса Point , который (в демонстрационных целях) реализует пользовательскую версию обоих методов, .__new__() и .__init__() :

# point.py class Point: def __new__(cls, *args, **kwargs): print("1. Создается новый экземпляр Point.") return super().__new__(cls) def __init__(self, x, y): print("2. Инициализируется новый экземпляр Point.") self.x = x self.y = y def __repr__(self) -> str: return f"type(self).__name__>(x=self.x>, y=self.y>)" 

Описание того, что делает этот код:

• Строка def __new__(cls, *args, **kwargs) определяет метод, который принимает класс в качестве первого аргумента. Обратите внимание, что использование cls в качестве имени этого аргумента является строгим соглашением в Python, точно так же, как использование self для имени текущего экземпляра. Метод также принимает *args и **kwargs , что позволяет передавать неопределенное количество аргументов инициализации базовому экземпляру.
• Строка return super().__new__(cls) создает и возвращает новый экземпляр Point, вызывая метод родительского класса .__new__() с cls в качестве аргумента. Этот экземпляр будет первым аргументом для .__init__() . В этом примере объект является родительским классом, и вызов super() дает доступ к нему.
• Строка def __init__(self, x, y) определяет метод конструктора, который отвечает за этап инициализации. Этот метод принимает первый аргумент с именем self , который содержит ссылку на текущий экземпляр и два дополнительных аргумента, x и y .
• Внутри метода конструктора .__init__() инициализируются начальные значения атрибутов экземпляра Point.x и Point.y соответственно. Для этого он использует входные аргументы x и y .

Сохраним код, представленный выше в файл с именем point.py и запустим интерпретатор Python:

>>> from point import Point >>> point = Point(21, 42) # 1. Создается новый экземпляр Point. # 2. Инициализируется новый экземпляр Point. >>> point # Point(x=21, y=42) 

Операции, доступные экземплярам класса.

Единственные операции, понятные объектам-экземплярам класса, являются ссылки на атрибуты класса. Существует два вида допустимых имен атрибутов класса, это атрибуты данных и методы класса.

Атрибуты данных соответствуют «переменным экземпляра» в языке Smalltalk или «членам данных» в языке C++. Атрибуты данных класса в Python можно не объявлять, как например это делается с локальным переменным, они появляться динамически, когда им впервые присваивается значение. При этом, динамически созданные атрибуты хранятся в специальном словаре объекта-экземпляра x.__dict__ . Например, если x это экземпляр MyClass , то следующий фрагмент кода напечатает значение 16 .

Создайте файл test.py с определением класса MyClass и запустите его в интерактивном режиме командой: python3 -i test.py .

# файл `test.py` class MyClass: """Простой пример класса""" i = 12345 def f(self): return 'hello world' # запускаем: $ python3 -i test.py >>> x = MyClass() # обратите внимание, что атрибут # `counter` в классе не определен >>> x.counter = 1 # динамически созданные атрибуты экземпляра класса # хранятся в специальных словарях этих экземпляров >>> x.__dict__ # >>> while x.counter  10: . x.counter = x.counter * 2 . >>> x.counter # 16 # удаляем динамически созданный атрибут >>> del x.counter # смотрим специальный словарь экземпляра >>> x.__dict__ # <> # пытаемся получить значение x.counter # Traceback (most recent call last): # File "", line 1, in # AttributeError: 'MyClass' object has no attribute 'counter' 

Другой вид ссылки на атрибут объекта-экземпляра — это метод. Метод — это функция, которая принадлежит объекту класса. В языке Python термин «метод«, для экземпляров классов, не уникален: другие типы объектов также могут иметь свои методы. Например, объекты списка list() имеют методы list.append , list.insert , list.remove , list.sort и т. д. Дальше будем использовать термин «метод» исключительно для обозначения «методов объектов экземпляра класса«, если явно не указано иное.

Допустимые имена методов объекта экземпляра класса зависят от его класса. По определению, все атрибуты класса, являющиеся объектами функций, определяют соответствующие методы его экземпляров. Таким образом, в нашем примере x.f это допустимая ссылка на связанный метод, так как MyClass.f это функция. Тогда как x.i это НЕ метод, а ссылка на атрибут класса MyClass.i . При этом выражение x.f это объект связанного метода, т.е. не то же самое, что MyClass.f . Так как MyClass.f — это объект функции.

Смотрим пример, который это показывает:

>>> MyClass.f # >>> x.f # > >>> MyClass.i # 12345 >>> x.i # 12345 

• ОБЗОРНАЯ СТРАНИЦА РАЗДЕЛА
• Пространство имен и область видимости в классах
• Определение классов
• Объект класса и конструктор класса
• Создание экземпляра класса
• Метод экземпляра класса
• Что такое метод класса и зачем нужен
• Что такое статический метод в классах Python и зачем нужен
• Атрибуты класса и переменные экземпляра класса
• Кэширование методов экземпляра декоратором lru_cache
• Закрытые/приватные методы и переменные класса Python
• Наследование классов
• Множественное наследование классов
• Абстрактные классы
• Перегрузка методов в классе Python
• Что такое миксины и как их использовать
• Класс Python как структура данных, подобная языку C
• Создание пользовательских типов данных
• Специальные (магические) методы класса Python
• Базовая настройка классов Python магическими методами
• Настройка доступа к атрибутам класса Python
• Дескриптор класса для чайников
• Протокол дескриптора класса
• Практический пример дескриптора
• Использование метода .__new__() в классах Python
• Специальный атрибут __slots__ класса Python
• Специальный метод __init_subclass__ класса Python
• Определение метаклассов metaclass
• Эмуляция контейнерных типов в классах Python
• Другие специальные методы класса
• Как Python ищет специальные методы в классах
• Шаблон проектирования Фабрика и его реализация

Создание классов и объектов

В языке программирования Python классы создаются с помощью инструкции class , за которой следует произвольное имя класса, после которого ставится двоеточие, далее с новой строки и с отступом реализуется тело класса:

class ИмяКласса: код_тела_класса

Если класс является дочерним, то родительские классы перечисляются в круглых скобках после имени класса.

Объект создается путем вызова класса по его имени. При этом после имени класса обязательно ставятся скобки:

ИмяКласса()

То есть класс вызывается подобно функции. Однако в случае вызова класса происходит не выполнение его тела, как это происходило бы при вызове функции, а создается объект. Поскольку в программном коде важно не потерять ссылку на только что созданный объект, то обычно его связывают с переменной. Поэтому создание объекта чаще всего выглядит так:

имя_переменной = ИмяКласса()

В последствии к объекту обращаются через связанную с ним переменную.

Пример «пустого» класса и двух созданных на его основе объектов:

>>> class A: . pass . >>> a = A() >>> b = A()

Класс как пространство имен

С точки зрения пространства имен класс можно представить подобным модулю. Также как в модуле в классе могут быть свои переменные со значениями и функции. Также как в модуле у класса есть собственное пространство имен, доступ к которому возможен через имя класса:

>>> class B: . n = 5 . def adder(v): . return v + B.n . >>> B.n 5 >>> B.adder(4) 9

Однако в случае классов используется особая терминология. Пусть имена, определенные в классе, называются атрибутами этого класса. В примере имена n и adder – это атрибуты класса B . Атрибуты-переменные часто называют полями или свойствами (в других языках понятия «поле» и «свойство» не совсем одно и то же). Полем является n . Атрибуты-функции называются методами. Методом в классе B является adder . Количество свойств и методов в классе может быть любым.

Класс как шаблон для создания объектов

На самом деле классы – не модули. Они своего рода шаблоны, от которых создаются объекты-экземпляры. Такие объекты наследуют от класса его атрибуты. Вернемся к нашему классу B и создадим на его основе два объекта:

>>> class B: . n = 5 . def adder(v): . return v + B.n . >>> a = B() >>> b = B()

У объектов, связанных с переменными a и b , нет собственного поля n . Однако они наследуют его от своего класса:

>>> a.n 5 >>> a.n is B.n True

То есть поля a.n и B.n – это одно и то же поле, к которому можно обращаться и через имя a , и через имя b , и через имя класса. Поле одно, ссылок на него три.

Однако что произойдет в момент присваивания этому полю значения через какой-нибудь объект-экземпляр?

>>> a.n = 10 >>> a.n 10 >>> b.n 5 >>> B.n 5

В этот момент у экземпляра появляется собственный атрибут n , который перекроет (переопределит) родительский, то есть тот, который достался от класса.

>>> a.n is B.n False >>> b.n is B.n True

При этом присвоение через B.n отразится только на b и B , но не на a :

>>> B.n = 100 >>> B.n, b.n, a.n (100, 100, 10)

Иная ситуация нас ожидает с атрибутом adder . При создании объекта от класса функция adder не наследуется как есть, а как бы превращается для объекта в одноименный метод:

>>> B.adder is b.adder False >>> type(B.adder) >>> type(b.adder)

Через имя класса мы вызываем функцию adder :

>>> B.adder(33) 133

Через имя объекта вызываем метод adder :

>>> b.adder(33) Traceback (most recent call last): File "", line 1, in TypeError: adder() takes 1 positional argument but 2 were given

В сообщении об ошибке говорится, что adder принимает только один аргумент, а было передано два. Откуда появился второй, если в скобках было указано только одно число?

Дело в том, что в отличии от функции в метод первым аргументом всегда передается объект, к которому применяется этот метод. То есть выражение b.adder(33) как бы преобразовывается в adder(b, 33) . Сам же b.adder как объект типа method хранит сведения, с каким классом он связан и какому объекту-экземпляру принадлежит:

>>> b.adder >

В нашем случае, чтобы вызывать adder через объекты-экземпляры, класс можно переписать так:

>>> class B: . n = 5 . def adder(obj, v): . return v + obj.n . >>> b = B() >>> b.adder(33) 38

В коде выше при вызове метода adder переменной-параметру obj присваивается объект, связанный с переменной, к которой применяется данный метод. В данном случае это объект, связанный с b . Если adder будет вызван на другой объект, то уже он будет присвоен obj :

>>> a = B() >>> a.n = 9 >>> a.adder(3) 12

В Python переменную-параметр метода, которая связывается с экземпляром своего класса, принято называть именем self. Таким образом, более корректный код будет таким:

>>> class B: . n = 5 . def adder(self, v): . return v + self.n

Можем ли мы все также вызывать adder как функцию, через имя класса? Вполне. Только теперь в функцию надо передавать два аргумента:

>>> B.adder(B, 200) 205 >>> B.adder(a, 200) 209

Здесь первым аргументом в функцию передается объект, у которого есть поле n лишь только потому, что далее к этому полю обращаются через выражение self.n .

Однако если атрибут определен так, что предполагается его работа в качестве метода, а не функции, то через класс его уже не вызывают (нет смысла, логика программы этого не подразумевает).

С другой стороны, в ООП есть понятие «статический метод». По сути это функция, которая может вызываться и через класс, и через объект, и которой первым аргументом не подставляется объект, на который она вызывается. В Python статический метод можно создать посредством использования специального декоратора.

Атрибут __dict__

В Python у объектов есть встроенные специальные атрибуты. Мы их не определяем, но они есть. Одним из таких атрибутов объекта является свойство __dict__ . Его значением является словарь, в котором ключи – это имена свойств экземпляра, а значения – текущие значения свойств.

>>> class B: . n = 5 . def adder(self, v): . return v + self.n . >>> w = B() >>> w.__dict__ <> >>> w.n = 8 >>> w.__dict__

В примере у экземпляра класса B сначала нет собственных атрибутов. Свойство n и метод adder – это атрибуты объекта-класса, а не объекта-экземпляра, созданного от этого класса. Лишь когда мы выполняем присваивание новому полю n экземпляра, у него появляется собственное свойство, что мы наблюдаем через словарь __dict__ .

В следующем уроке мы увидим, что свойства экземпляра обычно не назначаются за пределами класса. Это происходит в методах классах путем присваивание через self . Например, self.n = 10 .

Атрибут __dict__ используется не только для просмотра свойств объекта. С его помощью можно удалять, добавлять свойства, а также изменять их значения.

>>> w.__dict__['m'] = 100 >>> w.__dict__ >>> w.m 100

Практическая работа

Напишите программу по следующему описанию. Есть класс «Воин». От него создаются два экземпляра-юнита. Каждому устанавливается здоровье в 100 очков. В случайном порядке они бьют друг друга. Тот, кто бьет, здоровья не теряет. У того, кого бьют, оно уменьшается на 20 очков от одного удара. После каждого удара надо выводить сообщение, какой юнит атаковал, и сколько у противника осталось здоровья. Как только у кого-то заканчивается ресурс здоровья, программа завершается сообщением о том, кто одержал победу.

Курс с примерами решений практических работ:
pdf-версия

X Скрыть Наверх

Объектно-ориентированное программирование на Python

Классы, структуры и пространства имен

C# является полноценным объектно-ориентированным языком. Это значит, что программу на C# можно представить в виде взаимосвязанных взаимодействующих между собой объектов.

Описанием объекта является класс , а объект представляет экземпляр этого класса. Можно еще провести следующую аналогию. У нас у всех есть некоторое представление о человеке, у которого есть имя, возраст, какие-то другие характеристики. То есть некоторый шаблон — этот шаблон можно назвать классом. Конкретное воплощение этого шаблона может отличаться, например, одни люди имеют одно имя, другие — другое имя. И реально существующий человек (фактически экземпляр данного класса) будет представлять объект этого класса.

В принципе ранее уже использовались классы. Например, тип string , который представляет строку, фактически является классом. Или, например, класс Console , у которого метод WriteLine() выводит на консоль некоторую информацию. Теперь же посмотрим, как мы можем определять свои собственные классы.

По сути класс представляет новый тип, который определяется пользователем. Класс определяется с помощью ключевого слова сlass :

class название_класса < // содержимое класса >

После слова class идет имя класса и далее в фигурных скобках идет собственно содержимое класса. Например, определим в файле Program.cs класс Person, который будет представлять человека:

class Person

Начиная с версии C# 12, если класс имеет пустое определение, то фигурные скобки после названия типа можно не использовать:

class Person;

Однако такой класс не особо показателен, поэтому добавим в него некоторую функциональность.

Поля и методы класса

Класс может хранить некоторые данные. Для хранения данных в классе применяются поля . По сути поля класса — это переменные, определенные на уровне класса.

Кроме того, класс может определять некоторое поведение или выполняемые действия. Для определения поведения в классе применяются методы.

Итак, добавим в класс Person поля и методы:

class Person < public string name = "Undefined"; // имя public int age; // возраст public void Print() < Console.WriteLine($"Имя: Возраст: "); > >

В данном случае в классе Person определено поле name , которое хранит имя, и поле age , которое хранит возраст человека. В отличие от переменных, определенных в методах, поля класса могут иметь модификаторы, которые указываются перед полем. Так, в данном случае, чтобы все поля были доступны вне класса Person поля определены с модификатором public .

При определении полей мы можем присвоить им некоторые значения, как в примере выше в случае переменной name . Если поля класса не инициализированы, то они получают значения по умолчанию. Для переменных числовых типов это число 0.

Также в классе Person определен метод Print() . Методы класса имеют доступ к его поля, и в данном случае обращаемся к полям класса name и age для вывода их значения на консоль. И чтобы этот метод был виден вне класса, он также определен с модификатором public .

Создание объекта класса

После определения класса мы можем создавать его объекты. Для создания объекта применяются конструкторы . По сути конструкторы представляют специальные методы, которые называются так же как и класс, и которые вызываются при создании нового объекта класса и выполняют инициализацию объекта. Общий синтаксис вызова конструктора:

new конструктор_класса(параметры_конструктора);

Сначала идет оператор new , который выделяет память для объекта, а после него идет вызов конструктора .

Конструктор по умолчанию

Если в классе не определено ни одного конструктора (как в случае с нашим классом Person), то для этого класса автоматически создается пустой конструктор по умолчанию, который не принимает никаких параметров.

Теперь создадим объект класса Person:

Person tom = new Person(); // создание объекта класса Person // определение класса Person class Person < public string name = "Undefined"; public int age; public void Print() < Console.WriteLine($"Имя: Возраст: "); > >

Для создания объекта Person используется выражение new Person() . В итоге после выполнения данного выражения в памяти будет выделен участок, где будут храниться все данные объекта Person. А переменная tom получит ссылку на созданный объект, и через эту переменную мы можем использовать данный объект и обращаться к его функциональности.

Обращение к функциональности класса

Для обращения к функциональности класса — полям, методам (а также другим элементам класса) применяется точечная нотация точки — после объекта класса ставится точка, а затем элемент класса:

объект.поле_класса объект.метод_класса(параметры_метода)

Например, обратимся к полям и методам объекта Person:

Person tom = new Person(); // создание объекта класса Person // Получаем значение полей в переменные string personName = tom.name; int personAge = tom.age; Console.WriteLine($"Имя: Возраст "); // Имя: Undefined Возраст: 0 // устанавливаем новые значения полей tom.name = "Tom"; tom.age = 37; // обращаемся к методу Print tom.Print(); // Имя: Tom Возраст: 37 class Person < public string name = "Undefined"; public int age; public void Print() < Console.WriteLine($"Имя: Возраст: "); > >

Консольный вывод данной программы:

Имя: Undefined Возраст: 0 Имя: Tom Возраст: 37

Добавление класса

Обычно классы помещаются в отдельные файлы. Нередко для одного класса предназначен один файл. Если мы работаем над проектом вне среды Visual Studio, используя .NET CLI, то нам достаточно добавить новый файл класса в папку проекта. Например, добавим новый файл, который назовем Person.cs и в котором определим следующий код:

class Person < public string name = "Undefined"; public void Print() < Console.WriteLine($"Person "); > >

Здесь определен класс Person с одним полем name и методом Print.

В файле Program.cs , который представляет основной файл программы используем класс Person:

Person tom = new Person(); tom.name = "Tom"; tom.Print(); // Person Tom

Visual Studio предоставляет по умолчанию встроенные шаблоны для добвления класса. Для добавления класса нажмем в Visual Studio правой кнопкой мыши на название проекта:

В появившемся контекстном меню выберем пункт Add -> New Item. (или Add -> Class. )

В открывшемся окне добавления нового элемента убедимся, что в центральной части с шаблонами элементов у нас выбран пункт Class . А внизу окна в поле Name введем название добавляемого класса — пусть он будет назваться Person :

В качестве названия класса можно вводить как Person, так и Person.cs. И после нажатия на кнопку добавления в проект будет добавлен новый класс, в котором можно определить тот же код и также использовать в файле Program.cs.

Таким образом, мы можем определять классы в отдельных файлах и использовать их в программе.