Upgrade to Pro — share decks privately, control downloads, hide ads and more …

Lecture №2.10. Design patterns (part 3). Struct...

Sponsored · SiteGround - Reliable hosting with speed, security, and support you can count on. →

Lecture №2.10. Design patterns (part 3). Structural patterns.

1. Adapter.
2. Decorator.
3. Proxy.
4. Facade.
5. Composite.
6. Object Pool.
7. Null Object.
8. Servant (Слуга).

Baramiya Denis

November 05, 2019

Transcript

90 slides
  1. Структурные паттерны: как собрать из объектов более крупную структуру Обёртки,

    группы, мосты между интерфейсами — и всё это так, чтобы клиентский код не менялся
  2. Продолжаем графический редактор Мой редактор — рисунок.svg Выделение Прямоугольник Круг

    Как и раньше: решаем задачу в лоб, находим проблему — и исправляем паттерном
  3. Структурный паттерн · 1 / 7 Adapter Адаптер Превращает интерфейс

    чужого класса в тот, который ждёт наш код
  4. Задача: чужая геометрия Готовая библиотека хранит многоугольники и считает их

    площадь Но у неё свои типы и имена: geo::Vec2, area_and_perimeter() Рисует редактор сам — библиотека ничего не рисует Менять библиотеку нельзя — это чужой код
  5. Наш интерфейс class Shape { public: virtual ~Shape() = default;

    virtual void draw() const = 0; virtual double area() const = 0; }; Весь редактор работает с Shape: рисует, считает площадь, сохраняет
  6. Интерфейс библиотеки namespace geo { // сторонняя библиотека геометрии: менять

    её нельзя struct Vec2 { double x; double y; }; // своя точка class Polygon { public: explicit Polygon(std::vector<Vec2> vertices); const std::vector<Vec2>& vertices() const; void area_and_perimeter(double& area, double& perimeter) const; }; } // namespace geo Свой тип точки: Vec2 Площадь — через выходные параметры
  7. Решение в лоб for (const auto& shape : shapes) shape->draw();

    for (const auto& polygon : polygons) { // и так — везде, где обходим фигуры std::vector<Point> points; for (const geo::Vec2& v : polygon.vertices()) points.push_back({v.x, v.y}); drawPolyline(points); } Перевод чужих типов — в каждом клиенте Свои и чужие фигуры не лежат в одном контейнере
  8. Идея: обёртка с нашим интерфейсом Клиент Ожидаемый интерфейс Редактор Shape

    вызывает draw() draw() = 0 area() = 0 Адаптер Чужой класс PolygonShape geo::Polygon draw() area() vertices() area_and_perimeter() draw(): вершины Vec2 → Point → drawPolyline()
  9. Адаптер объекта class PolygonShape final : public Shape { public:

    explicit PolygonShape(geo::Polygon polygon) : polygon_(std::move(polygon)) {} void draw() const override; double area() const override; private: geo::Polygon polygon_; }; // адаптер владеет объектом библиотеки
  10. Адаптер переводит void PolygonShape::draw() const { std::vector<Point> points; for (const

    geo::Vec2& v : polygon_.vertices()) points.push_back({v.x, v.y}); // чужие точки → наши drawPolyline(points); // рисует сам редактор } double PolygonShape::area() const { double area = 0; double perimeter = 0; polygon_.area_and_perimeter(area, perimeter); return area; } // чужой интерфейс → наш Вся «переводческая» работа — в одном месте
  11. Использование std::vector<std::unique_ptr<Shape>> shapes; shapes.push_back(std::make_unique<Circle>(10)); shapes.push_back(std::make_unique<PolygonShape>( geo::Polygon({{0, 0}, {4, 0}, {4,

    3}}))); for (const auto& shape : shapes) { // один цикл для своих и чужих фигур shape->draw(); std::cout << shape->area() << '\n'; } Библиотека и редактор ничего не знают друг о друге — их связывает адаптер
  12. Адаптер класса class PolygonShape final : public Shape, private geo::Polygon

    { public: using geo::Polygon::Polygon; // конструкторы библиотеки void draw() const override; double area() const override { double area = 0; double perimeter = 0; area_and_perimeter(area, perimeter); return area; } }; // метод базы, без polygon_.
  13. Адаптер объекта или класса Адаптер объекта Адаптер класса Как Хранит

    объект в поле private-наследование Адаптирует Класс и всех его наследников Только один класс Может переопределить Нет Виртуальные методы чужого класса Обычно выбирают Да — композиция гибче Когда нужно переопределение
  14. Адаптеры в STL std::stack<int> undo; undo.push(1); // адаптер контейнера: deque

    → стек std::vector<int> copy; auto out = std::back_inserter(copy); std::ranges::copy(sizes, out); // адаптер итератора: *out = x → push_back(x) // адаптер диапазона: элементы видны умноженными на 2 auto doubled = sizes | std::views::transform([](int x) { return x * 2; }); Так их и называют в стандарте: адаптеры контейнеров, итераторов и диапазонов
  15. Итоги: Adapter Достоинства Чужой код работает с нашим, без правок

    Вся «переводческая» логика — в одном классе Недостатки Ещё один слой и класс на каждую библиотеку Не всё переводится один в один
  16. Структурный паттерн · 2 / 7 Facade Фасад Даёт простой

    интерфейс к сложной подсистеме
  17. Задача: сохранить рисунок в PNG Отрисовать в картинку, сжать, добавить

    метаданные, записать файл Это четыре разных класса со своими настройками Сохранять PNG нужно из меню, из экспорта и из автосохранения
  18. Решение в лоб // каждый, кому нужен PNG, повторяет всё

    это Rasterizer rasterizer; Bitmap bitmap = rasterizer.render(canvas, 300); PngEncoder encoder; encoder.setCompression(6); Bytes png = encoder.encode(bitmap); MetadataWriter{}.add(png, "Software", "Мой редактор"); FileWriter{}.write("logo.png", png); Клиент знает все классы подсистемы Порядок шагов повторяется везде
  19. Идея: одна дверь в подсистему Подсистема Rasterizer Клиенты Меню, экспорт,

    автосохра нение Фасад PngEncoder PngExporter exportTo() MetadataWriter FileWriter
  20. Фасад class PngExporter { public: void setDpi(int dpi) { dpi_

    = dpi; } void exportTo(const Canvas& canvas, const std::string& path) const { Bitmap bitmap = Rasterizer{}.render(canvas, dpi_); PngEncoder encoder; encoder.setCompression(6); Bytes png = encoder.encode(bitmap); MetadataWriter{}.add(png, "Software", "Мой редактор"); FileWriter{}.write(path, png); } private: int dpi_ = 300; };
  21. Использование PngExporter exporter; exporter.exportTo(canvas, "logo.png"); // одна строка вместо десяти

    exporter.setDpi(72); exporter.exportTo(canvas, "preview.png"); Подсистема никуда не делась: если нужна тонкая настройка, её классы можно вызвать напрямую
  22. Итоги: Facade Достоинства Клиенты не зависят от устройства подсистемы Типичный

    сценарий — одной строкой Недостатки Фасад легко раздуть до «класса, который знает всё» Редкие сценарии всё равно требуют подсистемы
  23. Структурный паттерн · 3 / 7 Proxy Заместитель Подставной объект

    с тем же интерфейсом, который управляет доступом к настоящему
  24. Задача: большие фотографии В документе сотня фотографий по 50 МБ

    При открытии нужно только разложить их по странице — нужны размеры Загружать все пиксели сразу — долго и дорого
  25. Изображение class Image { public: virtual ~Image() = default; virtual

    Size size() const = 0; virtual void draw() const = 0; }; class RealImage final : public Image { public: explicit RealImage(const std::string& path); Size size() const override { return size_; } void draw() const override; }; // читает весь файл: долго
  26. Идея: заместитель с тем же интерфейсом Клиент Интерфейс Документ Image

    size() draw() size() = 0 draw() = 0 Заместитель Настоящий объект LazyImage RealImage size(): из заголовка draw(): загрузить и нарисовать создаёт size() draw()
  27. Ленивая загрузка class LazyImage final : public Image { public:

    explicit LazyImage(std::string path) : path_(std::move(path)), size_(readHeader(path_)) {} Size size() const override { return size_; } // пиксели не нужны void draw() const override { if (!real_) real_ = std::make_unique<RealImage>(path_); real_->draw(); } private: std::string path_; Size size_; mutable std::unique_ptr<RealImage> real_; }; // загрузка при первом draw // кеш меняется в const-методе
  28. const-метод меняет поле? mutable Кеш — не часть наблюдаемого состояния:

    для клиента картинка та же Потоки Два потока вызвали draw() одновременно — гонка. Нужен mutex или std::call_once
  29. Использование std::vector<std::unique_ptr<Image>> photos; photos.reserve(paths.size()); for (const auto& path : paths)

    photos.push_back(std::make_unique<LazyImage>(path)); int width = 0; for (const auto& photo : photos) width += photo->size().w; photos.front()->draw(); // быстро // раскладка: нужны только размеры // загрузится только первая фотография Документ открылся сразу: прочитаны только заголовки файлов
  30. Защищающий заместитель class ReadOnlyDocument final : public Document { public:

    explicit ReadOnlyDocument(std::unique_ptr<Document> real) : real_(std::move(real)) {} void view() const override { real_->view(); } // смотреть можно void edit() override { throw std::runtime_error("Документ открыт только для чтения"); } private: std::unique_ptr<Document> real_; }; Тот же интерфейс Document — но редактировать нельзя
  31. Виды заместителей Виртуальный Создаёт дорогой объект только тогда, когда он

    нужен Защищающий Проверяет права перед вызовом Удалённый Скрывает, что объект в другом процессе или на сервере Умный указатель unique_ptr и shared_ptr: operator-> ведёт к объекту и управляет его временем жизни
  32. Итоги: Proxy Достоинства Клиент не замечает подмены Ленивая загрузка, проверка

    прав, кеш — без правок в настоящем классе Недостатки Задержка переезжает в неожиданный момент: первый draw() Ещё один слой косвенности
  33. Структурный паттерн · 4 / 7 Decorator Декоратор Добавляет объекту

    новое поведение, оборачивая его, — без наследования
  34. Задача: тень и рамка Любой фигуре можно включить тень, рамку,

    прозрачность В любых сочетаниях — и даже две рамки Включать и выключать прямо во время работы
  35. Решение в лоб: наследование class ShadowCircle : public Circle {};

    class BorderCircle : public Circle {}; class ShadowBorderCircle : public Circle {}; class ShadowRectangle : public Rectangle {}; class BorderRectangle : public Rectangle {}; class ShadowBorderRectangle : public Rectangle {}; // + прозрачность: каждая новая настройка удваивает число классов Взрыв классов Эффект нельзя добавить к уже созданной фигуре
  36. Идея: обёртки, вложенные друг в друга снаружи внутри Border 4px

    Border 2px Shadow Circle draw() draw() draw() draw() У каждой обёртки тот же интерфейс Shape. Она делает своё и передаёт вызов внутрь
  37. Базовый декоратор class ShapeDecorator : public Shape { public: explicit

    ShapeDecorator(std::unique_ptr<Shape> inner) : inner_(std::move(inner)) {} void draw() const override { inner_->draw(); } // передаём внутрь double area() const override { return inner_->area(); } private: std::unique_ptr<Shape> inner_; }; Декоратор — это Shape, который держит другой Shape
  38. Тень class Shadow final : public ShapeDecorator { public: using

    ShapeDecorator::ShapeDecorator; void draw() const override { std::cout << "тень\n"; // до фигуры ShapeDecorator::draw(); } };
  39. Рамка class Border final : public ShapeDecorator { public: Border(std::unique_ptr<Shape>

    inner, int width) : ShapeDecorator(std::move(inner)), width_(width) {} void draw() const override { ShapeDecorator::draw(); std::cout << "рамка " << width_ << "px\n"; } private: int width_; }; // после фигуры
  40. Использование std::unique_ptr<Shape> logo = std::make_unique<Circle>(30); logo = std::make_unique<Shadow>(std::move(logo)); logo =

    std::make_unique<Border>(std::move(logo), 2); logo = std::make_unique<Border>(std::move(logo), 4); // две рамки — легко logo->draw(); // тень, круг, рамка 2px, рамка 4px Порядок обёрток важен: внешняя рамка рисуется последней
  41. Осторожно: тип скрыт auto* circle = dynamic_cast<Circle*>(logo.get()); // nullptr! //

    снаружи это Border, а не Circle: декоратор прячет настоящий тип Код, который проверяет конкретный тип, перестанет работать с обёрнутыми объектами
  42. Adapter, Proxy, Decorator Интерфейс Зачем Adapter Меняет на нужный Подружить

    несовместимые классы Proxy Тот же Управлять доступом: когда и кому Decorator Тот же Добавить поведение Все три — обёртки. Различаются целью
  43. Итоги: Decorator Достоинства Поведение добавляется во время работы Любые сочетания

    без новых классов Недостатки Много маленьких объектов-обёрток Настоящий тип объекта скрыт Важен порядок обёрток
  44. Структурный паттерн · 5 / 7 Composite Компоновщик Собирает объекты

    в дерево и позволяет работать с группой так же, как с одним объектом
  45. Задача: группы фигур Выделили несколько фигур, нажали Ctrl+G — получилась

    группа Группу можно двигать, рисовать, считать площадь — как одну фигуру Группы бывают вложенными
  46. Решение в лоб struct Group { // не наследует Shape

    std::vector<std::unique_ptr<Shape>> shapes; std::vector<Group> groups; // вложенные группы }; double totalArea(const Group& group) { double sum = 0; for (const auto& shape : group.shapes) sum += shape->area(); for (const auto& sub : group.groups) sum += totalArea(sub); // обход — у клиента return sum; } // и так же для draw(), moveBy(), hitTest()… Группа — не Shape: в холст её не положить Обход дерева — в каждой операции Фигуры и группы порознь — порядок потерян
  47. Идея: группа — тоже фигура Клиент Компонент Редактор Shape работает

    с Shape draw() = 0 area() = 0 moveBy() = 0 дети: Shape Лист Составной Circle Group draw() add() draw(): для всех детей
  48. Компонент class Shape { public: virtual ~Shape() = default; virtual

    void draw() const = 0; virtual double area() const = 0; virtual void moveBy(Point delta) = 0; };
  49. Группа class Group final : public Shape { public: void

    add(std::unique_ptr<Shape> s) { items_.push_back(std::move(s)); } void draw() const override { for (const auto& c : items_) c->draw(); } void moveBy(Point d) override { for (auto& c : items_) c->moveBy(d); } double area() const override { double sum = 0; for (const auto& c : items_) sum += c->area(); // c может быть и группой return sum; } private: std::vector<std::unique_ptr<Shape>> items_; }; // дети: любые Shape
  50. Использование auto face = std::make_unique<Group>(); face->add(std::make_unique<Circle>(50)); face->add(std::make_unique<Circle>(5)); face->add(std::make_unique<Circle>(5)); // голова

    // глаз // глаз Group drawing; drawing.add(std::move(face)); // группа внутри группы drawing.add(std::make_unique<Rectangle>(200, 10)); drawing.moveBy({10, 0}); // сдвинули всё дерево std::cout << drawing.area() << '\n'; // сумма по всему дереву
  51. Где объявить add()? В Shape Только в Group Подход Прозрачность

    Безопасность Плюс Клиент вообще не различает Circle::add() не скомпилируется Минус Circle::add() — ошибка только во время работы Чтобы добавить, нужно знать, что это группа Мы выбрали безопасность: ошибки лучше ловить при компиляции
  52. Итоги: Composite Достоинства Группа и фигура — один интерфейс Вложенность

    любой глубины Новые виды фигур не трогают Group Недостатки Общий интерфейс бывает слишком общим Трудно запретить, например, группу внутри самой себя
  53. Структурный паттерн · 6 / 7 Bridge Мост Разделяет абстракцию

    и реализацию, чтобы они менялись независимо
  54. Задача: рисовать по-разному Экран SVG PDF Круг CircleScreen CircleSvg CirclePdf

    Прямоугольник RectScreen RectSvg RectPdf Треугольник TriScreen TriSvg TriPdf Фигуры × способы рисования: 3 × 3 = 9 классов. Ещё одна фигура — плюс три
  55. Идея: две иерархии и мост между ними Абстракция: ЧТО Реализация:

    КАК мост Shape draw(Renderer&) = 0 Circle Renderer drawCircle() = 0 drawRect() = 0 Rectangle 3 фигуры + 3 способа = 6 классов вместо 9. Новая фигура — один класс Screen Svg
  56. Реализация: как рисовать class Renderer { // реализация: КАК рисовать

    public: virtual ~Renderer() = default; virtual void drawCircle(Point center, double r) = 0; virtual void drawRect(Point a, Point b) = 0; };
  57. Конкретные способы class SvgRenderer final : public Renderer { public:

    void drawCircle(Point c, double r) override { out_ << "<circle cx='" << c.x << "' cy='" << c.y << "' r='" << r << "'/>\n"; } void drawRect(Point a, Point b) override { out_ << "<rect x='" << a.x << "' y='" << a.y << "' width='" << b.x - a.x << "' height='" << b.y - a.y << "'/>\n"; } std::string result() const { return out_.str(); } private: std::ostringstream out_; }; // ScreenRenderer — так же, но рисует на экране
  58. Абстракция: что рисовать class Shape { // абстракция: ЧТО рисовать

    public: virtual ~Shape() = default; virtual void draw(Renderer& out) const = 0; }; class Circle final : public Shape { public: Circle(Point center, double r) : center_(center), r_(r) {} void draw(Renderer& out) const override { out.drawCircle(center_, r_); } private: Point center_; double r_; };
  59. Использование std::vector<std::unique_ptr<Shape>> shapes; shapes.push_back(std::make_unique<Circle>(Point{50, 50}, 30)); shapes.push_back(std::make_unique<Rectangle>(Point{0, 0}, Point{200, 100}));

    ScreenRenderer screen; SvgRenderer svg; for (const auto& shape : shapes) { shape->draw(screen); // на экран shape->draw(svg); // в файл SVG }
  60. Pimpl — мост по-плюсовому Pointer to implementation: класс в заголовке

    хранит только указатель, а все детали спрятаны в .cpp
  61. Pimpl: заголовок // canvas.h class Canvas { public: Canvas(); ~Canvas();

    // объявлен здесь, определён в .cpp Canvas(Canvas&&) noexcept; Canvas& operator=(Canvas&&) noexcept; void add(std::unique_ptr<Shape> shape); void draw(Renderer& renderer) const; private: struct Impl; // только объявление: в заголовке деталей нет std::unique_ptr<Impl> impl_; };
  62. Pimpl: реализация // canvas.cpp struct Canvas::Impl { std::vector<std::unique_ptr<Shape>> shapes; };

    // и любые другие детали Canvas::Canvas() : impl_(std::make_unique<Impl>()) {} Canvas::~Canvas() = default; // здесь Impl уже полный тип Canvas::Canvas(Canvas&&) noexcept = default; Canvas& Canvas::operator=(Canvas&&) noexcept = default; void Canvas::add(std::unique_ptr<Shape> shape) { impl_->shapes.push_back(std::move(shape)); }
  63. Почему деструктор в .cpp? // если оставить ~Canvas() неявным в

    canvas.h: error: invalid application of 'sizeof' to incomplete type 'Canvas::Impl' static_assert(sizeof(_Tp) > 0, "can't delete an incomplete type"); unique_ptr удаляет объект — и должен знать его тип. Полным Impl становится только в .cpp
  64. Зачем нужен Pimpl Сборка Поменяли детали в .cpp — клиенты

    не перекомпилируются ABI Размер класса не меняется: можно обновить библиотеку без пересборки программ Цена Выделение памяти и лишний переход по указателю
  65. Итоги: Bridge Достоинства Фигуры и способы рисования развиваются независимо Классов:

    сумма, а не произведение Недостатки Нужно заранее увидеть два независимых измерения Общий интерфейс Renderer — «общий знаменатель»
  66. Структурный паттерн · 7 / 7 Flyweight Приспособленец Экономит память:

    множество объектов делят общую неизменяемую часть
  67. Задача: тысячи надписей Схема на 10 000 подписей У каждой

    подписи стиль: шрифт, цвет, текстура фона Стилей всего десяток, а текстура весит мегабайты
  68. Стиль struct Style { // тяжёлый объект std::string font; std::uint32_t

    color = 0; std::vector<std::byte> texture; }; // может весить мегабайты
  69. Решение в лоб class Label { public: Label(std::string text, Point

    pos, Style style) : text_(std::move(text)), pos_(pos), style_(std::move(style)) {} private: std::string text_; Point pos_; Style style_; // у каждой надписи своя копия текстуры }; Например, 10 000 надписей × 1 МБ текстуры ≈ 10 ГБ памяти — на десяток одинаковых стилей
  70. Идея: разделить состояние Внутреннее Внешнее Что Стиль: шрифт, цвет, текстура

    Текст и позиция надписи У кого Общее для многих объектов Своё у каждого объекта Можно менять? Нет — его делят многие Да
  71. Кеш стилей class StyleCache { public: std::shared_ptr<const Style> get(const std::string&

    name) { auto& slot = styles_[name]; if (!slot) slot = std::make_shared<const Style>(loadStyle(name)); return slot; } // один раз private: std::unordered_map<std::string, std::shared_ptr<const Style>> styles_; }; Стиль создаётся один раз, дальше все получают тот же объект
  72. Надпись class Label { public: Label(std::string text, Point pos, std::shared_ptr<const

    Style> style) : text_(std::move(text)), pos_(pos), style_(std::move(style)) {} const Style& style() const { return *style_; } private: std::string text_; Point pos_; std::shared_ptr<const Style> style_; }; // своё у каждой надписи // своё у каждой надписи // общее для многих const Style: раз стиль общий, менять его нельзя — иначе изменятся все надписи
  73. Использование StyleCache styles; std::vector<Label> labels; labels.reserve(10'000); for (int i =

    0; i < 10'000; ++i) labels.emplace_back("№" + std::to_string(i), Point{0, i * 20}, styles.get("Заголовок")); // 10 000 надписей, а объект Style — один
  74. Итоги: Flyweight Достоинства Память: десяток стилей вместо десяти тысяч копий

    Общая часть неизменяема — её безопасно делить Недостатки Нужен кеш и ключ для поиска Объект распадается на две части — код сложнее
  75. Ещё паттерн · 1 / 3 Null Object Пустой объект

    Объект, который ничего не делает, вместо nullptr
  76. Решение в лоб: проверки void Editor::onDrag(Point from, Point to) {

    if (tool_) // инструмент может быть не выбран tool_->onDrag(canvas_, from, to); } // такая же проверка — в onPress(), onRelease(), onKey()… Проверка в каждом методе Забыли одну — обращение к nullptr
  77. Пустой инструмент class NullTool final : public Tool { public:

    void onDrag(Canvas&, Point, Point) const override {} }; // ничего не делает
  78. Редактор class Editor { public: void selectTool(std::unique_ptr<Tool> tool) { tool_

    = tool ? std::move(tool) : std::make_unique<NullTool>(); } void onDrag(Point from, Point to) { tool_->onDrag(canvas_, from, to); } // проверка на nullptr не нужна private: Canvas canvas_; std::unique_ptr<Tool> tool_ = std::make_unique<NullTool>(); }; Инструмент есть всегда — просто иногда он ничего не делает
  79. Итоги: Null Object Достоинства Нет проверок на nullptr Поведение «ничего

    не делать» — явное Недостатки Скрывает ошибку, если «ничего» — на самом деле баг Нужен класс на каждый интерфейс
  80. Ещё паттерн · 2 / 3 Object Pool Пул объектов

    Переиспользует дорогие объекты вместо того, чтобы создавать их заново
  81. Задача: буферы для отрисовки Каждый кадр нужен буфер на 4

    МБ Выделять и освобождать память 60 раз в секунду — дорого Буфер после кадра больше не нужен — его можно отдать следующему
  82. Пул буферов class BufferPool { public: struct Return { //

    «удалитель», который возвращает буфер в пул BufferPool* pool; void operator()(Buffer* b) const { pool->release(b); } }; using Handle = std::unique_ptr<Buffer, Return>; explicit BufferPool(std::size_t bufferSize) : size_(bufferSize) {} [[nodiscard]] Handle acquire(); private: void release(Buffer* b) { free_.emplace_back(b); } std::size_t size_; std::vector<std::unique_ptr<Buffer>> free_; };
  83. Взять буфер BufferPool::Handle BufferPool::acquire() { if (free_.empty()) return Handle(new Buffer(size_),

    Return{this}); Buffer* b = free_.back().release(); free_.pop_back(); return Handle(b, Return{this}); } // берём готовый // создаём новый
  84. Использование constexpr std::size_t MiB = std::size_t{1024} * 1024; BufferPool pool(4

    * MiB); // буферы по 4 МБ { auto buffer = pool.acquire(); } auto again = pool.acquire(); // новый буфер // вернулся в пул сам // тот же буфер, без выделения памяти RAII: буфер возвращается в пул сам. Но пул должен жить дольше всех выданных буферов
  85. Итоги: Object Pool Достоинства Нет повторных выделений памяти Предсказуемое время

    работы Недостатки Объекты нужно «очищать» перед повторным использованием Пул должен пережить все выданные объекты Пул может разрастись
  86. Ещё паттерн · 3 / 3 Servant Слуга Общее поведение

    для разных классов живёт отдельно — в «слуге»
  87. Слуга class Movable { // всё, что нужно слуге public:

    virtual ~Movable() = default; virtual Point position() const = 0; virtual void setPosition(Point p) = 0; }; namespace mover { // слуга: поведение отдельно от иерархии фигур inline void moveTo(Movable& obj, Point p) { obj.setPosition(p); } inline void moveBy(Movable& obj, Point d) { const Point p = obj.position(); obj.setPosition({p.x + d.x, p.y + d.y}); } } // namespace mover
  88. Как выбрать Вопрос Паттерн В редакторе Чужой интерфейс не подходит?

    Adapter PolygonShape Подсистема слишком сложная? Facade PngExporter Управлять доступом к объекту? Proxy LazyImage Добавить поведение на лету? Decorator Shadow, Border Группа как один объект? Composite Group Два независимых измерения? Bridge Shape × Renderer Много одинаковых тяжёлых частей? Flyweight StyleCache
  89. Когда паттерн не нужен Свой код с неудобным интерфейсом →

    поправьте интерфейс, а не пишите адаптер Один способ рисования → мост не нужен Сотня объектов → Flyweight не окупится Паттерн — средство, а не цель

More Decks by Baramiya Denis

Other Decks in Programming