Czytaj książkę: «Прототип. Паттерн GoF на Python, C++23, Rust и Java»

Czcionka:

Введение

Эта книга посвящена одному паттерну проектирования — Прототип (Prototype). Он относится к каталогу «Банды четырёх» (Gang of Four, GoF). Здесь паттерн разобран сразу в четырёх реализациях: на Python, C++23, Rust и Java. Каждая реализация — отдельная часть книги: сначала задача и общая схема, затем код, модификации, гибридные варианты и самостоятельные работы.

Как читать

Основы каждого языка здесь не повторяются: они собраны в книгах серий по соответствующему языку. Разделы каждой части нумеруются заново, поэтому ссылка «раздел 1.2» указывает на раздел той же части, где она сделана.

Глава 4. Реализация на Python

4.1. Зачем нужен прототип

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

Прототип описывает именно это: объект умеет клонировать себя, а клиент создаёт новые объекты копированием образца. В Python копирование встроено в стандартную библиотеку — модуль copy с функциями copy.copy (поверхностная копия) и copy.deepcopy (глубокая), а для dataclass — dataclasses.replace. Поэтому главный вопрос паттерна в Python — не «как скопировать», а что именно копировать: данные целиком или разделяемые ссылки.

4.2. Участники и схема



Prototype — интерфейс клонирования.

ConcretePrototype — классы, умеющие себя копировать.

Client — создаёт объекты, запрашивая копии.

Registry — необязательное хранилище именованных образцов.

4.3. Поверхностная и глубокая копия

Это главная ловушка паттерна в Python, поэтому начнём с неё.

Файл 01_shallow_deep.py :



Листинг 4.1 — Поверхностная и глубокая копия

Разбор. copy.copy создаёт новый объект, но его атрибуты ссылаются на те же объекты, что и у оригинала. Число hp неизменяемо, поэтому shallow.hp -= 30 просто привязывает к атрибуту копии новое число — прототип не затронут. А список loot общий: добавление ключа в «копию» испортило прототип. copy.deepcopy рекурсивно копирует вложенные объекты, и копия становится полностью независимой.

Правило: если у объекта есть изменяемые вложенные данные (списки, словари, другие объекты), которые копия будет менять, нужна глубокая копия — или явное копирование именно этих полей.

4.4. Классическая реализация: метод clone

Иногда ни поверхностная, ни глубокая копия не подходят целиком: часть данных нужно копировать, часть — разделять, часть — сбрасывать. Тогда объект определяет собственный метод clone или специальные методы __copy__ и __deepcopy__.

Файл 02_clone.py :




Листинг 4.2 — Классическая реализация: метод clone




Листинг 4.2 (продолжение) — Классическая реализация: метод clone

Разбор. Метод clone определён в базовом классе и работает для всех фигур: copy.copy(self) создаёт объект того же класса со всеми атрибутами, включая r, w и h, о которых базовый класс не знает. Затем копия получает собственный идентификатор и собственное множество тегов. Добавление тега «копия» не затронуло оригинал. Клиенту, который вызывает moved, не нужно знать, круг перед ним или прямоугольник.

4.5. Модификации паттерна

Реестр прототипов

Файл 03_registry.py :



Листинг 4.3 — Модификации паттерна




Листинг 4.3 (продолжение) — Модификации паттерна

Разбор. Реестр хранит образцы и выдаёт только глубокие копии — клиент может менять результат как угодно, образцы остаются нетронутыми. Новые шаблоны создаются от существующих. Сообщение берётся из e.args[0], потому что str() у KeyError добавляет кавычки вокруг сообщения.

Разделяемые неизменяемые данные

Глубокое копирование не всегда нужно и бывает дорогим. Если большая часть объекта неизменяема — модель, текстура, справочник, — её разделяют между копиями, а копируют только изменяемое.

Файл 04_shared.py :




Листинг 4.4 — Модификации паттерна

Разбор. dataclasses.replace создаёт копию с изменёнными полями, а поле mesh в копии ссылается на ту же модель. Это безопасно, потому что Mesh неизменяем (frozen=True и кортежи). Тысяча деревьев хранит одну модель из 50 000 вершин. sys.getrefcount показывает число ссылок: тысяча деревьев, прототип и переменная mesh (функция добавляет ещё одну временную ссылку, её мы вычитаем).

Последняя строка показывает, что deepcopy достаточно умна: неизменяемые кортежи из неизменяемых элементов она не копирует, а возвращает тот же объект.

Свой __deepcopy__: что не копировать

