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

Lecture №2.9. Design patterns (part 2). Behavio...

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

Lecture №2.9. Design patterns (part 2). Behavioral patterns.

1. Iterator.
2. Command.
3. Template method.
4. State.
5. Strategy.

Baramiya Denis

October 29, 2019

Transcript

104 slides
  1. Поведенческие паттерны: кто что делает и как объекты общаются Порождающие

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

    Как и в прошлый раз: решаем задачу в лоб, находим проблему — и исправляем паттерном
  3. Поведенческий паттерн · 1 / 6 Iterator Итератор Даёт последовательный

    доступ к элементам коллекции, не раскрывая, как она устроена
  4. Решение в лоб class Canvas { public: // ПЛОХО: наружу

    торчит внутреннее устройство std::vector<std::unique_ptr<Shape>>& shapes() { return shapes_; } private: std::vector<std::unique_ptr<Shape>> shapes_; }; for (const auto& shape : canvas.shapes()) shape->draw(); canvas.shapes().clear(); Клиент знает, что внутри vector // а так было можно? Сменили хранилище → правим всех клиентов Можно всё сломать: clear()
  5. Пусть холст выдаёт итератор: «дай текущий» и «перейди к следующему»

    Как устроен контейнер, знает только итератор
  6. Свой итератор class ShapeIterator { public: using value_type = Shape;

    using difference_type = std::ptrdiff_t; ShapeIterator() = default; explicit ShapeIterator(Storage::const_iterator it) : it_(it) {} Shape& operator*() const { return **it_; } Shape* operator->() const { return it_->get(); } ShapeIterator& operator++() { ++it_; return *this; } ShapeIterator operator++(int) { auto old = *this; ++it_; return old; } bool operator==(const ShapeIterator&) const = default; private: Storage::const_iterator it_; };
  7. Холст выдаёт итераторы class Canvas { public: void add(std::unique_ptr<Shape> shape)

    { shapes_.push_back(std::move(shape)); } ShapeIterator begin() const { return ShapeIterator(shapes_.begin()); } ShapeIterator end() const { return ShapeIterator(shapes_.end()); } private: Storage shapes_; }; // можно заменить на list — клиенты не заметят
  8. Использование for (Shape& shape : canvas) shape.draw(); // клиент видит

    Shape&, а не unique_ptr auto selected = std::ranges::count_if( canvas, [](const Shape& s) { return s.selected(); }); Тип хранилища можно поменять — клиентский код не изменится
  9. Ленивый фильтр auto isSelected = [](const Shape& s) { return

    s.selected(); }; for (Shape& shape : canvas | std::views::filter(isSelected)) shape.draw(); // только выделенные, без копии контейнера Фильтр проверяет фигуры по мере движения итератора — копии контейнера нет (C++20 ranges)
  10. Что такое view Лёгкий Обёртка над диапазоном: ничего не копирует

    и ничем не владеет Ленивый Ничего не считает заранее — работа идёт во время обхода Склеиваемый Операции соединяются через | в конвейер
  11. Фильтр ленивый auto view = canvas | std::views::filter([](const Shape& s)

    { std::cout << "проверка\n"; return s.selected(); }); std::cout << "view создан\n"; // ещё ни одной проверки for (Shape& shape : view) shape.draw(); // проверки — по ходу обхода На холсте: Circle, Rectangle (выделен), Circle Вывод: view создан → проверка → проверка → Rectangle → проверка
  12. Как устроен итератор фильтра FilterIterator& operator++() { ++it_; skip(); return

    *this; } void skip() { while (it_ != end_ && !pred_(*it_)) ++it_; // пропускаем неподходящие } Упрощённо: ++ двигает обычный итератор, пока предикат не скажет «да»
  13. Конвейер: фильтр + take auto firstSelected = canvas | std::views::filter(isSelected)

    | std::views::take(1); for (Shape& shape : firstSelected) shape.draw(); // обход остановится // на первой выделенной Лень окупается: после первой выделенной фигуры остальные даже не проверяются
  14. Осторожно: инвалидация for (const auto& shape : canvas) if (shape->selected())

    canvas.add(std::make_unique<Circle>()); push_back перевыделил память → итераторы недействительны // UB! Сначала соберите, что добавить, потом добавляйте
  15. Итоги: Iterator Достоинства Клиент не знает устройство контейнера Один код

    обхода для разных контейнеров Работают алгоритмы STL и ranges Недостатки Свой итератор — много шаблонного кода Изменение контейнера во время обхода ломает итераторы
  16. Поведенческий паттерн · 2 / 6 Command Команда Превращает действие

    в объект: его можно выполнить, отменить и сохранить в историю
  17. Задача: Ctrl+Z и Ctrl+Y Любое действие можно отменить и повторить

    Действия разные: переместить, добавить, удалить…
  18. Решение в лоб: запись о действии enum class ActionType {

    Move, Add, Delete }; struct Action { ActionType type; Shape* shape = nullptr; Point delta; std::unique_ptr<Shape> removed; }; Поля для всех действий сразу // нужно только для Move // нужно только для Delete Новое действие → правим структуру
  19. Решение в лоб: отмена void Editor::undo() { Action& a =

    history_.back(); switch (a.type) { case ActionType::Move: a.shape->moveBy({-a.delta.x, -a.delta.y}); break; case ActionType::Add: canvas_.remove(a.shape); break; case ActionType::Delete: canvas_.add(std::move(a.removed)); break; } history_.pop_back(); } Такой же switch — в redo() Новое действие → правим оба
  20. Идея: действие — это объект Вызывающий Команда History Command execute()

    undo() redo() execute() = 0 undo() = 0 Получатель Canvas хранит выполненные команды MoveCommand AddShapeCommand execute() undo() execute() undo()
  21. Команда class Command { public: virtual ~Command() = default; virtual

    void execute() = 0; virtual void undo() = 0; }; Каждое действие знает, как себя выполнить и как отменить
  22. Первая мысль: хранить Shape* // первая мысль: команда хранит указатель

    на фигуру MoveCommand move(circle, Point{10, 0}); canvas.clear(); move.undo(); // фигуры удалили в обход истории // обращение к мёртвой фигуре — UB Указатель не знает, жив ли объект Компилятор не поможет
  23. Команда хранит id фигуры, а не указатель Нет фигуры —

    понятная ошибка вместо UB. Такую историю можно даже сохранить в файл
  24. Холст: фигуры по id using ShapeId = int; class Canvas

    { public: ShapeId newId() { return nextId_++; } void insert(ShapeId id, std::unique_ptr<Shape> shape); std::unique_ptr<Shape> extract(ShapeId id); // забрать с холста Shape* find(ShapeId id); // nullptr, если нет private: std::map<ShapeId, std::unique_ptr<Shape>> shapes_; ShapeId nextId_ = 0; };
  25. Переместить фигуру class MoveCommand final : public Command { public:

    MoveCommand(Canvas& canvas, ShapeId id, Point delta) : canvas_(&canvas), id_(id), delta_(delta) {} void execute() override { shape().moveBy(delta_); } void undo() override { shape().moveBy({-delta_.x, -delta_.y}); } private: Shape& shape() const; Canvas* canvas_; ShapeId id_; Point delta_; }; // найти фигуру по id // холст живёт дольше истории
  26. Поиск фигуры по id Shape& MoveCommand::shape() const { Shape* s

    = canvas_->find(id_); if (!s) throw std::logic_error("shape not found"); return *s; } // ошибка, а не UB Фигуры нет — исключение с понятным сообщением, а не чтение чужой памяти
  27. Добавить фигуру class AddShapeCommand final : public Command { public:

    AddShapeCommand(Canvas& canvas, std::unique_ptr<Shape> shape) : canvas_(&canvas), id_(canvas.newId()), shape_(std::move(shape)) {} void execute() override { canvas_->insert(id_, std::move(shape_)); } void undo() override { shape_ = canvas_->extract(id_); } ShapeId id() const { return id_; } private: Canvas* canvas_; ShapeId id_; std::unique_ptr<Shape> shape_; }; // владеет, пока фигуры нет на холсте id выдаётся один раз: после undo и redo фигура вернётся с тем же id
  28. История class History { public: void execute(std::unique_ptr<Command> cmd) { cmd->execute();

    done_.push_back(std::move(cmd)); undone_.clear(); // после нового действия redo невозможен } void undo(); void redo(); private: std::vector<std::unique_ptr<Command>> done_; std::vector<std::unique_ptr<Command>> undone_; };
  29. Повтор void History::redo() { if (undone_.empty()) return; undone_.back()->execute(); done_.push_back(std::move(undone_.back())); undone_.pop_back();

    } После нового действия список для redo очищается — как в любом редакторе
  30. Использование auto add = std::make_unique<AddShapeCommand>(canvas, std::make_unique<Circle>()); const ShapeId circle =

    add->id(); history.execute(std::move(add)); history.execute(std::make_unique<MoveCommand>(canvas, circle, Point{10, 0})); history.undo(); history.undo(); history.redo(); // круг вернулся на место // круга нет на холсте // круг снова на холсте — с тем же id
  31. Макрокоманда: одна отмена на всё class MacroCommand final : public

    Command { public: void add(std::unique_ptr<Command> cmd) { commands_.push_back(std::move(cmd)); } void execute() override { for (auto& cmd : commands_) cmd->execute(); } void undo() override { // в обратном порядке! for (auto& cmd : commands_ | std::views::reverse) cmd->undo(); } private: std::vector<std::unique_ptr<Command>> commands_; }; «Выровнять все фигуры» — десятки перемещений, но одна отмена
  32. Итоги: Command Достоинства Отмена и повтор Одно действие — из

    меню, кнопки или по горячей клавише Команды складываются в макросы и журнал Недостатки Класс на каждое действие Нужно аккуратно хранить данные для отмены
  33. Поведенческий паттерн · 3 / 6 Observer Наблюдатель Объект оповещает

    подписчиков о своих изменениях, не зная, кто они
  34. Решение в лоб void Canvas::select(Shape& shape) { selected_ = &shape;

    propertiesPanel_.show(shape); // холст знает про весь интерфейс statusBar_.setText("Выделена 1 фигура"); toolbar_.enableDelete(true); } Холст зависит от всех панелей Новая панель → правим Canvas Холст не проверить без интерфейса
  35. Идея: холст оповещает подписчиков Издатель Canvas subscribe() select() Подписчик список

    SelectionListener onSelectionChanged() = 0 select() вызывает onSelectionChanged() у всех PropertiesPanel StatusBar
  36. Классический Observer: издатель class Canvas { public: void subscribe(SelectionListener* l)

    { listeners_.push_back(l); } void unsubscribe(SelectionListener* l) { std::erase(listeners_, l); } void select(const Shape* shape) { selected_ = shape; for (auto* l : listeners_) l->onSelectionChanged(selected_); } private: std::vector<SelectionListener*> listeners_; const Shape* selected_ = nullptr; }; // не владеет
  37. Проблема: забыли отписаться { } PropertiesPanel panel; canvas.subscribe(&panel); // панель

    уничтожена, но осталась в списке canvas.select(&circle); В списке остался указатель на мёртвый объект // вызов метода мёртвого объекта — UB Следить за отпиской приходится вручную
  38. Идея: сигналы и слоты Слоты Издатель PropertiesPanel::show Canvas сигнал selectionChanged

    connect() StatusBar::update [](const Shape*) { … } Сигнал — событие, о котором можно сообщить. Слот — любая функция, которая на него реагирует. connect() связывает их и возвращает подписку
  39. Что делает std::exchange // так устроен std::exchange (упрощённо) template <class

    T, class U = T> T exchange(T& obj, U&& newValue) { T old = std::move(obj); // запомнили старое obj = std::forward<U>(newValue); // записали новое return old; // вернули старое } Не swap: второй аргумент не меняется. Записали новое — вернули старое
  40. Подписка class Subscription { public: Subscription() = default; explicit Subscription(std::function<void()>

    cancel) : cancel_(std::move(cancel)) {} ~Subscription() { reset(); } void reset() { if (cancel_) std::exchange(cancel_, nullptr)(); } private: std::function<void()> cancel_; }; // отписаться один раз
  41. Подписку можно переместить Subscription::Subscription(Subscription&& other) noexcept : cancel_(std::exchange(other.cancel_, nullptr)) {}

    Subscription& Subscription::operator=(Subscription&& other) noexcept { if (this != &other) { reset(); // старую подписку отменяем cancel_ = std::exchange(other.cancel_, nullptr); } return *this; } Копировать нельзя: отписаться можно только один раз
  42. Сигнал template <class... Args> class Signal { public: using Slot

    = std::function<void(Args...)>; [[nodiscard]] Subscription connect(Slot slot); void emit(Args... args) const; private: using Slots = std::map<int, Slot>; std::shared_ptr<Slots> slots_ = std::make_shared<Slots>(); int nextId_ = 0; };
  43. Сигнал: подписка template <class... Args> Subscription Signal<Args...>::connect(Slot slot) { const

    int id = nextId_++; slots_->emplace(id, std::move(slot)); return Subscription([weak = std::weak_ptr(slots_), id] { if (auto slots = weak.lock()) // сигнал ещё жив? slots->erase(id); }); }
  44. Сигнал: оповещение template <class... Args> void Signal<Args...>::emit(Args... args) const {

    const auto copy = *slots_; // снимок списка подписчиков for (const auto& [id, slot] : copy) slot(args...); } Обходим снимок списка — зачем, на следующем слайде
  45. Зачем копия: отписка из обработчика Subscription once; once = canvas.selectionChanged().connect([&once](const

    Shape*) { std::cout << "первое выделение\n"; once.reset(); // отписались прямо во время emit() }); canvas.select(&circle); canvas.select(&rect); reset() удаляет слот из map // сработает // уже нет Без копии emit() обходит тот же map — итератор на удалённый элемент → UB
  46. Холст class Canvas { public: Signal<const Shape*>& selectionChanged() { return

    selectionChanged_; } void select(const Shape* shape) { selected_ = shape; selectionChanged_.emit(selected_); } private: Signal<const Shape*> selectionChanged_; const Shape* selected_ = nullptr; }; // холст не знает, кто слушает
  47. Панель свойств class PropertiesPanel { public: explicit PropertiesPanel(Canvas& canvas) :

    sub_(canvas.selectionChanged().connect( [this](const Shape* s) { show(s); })) {} private: void show(const Shape* s) const; Subscription sub_; }; // панель уничтожена → отписалась сама
  48. Использование Canvas canvas; auto status = canvas.selectionChanged().connect([](const Shape* s) {

    std::cout << "status: " << (s ? s->name() : "none") << '\n'; }); { PropertiesPanel panel(canvas); canvas.select(&circle); // сработают оба подписчика } canvas.select(&rect); // только строка состояния
  49. Итоги: Observer Достоинства Недостатки Издатель не знает подписчиков Новых подписчиков

    добавляем, не меняя холст Порядок оповещения не гарантирован Без RAII — висячие подписки Трудно проследить, кто кого вызвал Готовые реализации: сигналы и слоты в Qt, boost::signals2
  50. Поведенческий паттерн · 4 / 6 Template Method Шаблонный метод

    Задаёт скелет алгоритма в базовом классе, а отдельные шаги — в наследниках
  51. Задача: отчёт о фигурах CSV — открыть в Excel HTML

    — показать в браузере Скрытые фигуры: в CSV нужны, в HTML — нет
  52. Решение в лоб void exportCsv(const Canvas& canvas, std::ostream& out) {

    out << "name,x,y\n"; for (const Shape& s : canvas) // все фигуры out << s.name() << ',' << s.position().x << ',' << s.position().y << '\n'; } void exportHtml(const Canvas& canvas, std::ostream& out) { out << "<table>\n"; for (const Shape& s : canvas) if (s.visible()) // только видимые out << "<tr><td>" << s.name() << "</td><td>" << s.position().x << "</td><td>" << s.position().y << "</td></tr>\n"; out << "</table>\n"; } Схема «заголовок → обход → концовка» скопирована в каждый формат
  53. Идея: общий скелет, разные шаги ReportExporter exportTo() ← шаблонный метод

    writeHeader() = 0 writeRow() = 0 writeFooter() ← хук includeHidden() ← хук CsvExporter HtmlExporter writeHeader() writeRow() includeHidden() writeHeader() writeRow() writeFooter()
  54. Шаблонный метод class ReportExporter { public: virtual ~ReportExporter() = default;

    void exportTo(const Canvas& canvas, std::ostream& out) const { writeHeader(out); for (const Shape& shape : canvas) if (shape.visible() || includeHidden()) writeRow(out, shape); writeFooter(out); } private: virtual virtual virtual virtual }; void void void bool writeHeader(std::ostream& out) const = 0; writeRow(std::ostream& out, const Shape& s) const = 0; writeFooter(std::ostream&) const {} // хук includeHidden() const { return false; } // хук
  55. Шаги и хуки =0 Обязательный шаг: наследник должен его реализовать

    {} Хук: можно переопределить, а можно оставить как есть private Наследник переопределяет шаги, но вызывает их только база
  56. CSV class CsvExporter final : public ReportExporter { void writeHeader(std::ostream&

    out) const override { out << "name,x,y\n"; } void writeRow(std::ostream& out, const Shape& s) const override { out << s.name() << ',' << s.position().x << ',' << s.position().y << '\n'; } bool includeHidden() const override { return true; } }; // в данные — всё
  57. HTML class HtmlExporter final : public ReportExporter { void writeHeader(std::ostream&

    out) const override { out << "<table>\n"; } void writeRow(std::ostream& out, const Shape& s) const override { out << "<tr><td>" << s.name() << "</td><td>" << s.position().x << "</td><td>" << s.position().y << "</td></tr>\n"; } void writeFooter(std::ostream& out) const override { out << "</table>\n"; } };
  58. Использование std::unique_ptr<ReportExporter> exporter = std::make_unique<CsvExporter>(); exporter->exportTo(canvas, std::cout); // name,x,y /

    circle,10,20 / rect,50,60 exporter = std::make_unique<HtmlExporter>(); exporter->exportTo(canvas, std::cout); // <table> … </table>, без скрытых
  59. «Не звоните нам — мы вам позвоним» Голливудский принцип: базовый

    класс сам вызывает шаги наследника, а не наоборот
  60. Помните Tool::onDrag()? Это уже был Template Method Factory Method —

    частный случай: один из шагов алгоритма создаёт объект
  61. Итоги: Template Method Достоинства Общий алгоритм — в одном месте

    Наследник пишет только отличия Недостатки Скелет алгоритма жёстко зафиксирован Шаги выбираются наследованием — не поменять во время работы Наследник может нарушить ожидания базы (LSP)
  62. Поведенческий паттерн · 5 / 6 Strategy Стратегия Набор взаимозаменяемых

    алгоритмов: клиент выбирает нужный, не меняя свой код
  63. Задача: привязка при перемещении Без привязки, к сетке, к другим

    фигурам Пользователь переключает режим в любой момент
  64. Решение в лоб Point MoveTool::snap(Point p) const { switch (mode_)

    { case SnapMode::None: return p; case SnapMode::Grid: return {roundTo(p.x, gridStep_), roundTo(p.y, gridStep_)}; // case SnapMode::Shapes: ещё 30 строк поиска ближайшей фигуры } return p; } Все алгоритмы в одном классе Поля для всех режимов сразу Новый режим → правим MoveTool
  65. Идея: алгоритм — отдельный объект Контекст Стратегия MoveTool SnapStrategy onDrag()

    setSnap() snap() = 0 стратегию можно заменить во время работы NoSnap GridSnap snap() snap()
  66. Стратегия class SnapStrategy { public: virtual ~SnapStrategy() = default; virtual

    Point snap(Point p) const = 0; }; class NoSnap final : public SnapStrategy { public: Point snap(Point p) const override { return p; } };
  67. Привязка к сетке class GridSnap final : public SnapStrategy {

    public: explicit GridSnap(int step) : step_(step) {} Point snap(Point p) const override { return {roundTo(p.x, step_), roundTo(p.y, step_)}; } private: int step_; };
  68. Инструмент class MoveTool { public: explicit MoveTool(std::unique_ptr<SnapStrategy> snap) : snap_(std::move(snap))

    {} void setSnap(std::unique_ptr<SnapStrategy> snap) { snap_ = std::move(snap); } void onDrag(Shape& shape, Point mouse) const { shape.moveTo(snap_->snap(mouse)); } private: std::unique_ptr<SnapStrategy> snap_; };
  69. Почему не наследовать MoveTool? Не переключить GridMoveTool не станет NoSnapMoveTool

    во время работы Взрыв классов Привязка × границы × курсоры — класс на каждое сочетание Смешение Алгоритм привязки перемешан с логикой инструмента
  70. Стратегия-функция using SnapFn = std::function<Point(Point)>; class MoveTool { public: explicit

    MoveTool(SnapFn snap) : snap_(std::move(snap)) {} void onDrag(Shape& shape, Point mouse) const { shape.moveTo(snap_(mouse)); } private: SnapFn snap_; }; Если у стратегии один метод — хватит std::function и лямбды
  71. Стратегия при компиляции Стратегия — параметр шаблона, а не объект

    с virtual Компилятор встраивает вызов: накладных расходов нет Policy-based design — А. Александреску, «Современное проектирование на C++»
  72. Политики struct NoSnap { Point snap(Point p) const { return

    p; } }; struct Grid10 { Point snap(Point p) const { return {roundTo(p.x, 10), roundTo(p.y, 10)}; } }; struct Unbounded { Point clamp(Point p) const { return p; } }; struct InsideCanvas { Point clamp(Point p) const { return {std::clamp(p.x, 0, 1920), std::clamp(p.y, 0, 1080)}; } };
  73. Инструмент с политиками template <class SnapPolicy, class BoundsPolicy> class MoveTool

    { public: void onDrag(Shape& shape, Point mouse) const { shape.moveTo(bounds_.clamp(snap_.snap(mouse))); } private: SnapPolicy snap_; BoundsPolicy bounds_; }; using FreeMove = MoveTool<NoSnap, Unbounded>; using PreciseMove = MoveTool<Grid10, InsideCanvas>; Две независимые политики: 2 × 2 сочетания без четырёх классов
  74. Политики: использование policy::FreeMove freeMove; policy::PreciseMove preciseMove; freeMove.onDrag(shape, {2003, 27}); preciseMove.onDrag(shape,

    {2003, 27}); // (2003, 27) // (1920, 30): сетка, затем границы FreeMove и PreciseMove — разные типы: в один контейнер их не положить
  75. Стратегии в STL std::ranges::sort(sizes, std::greater{}); // стратегия сравнения std::set<std::string, CaseInsensitiveLess>

    names; names.insert("Circle"); names.insert("circle"); // стратегия — параметр шаблона // не добавится: «равны» Компараторы, хеш-функции, аллокаторы — это стратегии-параметры
  76. Template Method или Strategy Template Method Strategy Механизм Наследование Композиция

    Что меняется Отдельные шаги Весь алгоритм Когда выбирается При создании объекта В любой момент (или при компиляции) В редакторе ReportExporter SnapStrategy
  77. Итоги: Strategy Достоинства Алгоритмы отделены от клиента Можно переключать во

    время работы Новый алгоритм — новый класс или лямбда Недостатки Клиент должен знать, какие стратегии есть Политики-шаблоны: выбор только при компиляции
  78. Поведенческий паттерн · 6 / 6 State Состояние Объект меняет

    поведение вместе со своим состоянием — будто меняет класс
  79. Задача: поведение документа Изменить Сохранить Закрыть Сохранён → Изменён ничего

    закрыть Изменён ничего записать → Сохранён «Сохранить?», закрыть Только чтение ошибка ошибка закрыть Одно и то же действие ведёт себя по-разному в зависимости от состояния
  80. Решение в лоб enum class DocState { Saved, Modified, ReadOnly

    }; void Document::edit() { switch (state_) { case DocState::Saved: state_ = DocState::Modified; break; case DocState::Modified: break; case DocState::ReadOnly: std::cout << "Только для чтения\n"; break; } } // save() и close() — такие же switch: 3 состояния × 3 события Такой switch — в каждом методе Новое состояние → правим все методы
  81. Идея: состояние — отдельный объект Контекст Состояние Document DocumentState edit()

    save() close() edit() = 0 save() = 0 close() = 0 Document передаёт события текущему состоянию Saved Modified ReadOnly
  82. Состояние class DocumentState { public: using Next = std::unique_ptr<DocumentState>; //

    nullptr — остаёмся virtual ~DocumentState() = default; [[nodiscard]] virtual Next edit(Document& doc) = 0; [[nodiscard]] virtual Next save(Document& doc) = 0; [[nodiscard]] virtual Next close(Document& doc) = 0; };
  83. Документ class Document { public: Document() : state_(std::make_unique<SavedState>()) {} void

    edit() { apply(state_->edit(*this)); } void save() { apply(state_->save(*this)); } void close() { apply(state_->close(*this)); } void writeToDisk(); // действия, которые вызывают состояния void closeWindow(); bool askSaveChanges() const; private: void apply(DocumentState::Next next); std::unique_ptr<DocumentState> state_; };
  84. Состояние «Сохранён» auto SavedState::edit(Document&) -> Next { return std::make_unique<ModifiedState>(); }

    auto SavedState::save(Document&) -> Next { return nullptr; // уже сохранён — ничего не делаем } auto SavedState::close(Document& doc) -> Next { doc.closeWindow(); return nullptr; }
  85. Состояние «Изменён» auto ModifiedState::edit(Document&) -> Next { return nullptr; //

    уже изменён } auto ModifiedState::save(Document& doc) -> Next { doc.writeToDisk(); return std::make_unique<SavedState>(); } auto ModifiedState::close(Document& doc) -> Next { if (doc.askSaveChanges()) doc.writeToDisk(); doc.closeWindow(); return nullptr; }
  86. Почему не setState() изнутри? void ModifiedState::save(Document& doc) { doc.writeToDisk(); doc.setState(std::make_unique<SavedState>());

    log("saved"); // UB: объекта уже нет } // удалил *this setState() удалил объект, чей метод ещё выполняется
  87. Решение: вернуть следующее состояние void Document::apply(DocumentState::Next next) { if (next)

    state_ = std::move(next); // старое состояние уже отработало } Состояние только решает, куда перейти. Заменяет его документ — когда метод уже завершился
  88. Использование Document doc; doc.save(); // Saved: ничего не происходит doc.edit();

    // Saved → Modified doc.close(); // «Сохранить изменения?» → сохранили, закрыли
  89. std::variant: одно из нескольких std::variant<int, std::string> value = 42; value

    = std::string("text"); value.index(); std::get<std::string>(value); std::get<int>(value); // либо int, либо string // теперь внутри string // 1 — номер типа, который сейчас внутри // "text" // исключение std::bad_variant_access Как union, но помнит, какой тип сейчас внутри, и не даёт прочитать не тот
  90. std::visit: перегрузка по типу struct OnInt { void operator()(int) const

    { std::cout << "int\n"; } }; struct OnString { void operator()(const std::string&) const { std::cout << "string\n"; } }; struct Handler : OnInt, OnString { using OnInt::operator(); // без using вызов неоднозначен: using OnString::operator(); // одно имя пришло из двух баз }; std::visit(Handler{}, value); // перегрузка — по типу внутри value
  91. overloaded: то же для любых лямбд template <class... Fs> struct

    overloaded : Fs... { using Fs::operator()...; }; // Fs... — любое число типов // наследуемся от каждого // и для каждого пишем using std::visit(overloaded{ [](int x) { std::cout << "int " << x << '\n'; }, [](const std::string& s) { std::cout << "string " << s << '\n'; }, }, value); Лямбда — объект безымянного класса с operator(), поэтому от неё можно наследоваться
  92. State на std::variant struct Saved {}; struct Modified {}; struct

    ReadOnly {}; using State = std::variant<Saved, Modified, ReadOnly>; State onEdit(const State& state) { return std::visit(overloaded{ [](Saved) -> State { return Modified{}; }, [](Modified) -> State { return Modified{}; }, [](ReadOnly) -> State { std::cout << "Только чтение\n"; return ReadOnly{}; }, }, state); } Состояние — значение, не объект в куче. Пропустили случай — не скомпилируется
  93. State или Strategy Strategy State Кто меняет Клиент снаружи Само

    состояние изнутри Знают друг о друге Нет Да: решают, кто следующий В редакторе NoSnap ↔ GridSnap Saved → Modified Устроены одинаково, а различаются тем, кто и почему делает замену
  94. Итоги: State Достоинства Нет switch по состояниям Правила одного состояния

    — в одном классе Новое состояние — новый класс Недостатки Много маленьких классов Состояния знают друг о друге
  95. Как выбрать Вопрос Паттерн В редакторе Обойти коллекцию, не зная

    её устройства? Iterator Canvas::begin() Действие нужно отменять и повторять? Command History Оповестить других об изменении? Observer selectionChanged() Алгоритм общий, отличаются шаги? Template Method ReportExporter Менять алгоритм на лету? Strategy SnapStrategy Поведение зависит от состояния? State DocumentState
  96. Когда паттерн не нужен Обычный цикл по vector → свой

    итератор не нужен Действие без отмены → команда не нужна Два варианта, которые никогда не меняются → хватит if Паттерн — средство, а не цель

More Decks by Baramiya Denis

Other Decks in Programming