Share
Embed
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
-
Поведенческие паттерны: кто что делает и как объекты общаются Порождающие
отвечали на вопрос «как создать объект». Теперь — как распределить обязанности -
Продолжаем графический редактор Мой редактор — рисунок.svg Выделение Прямоугольник Круг
Как и в прошлый раз: решаем задачу в лоб, находим проблему — и исправляем паттерном -
Поведенческий паттерн · 1 / 6 Iterator Итератор Даёт последовательный
доступ к элементам коллекции, не раскрывая, как она устроена -
Задача: обойти все фигуры Нарисовать каждую фигуру, посчитать выделенные, экспортировать
Как холст хранит фигуры — клиенту знать не нужно -
Решение в лоб 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() -
Пусть холст выдаёт итератор: «дай текущий» и «перейди к следующему»
Как устроен контейнер, знает только итератор -
Свой итератор 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_; }; -
Холст выдаёт итераторы 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 — клиенты не заметят -
Использование for (Shape& shape : canvas) shape.draw(); // клиент видит
Shape&, а не unique_ptr auto selected = std::ranges::count_if( canvas, [](const Shape& s) { return s.selected(); }); Тип хранилища можно поменять — клиентский код не изменится -
Ленивый фильтр auto isSelected = [](const Shape& s) { return
s.selected(); }; for (Shape& shape : canvas | std::views::filter(isSelected)) shape.draw(); // только выделенные, без копии контейнера Фильтр проверяет фигуры по мере движения итератора — копии контейнера нет (C++20 ranges) -
Что такое view Лёгкий Обёртка над диапазоном: ничего не копирует
и ничем не владеет Ленивый Ничего не считает заранее — работа идёт во время обхода Склеиваемый Операции соединяются через | в конвейер -
Фильтр ленивый 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 → проверка -
Как устроен итератор фильтра FilterIterator& operator++() { ++it_; skip(); return
*this; } void skip() { while (it_ != end_ && !pred_(*it_)) ++it_; // пропускаем неподходящие } Упрощённо: ++ двигает обычный итератор, пока предикат не скажет «да» -
Конвейер: фильтр + take auto firstSelected = canvas | std::views::filter(isSelected)
| std::views::take(1); for (Shape& shape : firstSelected) shape.draw(); // обход остановится // на первой выделенной Лень окупается: после первой выделенной фигуры остальные даже не проверяются -
Осторожно: инвалидация for (const auto& shape : canvas) if (shape->selected())
canvas.add(std::make_unique<Circle>()); push_back перевыделил память → итераторы недействительны // UB! Сначала соберите, что добавить, потом добавляйте -
Итоги: Iterator Достоинства Клиент не знает устройство контейнера Один код
обхода для разных контейнеров Работают алгоритмы STL и ranges Недостатки Свой итератор — много шаблонного кода Изменение контейнера во время обхода ломает итераторы -
Поведенческий паттерн · 2 / 6 Command Команда Превращает действие
в объект: его можно выполнить, отменить и сохранить в историю -
Задача: Ctrl+Z и Ctrl+Y Любое действие можно отменить и повторить
Действия разные: переместить, добавить, удалить… -
Решение в лоб: запись о действии enum class ActionType {
Move, Add, Delete }; struct Action { ActionType type; Shape* shape = nullptr; Point delta; std::unique_ptr<Shape> removed; }; Поля для всех действий сразу // нужно только для Move // нужно только для Delete Новое действие → правим структуру -
Решение в лоб: отмена 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() Новое действие → правим оба -
Идея: действие — это объект Вызывающий Команда History Command execute()
undo() redo() execute() = 0 undo() = 0 Получатель Canvas хранит выполненные команды MoveCommand AddShapeCommand execute() undo() execute() undo() -
Команда class Command { public: virtual ~Command() = default; virtual
void execute() = 0; virtual void undo() = 0; }; Каждое действие знает, как себя выполнить и как отменить -
Первая мысль: хранить Shape* // первая мысль: команда хранит указатель
на фигуру MoveCommand move(circle, Point{10, 0}); canvas.clear(); move.undo(); // фигуры удалили в обход истории // обращение к мёртвой фигуре — UB Указатель не знает, жив ли объект Компилятор не поможет -
Команда хранит id фигуры, а не указатель Нет фигуры —
понятная ошибка вместо UB. Такую историю можно даже сохранить в файл -
Холст: фигуры по 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; }; -
Переместить фигуру 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 // холст живёт дольше истории -
Поиск фигуры по id Shape& MoveCommand::shape() const { Shape* s
= canvas_->find(id_); if (!s) throw std::logic_error("shape not found"); return *s; } // ошибка, а не UB Фигуры нет — исключение с понятным сообщением, а не чтение чужой памяти -
Добавить фигуру 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 -
История 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_; }; -
Повтор void History::redo() { if (undone_.empty()) return; undone_.back()->execute(); done_.push_back(std::move(undone_.back())); undone_.pop_back();
} После нового действия список для redo очищается — как в любом редакторе -
Использование 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 -
Макрокоманда: одна отмена на всё 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_; }; «Выровнять все фигуры» — десятки перемещений, но одна отмена -
Итоги: Command Достоинства Отмена и повтор Одно действие — из
меню, кнопки или по горячей клавише Команды складываются в макросы и журнал Недостатки Класс на каждое действие Нужно аккуратно хранить данные для отмены -
Поведенческий паттерн · 3 / 6 Observer Наблюдатель Объект оповещает
подписчиков о своих изменениях, не зная, кто они -
Задача: выделили фигуру Панель свойств показывает размеры Строка состояния: «Выделена
1 фигура» Кнопка «Удалить» становится активной -
Решение в лоб void Canvas::select(Shape& shape) { selected_ = &shape;
propertiesPanel_.show(shape); // холст знает про весь интерфейс statusBar_.setText("Выделена 1 фигура"); toolbar_.enableDelete(true); } Холст зависит от всех панелей Новая панель → правим Canvas Холст не проверить без интерфейса -
Идея: холст оповещает подписчиков Издатель Canvas subscribe() select() Подписчик список
SelectionListener onSelectionChanged() = 0 select() вызывает onSelectionChanged() у всех PropertiesPanel StatusBar -
Классический Observer: подписчик class SelectionListener { public: virtual ~SelectionListener() =
default; virtual void onSelectionChanged(const Shape* selected) = 0; }; -
Классический 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; }; // не владеет -
Проблема: забыли отписаться { } PropertiesPanel panel; canvas.subscribe(&panel); // панель
уничтожена, но осталась в списке canvas.select(&circle); В списке остался указатель на мёртвый объект // вызов метода мёртвого объекта — UB Следить за отпиской приходится вручную -
Идея: сигналы и слоты Слоты Издатель PropertiesPanel::show Canvas сигнал selectionChanged
connect() StatusBar::update [](const Shape*) { … } Сигнал — событие, о котором можно сообщить. Слот — любая функция, которая на него реагирует. connect() связывает их и возвращает подписку -
Подписка — это объект: уничтожили его — отписались RAII, как
unique_ptr для памяти -
Что делает 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: второй аргумент не меняется. Записали новое — вернули старое -
Подписка 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_; }; // отписаться один раз -
Подписку можно переместить 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; } Копировать нельзя: отписаться можно только один раз -
Сигнал 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; }; -
Сигнал: подписка 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); }); } -
Сигнал: оповещение template <class... Args> void Signal<Args...>::emit(Args... args) const {
const auto copy = *slots_; // снимок списка подписчиков for (const auto& [id, slot] : copy) slot(args...); } Обходим снимок списка — зачем, на следующем слайде -
Зачем копия: отписка из обработчика 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 -
Холст 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; }; // холст не знает, кто слушает -
Панель свойств 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_; }; // панель уничтожена → отписалась сама -
Использование 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); // только строка состояния -
Итоги: Observer Достоинства Недостатки Издатель не знает подписчиков Новых подписчиков
добавляем, не меняя холст Порядок оповещения не гарантирован Без RAII — висячие подписки Трудно проследить, кто кого вызвал Готовые реализации: сигналы и слоты в Qt, boost::signals2 -
Поведенческий паттерн · 4 / 6 Template Method Шаблонный метод
Задаёт скелет алгоритма в базовом классе, а отдельные шаги — в наследниках -
Задача: отчёт о фигурах CSV — открыть в Excel HTML
— показать в браузере Скрытые фигуры: в CSV нужны, в HTML — нет -
Решение в лоб 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"; } Схема «заголовок → обход → концовка» скопирована в каждый формат -
Идея: общий скелет, разные шаги ReportExporter exportTo() ← шаблонный метод
writeHeader() = 0 writeRow() = 0 writeFooter() ← хук includeHidden() ← хук CsvExporter HtmlExporter writeHeader() writeRow() includeHidden() writeHeader() writeRow() writeFooter() -
Шаблонный метод 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; } // хук -
Шаги и хуки =0 Обязательный шаг: наследник должен его реализовать
{} Хук: можно переопределить, а можно оставить как есть private Наследник переопределяет шаги, но вызывает их только база -
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; } }; // в данные — всё -
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"; } }; -
Использование 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>, без скрытых -
«Не звоните нам — мы вам позвоним» Голливудский принцип: базовый
класс сам вызывает шаги наследника, а не наоборот -
Помните Tool::onDrag()? Это уже был Template Method Factory Method —
частный случай: один из шагов алгоритма создаёт объект -
Итоги: Template Method Достоинства Общий алгоритм — в одном месте
Наследник пишет только отличия Недостатки Скелет алгоритма жёстко зафиксирован Шаги выбираются наследованием — не поменять во время работы Наследник может нарушить ожидания базы (LSP) -
Поведенческий паттерн · 5 / 6 Strategy Стратегия Набор взаимозаменяемых
алгоритмов: клиент выбирает нужный, не меняя свой код -
Задача: привязка при перемещении Без привязки, к сетке, к другим
фигурам Пользователь переключает режим в любой момент -
Решение в лоб 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 -
Идея: алгоритм — отдельный объект Контекст Стратегия MoveTool SnapStrategy onDrag()
setSnap() snap() = 0 стратегию можно заменить во время работы NoSnap GridSnap snap() snap() -
Стратегия 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; } }; -
Привязка к сетке 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_; }; -
Инструмент 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_; }; -
Использование MoveTool tool(std::make_unique<NoSnap>()); tool.onDrag(shape, {13, 27}); // (13, 27) tool.setSnap(std::make_unique<GridSnap>(10));
tool.onDrag(shape, {13, 27}); // пользователь включил сетку // (10, 30) -
Почему не наследовать MoveTool? Не переключить GridMoveTool не станет NoSnapMoveTool
во время работы Взрыв классов Привязка × границы × курсоры — класс на каждое сочетание Смешение Алгоритм привязки перемешан с логикой инструмента -
Стратегия-функция 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 и лямбды -
Стратегия-функция: использование fn::MoveTool free([](Point p) { return p; }); fn::MoveTool
grid([](Point p) { return Point{roundTo(p.x, 10), roundTo(p.y, 10)}; }); -
Стратегия при компиляции Стратегия — параметр шаблона, а не объект
с virtual Компилятор встраивает вызов: накладных расходов нет Policy-based design — А. Александреску, «Современное проектирование на C++» -
Политики 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)}; } }; -
Инструмент с политиками 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 сочетания без четырёх классов -
Политики: использование policy::FreeMove freeMove; policy::PreciseMove preciseMove; freeMove.onDrag(shape, {2003, 27}); preciseMove.onDrag(shape,
{2003, 27}); // (2003, 27) // (1920, 30): сетка, затем границы FreeMove и PreciseMove — разные типы: в один контейнер их не положить -
Стратегии в STL std::ranges::sort(sizes, std::greater{}); // стратегия сравнения std::set<std::string, CaseInsensitiveLess>
names; names.insert("Circle"); names.insert("circle"); // стратегия — параметр шаблона // не добавится: «равны» Компараторы, хеш-функции, аллокаторы — это стратегии-параметры -
Template Method или Strategy Template Method Strategy Механизм Наследование Композиция
Что меняется Отдельные шаги Весь алгоритм Когда выбирается При создании объекта В любой момент (или при компиляции) В редакторе ReportExporter SnapStrategy -
Итоги: Strategy Достоинства Алгоритмы отделены от клиента Можно переключать во
время работы Новый алгоритм — новый класс или лямбда Недостатки Клиент должен знать, какие стратегии есть Политики-шаблоны: выбор только при компиляции -
Поведенческий паттерн · 6 / 6 State Состояние Объект меняет
поведение вместе со своим состоянием — будто меняет класс -
Задача: поведение документа Изменить Сохранить Закрыть Сохранён → Изменён ничего
закрыть Изменён ничего записать → Сохранён «Сохранить?», закрыть Только чтение ошибка ошибка закрыть Одно и то же действие ведёт себя по-разному в зависимости от состояния -
Решение в лоб 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 — в каждом методе Новое состояние → правим все методы -
Идея: состояние — отдельный объект Контекст Состояние Document DocumentState edit()
save() close() edit() = 0 save() = 0 close() = 0 Document передаёт события текущему состоянию Saved Modified ReadOnly -
Состояние 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; }; -
Документ 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_; }; -
Состояние «Сохранён» 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; } -
Состояние «Изменён» 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; } -
Почему не setState() изнутри? void ModifiedState::save(Document& doc) { doc.writeToDisk(); doc.setState(std::make_unique<SavedState>());
log("saved"); // UB: объекта уже нет } // удалил *this setState() удалил объект, чей метод ещё выполняется -
Решение: вернуть следующее состояние void Document::apply(DocumentState::Next next) { if (next)
state_ = std::move(next); // старое состояние уже отработало } Состояние только решает, куда перейти. Заменяет его документ — когда метод уже завершился -
Использование Document doc; doc.save(); // Saved: ничего не происходит doc.edit();
// Saved → Modified doc.close(); // «Сохранить изменения?» → сохранили, закрыли -
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, но помнит, какой тип сейчас внутри, и не даёт прочитать не тот -
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 -
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(), поэтому от неё можно наследоваться -
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); } Состояние — значение, не объект в куче. Пропустили случай — не скомпилируется -
State или Strategy Strategy State Кто меняет Клиент снаружи Само
состояние изнутри Знают друг о друге Нет Да: решают, кто следующий В редакторе NoSnap ↔ GridSnap Saved → Modified Устроены одинаково, а различаются тем, кто и почему делает замену -
Итоги: State Достоинства Нет switch по состояниям Правила одного состояния
— в одном классе Новое состояние — новый класс Недостатки Много маленьких классов Состояния знают друг о друге -
Как выбрать Вопрос Паттерн В редакторе Обойти коллекцию, не зная
её устройства? Iterator Canvas::begin() Действие нужно отменять и повторять? Command History Оповестить других об изменении? Observer selectionChanged() Алгоритм общий, отличаются шаги? Template Method ReportExporter Менять алгоритм на лету? Strategy SnapStrategy Поведение зависит от состояния? State DocumentState -
Когда паттерн не нужен Обычный цикл по vector → свой
итератор не нужен Действие без отмены → команда не нужна Два варианта, которые никогда не меняются → хватит if Паттерн — средство, а не цель