Файл 05_custom_deepcopy.py :




Листинг 4.5 — Модификации паттерна

Разбор. Объекты вроде блокировок, файлов и сокетов глубоко копировать нельзя — deepcopy откажется. Метод __deepcopy__ позволяет решить за объект, что копировать, что создать заново и что сбросить. Словарь memo нужен, чтобы при циклических ссылках не копировать один объект дважды: мы записываем новый объект в memo до копирования вложенных данных.

4.6. Гибрид: прототипы для рабочих процессов

Прототип удобен для распределения работы: основной код настраивает образец, а каждый рабочий получает копию и меняет её без синхронизации. В пуле процессов копии создаются автоматически — объекты передаются через сериализацию.

Файл 06_processes.py :



Листинг 4.6 — Гибрид: прототипы для рабочих процессов

Разбор. Каждый вариант — копия прототипа с другим seed. Пул процессов сериализует объекты и передаёт их в отдельные процессы, где они выполняются по-настоящему параллельно, без ограничений GIL. Результат детерминирован: генератор random.Random(seed) зависит только от зерна. pool.map возвращает результаты в порядке входных данных.

Функция run объявлена на уровне модуля, а запуск стоит под if __name__ == «__main__»: — это обязательно для пула процессов: дочерние процессы импортируют модуль заново и не должны повторно запускать пул.

4.7. Самостоятельная работа: профиль игрока

Задание. Профиль игрока содержит имя, список предметов (у каждой копии свой) и общую таблицу уровней (одна на всех, неизменяемая). Сделайте копию профиля, измените в ней предметы и проверьте, что таблица разделяется, а предметы — нет.

Полное решение — файл 07_profile.py :




Листинг 4.7 — Самостоятельная работа: профиль игрока

Разбор. Метод clone явно решает, что копировать (list(self.items)), а что разделять (self.levels). bisect_right находит, сколько порогов опыта пройдено: при 750 очках это пороги 0, 100, 300 и 700 — уровень 4.

4.8. Типичные ошибки

Поверхностная копия с изменяемыми полями. Самая частая ошибка: copy.copy или dict.copy() оставляют вложенные списки общими.

Глубокая копия всего подряд. deepcopy больших структур медленный, а некоторые объекты (блокировки, файлы) не копируются вовсе. Копируйте осознанно или определяйте __deepcopy__.

Копия с тем же идентификатором. Если у объекта есть уникальный номер, копия должна получить новый.

Изменяемые значения по умолчанию. def f(items=[]) — одна и та же копия на все вызовы. Это не прототип, а ошибка.

4.9. Вопросы для самопроверки

Чем copy.copy отличается от copy.deepcopy?

Почему shallow.hp -= 30 не изменил прототип, а shallow.loot.append изменил?

Как метод clone в базовом классе копирует атрибуты подклассов?

Как dataclasses.replace помогает разделять неизменяемые данные?

Зачем нужен __deepcopy__ и что хранится в memo?

Почему deepcopy неизменяемого кортежа возвращает тот же объект?

Почему в примере с процессами функция run объявлена на уровне модуля?

Когда реестр прототипов удобнее набора функций-конструкторов?

4.10. Ответы

Поверхностная копия создаёт новый объект со ссылками на те же вложенные объекты; глубокая рекурсивно копирует вложенные объекты.

Число неизменяемо: -= привязывает к атрибуту копии новый объект. Список изменяемый и общий: append меняет сам объект, на который ссылаются оба.

copy.copy(self) создаёт объект того же класса и копирует весь словарь атрибутов, включая атрибуты подкласса.

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

Чтобы решить, какие части копировать, создавать заново или сбрасывать. memo хранит уже скопированные объекты по их id, чтобы обрабатывать циклические ссылки.

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

Дочерние процессы получают функцию по имени при сериализации; функция должна импортироваться из модуля.

Когда образцы настраиваются во время работы: пользователь сохраняет шаблоны, конфигурация описывает варианты.

Глава 4. Реализация на C++23

4.1. Создание через копирование

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

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

Prototype входит в порождающую группу GoF. Паттерн описывает организацию создания, но не предписывает всегда использовать виртуальные функции. В C++ конкретный известный тип часто достаточно скопировать обычным конструктором; виртуальный clone() особенно полезен, когда копирование должно сохранить неизвестный клиенту динамический тип.

4.2. Копирование и срезка в C++

