Share
Embed
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
-
Структурные паттерны: как собрать из объектов более крупную структуру Обёртки,
группы, мосты между интерфейсами — и всё это так, чтобы клиентский код не менялся -
Продолжаем графический редактор Мой редактор — рисунок.svg Выделение Прямоугольник Круг
Как и раньше: решаем задачу в лоб, находим проблему — и исправляем паттерном -
Структурный паттерн · 1 / 7 Adapter Адаптер Превращает интерфейс
чужого класса в тот, который ждёт наш код -
Задача: чужая геометрия Готовая библиотека хранит многоугольники и считает их
площадь Но у неё свои типы и имена: geo::Vec2, area_and_perimeter() Рисует редактор сам — библиотека ничего не рисует Менять библиотеку нельзя — это чужой код -
Наш интерфейс class Shape { public: virtual ~Shape() = default;
virtual void draw() const = 0; virtual double area() const = 0; }; Весь редактор работает с Shape: рисует, считает площадь, сохраняет -
Интерфейс библиотеки 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 Площадь — через выходные параметры -
Решение в лоб 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); } Перевод чужих типов — в каждом клиенте Свои и чужие фигуры не лежат в одном контейнере -
Идея: обёртка с нашим интерфейсом Клиент Ожидаемый интерфейс Редактор Shape
вызывает draw() draw() = 0 area() = 0 Адаптер Чужой класс PolygonShape geo::Polygon draw() area() vertices() area_and_perimeter() draw(): вершины Vec2 → Point → drawPolyline() -
Адаптер объекта 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_; }; // адаптер владеет объектом библиотеки -
Адаптер переводит 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; } // чужой интерфейс → наш Вся «переводческая» работа — в одном месте -
Использование 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'; } Библиотека и редактор ничего не знают друг о друге — их связывает адаптер -
Адаптер класса 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_. -
Адаптер объекта или класса Адаптер объекта Адаптер класса Как Хранит
объект в поле private-наследование Адаптирует Класс и всех его наследников Только один класс Может переопределить Нет Виртуальные методы чужого класса Обычно выбирают Да — композиция гибче Когда нужно переопределение -
Адаптеры в 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; }); Так их и называют в стандарте: адаптеры контейнеров, итераторов и диапазонов -
Итоги: Adapter Достоинства Чужой код работает с нашим, без правок
Вся «переводческая» логика — в одном классе Недостатки Ещё один слой и класс на каждую библиотеку Не всё переводится один в один -
Структурный паттерн · 2 / 7 Facade Фасад Даёт простой
интерфейс к сложной подсистеме -
Задача: сохранить рисунок в PNG Отрисовать в картинку, сжать, добавить
метаданные, записать файл Это четыре разных класса со своими настройками Сохранять PNG нужно из меню, из экспорта и из автосохранения -
Решение в лоб // каждый, кому нужен 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); Клиент знает все классы подсистемы Порядок шагов повторяется везде -
Идея: одна дверь в подсистему Подсистема Rasterizer Клиенты Меню, экспорт,
автосохра нение Фасад PngEncoder PngExporter exportTo() MetadataWriter FileWriter -
Фасад 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; }; -
Использование PngExporter exporter; exporter.exportTo(canvas, "logo.png"); // одна строка вместо десяти
exporter.setDpi(72); exporter.exportTo(canvas, "preview.png"); Подсистема никуда не делась: если нужна тонкая настройка, её классы можно вызвать напрямую -
Итоги: Facade Достоинства Клиенты не зависят от устройства подсистемы Типичный
сценарий — одной строкой Недостатки Фасад легко раздуть до «класса, который знает всё» Редкие сценарии всё равно требуют подсистемы -
Структурный паттерн · 3 / 7 Proxy Заместитель Подставной объект
с тем же интерфейсом, который управляет доступом к настоящему -
Задача: большие фотографии В документе сотня фотографий по 50 МБ
При открытии нужно только разложить их по странице — нужны размеры Загружать все пиксели сразу — долго и дорого -
Изображение 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; }; // читает весь файл: долго -
Идея: заместитель с тем же интерфейсом Клиент Интерфейс Документ Image
size() draw() size() = 0 draw() = 0 Заместитель Настоящий объект LazyImage RealImage size(): из заголовка draw(): загрузить и нарисовать создаёт size() draw() -
Ленивая загрузка 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-методе -
const-метод меняет поле? mutable Кеш — не часть наблюдаемого состояния:
для клиента картинка та же Потоки Два потока вызвали draw() одновременно — гонка. Нужен mutex или std::call_once -
Использование 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(); // быстро // раскладка: нужны только размеры // загрузится только первая фотография Документ открылся сразу: прочитаны только заголовки файлов -
Защищающий заместитель 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 — но редактировать нельзя -
Виды заместителей Виртуальный Создаёт дорогой объект только тогда, когда он
нужен Защищающий Проверяет права перед вызовом Удалённый Скрывает, что объект в другом процессе или на сервере Умный указатель unique_ptr и shared_ptr: operator-> ведёт к объекту и управляет его временем жизни -
Итоги: Proxy Достоинства Клиент не замечает подмены Ленивая загрузка, проверка
прав, кеш — без правок в настоящем классе Недостатки Задержка переезжает в неожиданный момент: первый draw() Ещё один слой косвенности -
Структурный паттерн · 4 / 7 Decorator Декоратор Добавляет объекту
новое поведение, оборачивая его, — без наследования -
Задача: тень и рамка Любой фигуре можно включить тень, рамку,
прозрачность В любых сочетаниях — и даже две рамки Включать и выключать прямо во время работы -
Решение в лоб: наследование class ShadowCircle : public Circle {};
class BorderCircle : public Circle {}; class ShadowBorderCircle : public Circle {}; class ShadowRectangle : public Rectangle {}; class BorderRectangle : public Rectangle {}; class ShadowBorderRectangle : public Rectangle {}; // + прозрачность: каждая новая настройка удваивает число классов Взрыв классов Эффект нельзя добавить к уже созданной фигуре -
Идея: обёртки, вложенные друг в друга снаружи внутри Border 4px
Border 2px Shadow Circle draw() draw() draw() draw() У каждой обёртки тот же интерфейс Shape. Она делает своё и передаёт вызов внутрь -
Базовый декоратор 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 -
Тень class Shadow final : public ShapeDecorator { public: using
ShapeDecorator::ShapeDecorator; void draw() const override { std::cout << "тень\n"; // до фигуры ShapeDecorator::draw(); } }; -
Рамка 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_; }; // после фигуры -
Использование 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 Порядок обёрток важен: внешняя рамка рисуется последней -
Осторожно: тип скрыт auto* circle = dynamic_cast<Circle*>(logo.get()); // nullptr! //
снаружи это Border, а не Circle: декоратор прячет настоящий тип Код, который проверяет конкретный тип, перестанет работать с обёрнутыми объектами -
Adapter, Proxy, Decorator Интерфейс Зачем Adapter Меняет на нужный Подружить
несовместимые классы Proxy Тот же Управлять доступом: когда и кому Decorator Тот же Добавить поведение Все три — обёртки. Различаются целью -
Итоги: Decorator Достоинства Поведение добавляется во время работы Любые сочетания
без новых классов Недостатки Много маленьких объектов-обёрток Настоящий тип объекта скрыт Важен порядок обёрток -
Структурный паттерн · 5 / 7 Composite Компоновщик Собирает объекты
в дерево и позволяет работать с группой так же, как с одним объектом -
Задача: группы фигур Выделили несколько фигур, нажали Ctrl+G — получилась
группа Группу можно двигать, рисовать, считать площадь — как одну фигуру Группы бывают вложенными -
Решение в лоб 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: в холст её не положить Обход дерева — в каждой операции Фигуры и группы порознь — порядок потерян -
Идея: группа — тоже фигура Клиент Компонент Редактор Shape работает
с Shape draw() = 0 area() = 0 moveBy() = 0 дети: Shape Лист Составной Circle Group draw() add() draw(): для всех детей -
Компонент class Shape { public: virtual ~Shape() = default; virtual
void draw() const = 0; virtual double area() const = 0; virtual void moveBy(Point delta) = 0; }; -
Группа 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 -
Использование 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'; // сумма по всему дереву -
Где объявить add()? В Shape Только в Group Подход Прозрачность
Безопасность Плюс Клиент вообще не различает Circle::add() не скомпилируется Минус Circle::add() — ошибка только во время работы Чтобы добавить, нужно знать, что это группа Мы выбрали безопасность: ошибки лучше ловить при компиляции -
Итоги: Composite Достоинства Группа и фигура — один интерфейс Вложенность
любой глубины Новые виды фигур не трогают Group Недостатки Общий интерфейс бывает слишком общим Трудно запретить, например, группу внутри самой себя -
Структурный паттерн · 6 / 7 Bridge Мост Разделяет абстракцию
и реализацию, чтобы они менялись независимо -
Задача: рисовать по-разному Экран SVG PDF Круг CircleScreen CircleSvg CirclePdf
Прямоугольник RectScreen RectSvg RectPdf Треугольник TriScreen TriSvg TriPdf Фигуры × способы рисования: 3 × 3 = 9 классов. Ещё одна фигура — плюс три -
Идея: две иерархии и мост между ними Абстракция: ЧТО Реализация:
КАК мост Shape draw(Renderer&) = 0 Circle Renderer drawCircle() = 0 drawRect() = 0 Rectangle 3 фигуры + 3 способа = 6 классов вместо 9. Новая фигура — один класс Screen Svg -
Реализация: как рисовать class Renderer { // реализация: КАК рисовать
public: virtual ~Renderer() = default; virtual void drawCircle(Point center, double r) = 0; virtual void drawRect(Point a, Point b) = 0; }; -
Конкретные способы 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 — так же, но рисует на экране -
Абстракция: что рисовать 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_; }; -
Использование 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 } -
Pimpl — мост по-плюсовому Pointer to implementation: класс в заголовке
хранит только указатель, а все детали спрятаны в .cpp -
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_; }; -
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)); } -
Почему деструктор в .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 -
Зачем нужен Pimpl Сборка Поменяли детали в .cpp — клиенты
не перекомпилируются ABI Размер класса не меняется: можно обновить библиотеку без пересборки программ Цена Выделение памяти и лишний переход по указателю -
Итоги: Bridge Достоинства Фигуры и способы рисования развиваются независимо Классов:
сумма, а не произведение Недостатки Нужно заранее увидеть два независимых измерения Общий интерфейс Renderer — «общий знаменатель» -
Структурный паттерн · 7 / 7 Flyweight Приспособленец Экономит память:
множество объектов делят общую неизменяемую часть -
Задача: тысячи надписей Схема на 10 000 подписей У каждой
подписи стиль: шрифт, цвет, текстура фона Стилей всего десяток, а текстура весит мегабайты -
Стиль struct Style { // тяжёлый объект std::string font; std::uint32_t
color = 0; std::vector<std::byte> texture; }; // может весить мегабайты -
Решение в лоб 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 ГБ памяти — на десяток одинаковых стилей -
Идея: разделить состояние Внутреннее Внешнее Что Стиль: шрифт, цвет, текстура
Текст и позиция надписи У кого Общее для многих объектов Своё у каждого объекта Можно менять? Нет — его делят многие Да -
Кеш стилей 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_; }; Стиль создаётся один раз, дальше все получают тот же объект -
Надпись 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: раз стиль общий, менять его нельзя — иначе изменятся все надписи -
Использование 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 — один -
Итоги: Flyweight Достоинства Память: десяток стилей вместо десяти тысяч копий
Общая часть неизменяема — её безопасно делить Недостатки Нужен кеш и ключ для поиска Объект распадается на две части — код сложнее -
Ещё паттерн · 1 / 3 Null Object Пустой объект
Объект, который ничего не делает, вместо nullptr -
Решение в лоб: проверки void Editor::onDrag(Point from, Point to) {
if (tool_) // инструмент может быть не выбран tool_->onDrag(canvas_, from, to); } // такая же проверка — в onPress(), onRelease(), onKey()… Проверка в каждом методе Забыли одну — обращение к nullptr -
Пустой инструмент class NullTool final : public Tool { public:
void onDrag(Canvas&, Point, Point) const override {} }; // ничего не делает -
Редактор 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>(); }; Инструмент есть всегда — просто иногда он ничего не делает -
Итоги: Null Object Достоинства Нет проверок на nullptr Поведение «ничего
не делать» — явное Недостатки Скрывает ошибку, если «ничего» — на самом деле баг Нужен класс на каждый интерфейс -
Ещё паттерн · 2 / 3 Object Pool Пул объектов
Переиспользует дорогие объекты вместо того, чтобы создавать их заново -
Задача: буферы для отрисовки Каждый кадр нужен буфер на 4
МБ Выделять и освобождать память 60 раз в секунду — дорого Буфер после кадра больше не нужен — его можно отдать следующему -
Пул буферов 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_; }; -
Взять буфер 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}); } // берём готовый // создаём новый -
Использование constexpr std::size_t MiB = std::size_t{1024} * 1024; BufferPool pool(4
* MiB); // буферы по 4 МБ { auto buffer = pool.acquire(); } auto again = pool.acquire(); // новый буфер // вернулся в пул сам // тот же буфер, без выделения памяти RAII: буфер возвращается в пул сам. Но пул должен жить дольше всех выданных буферов -
Итоги: Object Pool Достоинства Нет повторных выделений памяти Предсказуемое время
работы Недостатки Объекты нужно «очищать» перед повторным использованием Пул должен пережить все выданные объекты Пул может разрастись -
Ещё паттерн · 3 / 3 Servant Слуга Общее поведение
для разных классов живёт отдельно — в «слуге» -
Слуга 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 -
Как выбрать Вопрос Паттерн В редакторе Чужой интерфейс не подходит?
Adapter PolygonShape Подсистема слишком сложная? Facade PngExporter Управлять доступом к объекту? Proxy LazyImage Добавить поведение на лету? Decorator Shadow, Border Группа как один объект? Composite Group Два независимых измерения? Bridge Shape × Renderer Много одинаковых тяжёлых частей? Flyweight StyleCache -
Когда паттерн не нужен Свой код с неудобным интерфейсом →
поправьте интерфейс, а не пишите адаптер Один способ рисования → мост не нужен Сотня объектов → Flyweight не окупится Паттерн — средство, а не цель