При копировании производного объекта по значению в объект конкретного базового класса сохраняется только базовая часть. Это называют срезкой, или object slicing. Данные и поведение, относящиеся к производной части, в такой копии не сохраняются. Абстрактный базовый класс по значению создать вообще нельзя; ссылку или указатель на него использовать можно.

Виртуальная функция clone() вызывается через базовый интерфейс и делегирует создание копии самому объекту. Типичная сигнатура — std::unique_ptr<Entity> clone() const. Каждое переопределение возвращает тот же тип умного указателя на базовый класс, но создаёт свой конкретный объект. Виртуальный деструктор базового класса обеспечивает правильное удаление через этот указатель.

4.3. Участники и устройство

Prototype определяет интерфейс копирования.

ConcretePrototype создаёт копию своего конкретного типа и определяет правила копирования состояния.

Client запрашивает копию и использует её через интерфейс.

Prototype Registry — необязательный реестр именованных образцов.



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

4.4. Применимость и последствия

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

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

Отличие от Factory Method: фабричный метод создаёт продукт согласно реализации создателя; Prototype получает его копированием образца. Фабрика может хранить прототипы и вызывать их clone(). Отличие от Builder: Builder строит результат пошагово, а Prototype начинает с существующего состояния.

4.5. Классический пример: виртуальное копирование сущности

Monster реализует clone() через свой конструктор копирования. Возвращаемый unique_ptr<Entity> сохраняет владение, а виртуальный вызов describe() продолжает обращаться к правильному конкретному типу.



Листинг 4.1 — Классический пример: виртуальное копирование сущности

Разбор. Entity задаёт виртуальный контракт копирования и виртуальный деструктор. Monster::clone вызывает конструктор копирования Monster, поэтому строка и число копируются в отдельный объект. Указатель на копию возвращается как unique_ptr<Entity>; удаление происходит через виртуальный деструктор.

После копирования оригинал теряет 30 единиц здоровья. Копия сохраняет исходное значение. Виртуальный describe() на базовом указателе вызывает реализацию Monster. Оба объекта существуют независимо и используются одним потоком.

Вывод:



4.6. Восемь разновидностей и связанных приёмов

1. Shallow Copy Prototype — поверхностное копирование

При копировании верхнего объекта вложенный ресурс может оставаться общим. shared_ptr копирует владение, а не сам объект. Это удобно для неизменяемой палитры или текстуры, но опасно, если клиенты неожиданно разделяют изменяемые данные. В работе 2 два элемента имеют независимые координаты и одну const-палитру.

2. Deep Copy Prototype — глубокое копирование

Копируемое состояние, которое должно быть независимым, создаётся заново. Для дерева достаточно определить правила копирования узлов; для графа с циклами и разделяемыми узлами часто нужен словарь «старый адрес — новый адрес». Работа 3 хранит связи индексами в собственной таблице узлов: обычное копирование векторов сохраняет цикл и независимость двух графов.

3. Prototype Registry / Prototype Manager — реестр прототипов

Реестр хранит подготовленные объекты по ключам и выдаёт не оригинал, а результат их clone(). Нужно описать поведение при неизвестном имени и при повторной регистрации, а также правила конкурентного доступа. Работа 4 применяет эту схему к игровым юнитам.

4. Copy Constructor / Static Copy Factory

Когда конкретный тип известен, обычный конструктор копирования часто проще виртуальной иерархии. Статический copy_of может дать операции читаемое имя или добавить проверку. В работе 5 std::vector копируется значением, поэтому матрицы владеют независимыми буферами. Семантика перемещения и идеальная передача аргументов решают другие задачи и не делают копирование автоматически глубоким.

5. Serialization-Based Prototype

Объект можно записать в формат данных и восстановить из него новый экземпляр. Такой подход полезен, если сериализация уже нужна приложению, но он не является универсальной автоматической заменой clone(): необходимо определить формат, версии, типы, ссылки, циклы и обработку ошибок. Работа 6 использует явно определённый небольшой бинарный формат с проверкой границ.

6. Copy-on-Modify / with-Method

Метод with_theme может возвращать изменённую копию, оставляя исходный объект без изменений. Это удобный приём для значимых конфигураций и подготовки нескольких вариантов из одной основы. Работа 7 копирует строки значением. Обозначенная инициализация агрегатов применима лишь при соблюдении правил языка и не является произвольным механизмом копирования с изменением закрытых полей.

Darmowy fragment się skończył.

Ograniczenie wiekowe:
0+
Data wydania na Litres:
18 listopada 2026
Data napisania:
2026
Objętość:
128 str. 131 ilustracji
Właściciel praw:
Автор
Format pobierania: