🍿 Иерархический FSM (HFSM)

FSM (конечный автомат) — это не rocket science. Это просто способ явно описать: «в каком состоянии я нахожусь» и «что происходит при событии X». Пригодится везде: парсеры протоколов, UI-логика, игровые NPC, сетевые соединения.

Самая простая реализация — enum + switch и в большинстве случаев этого может быть достаточно. Но, если состояний становится много, то пользоваться им становится не удобно и самое время задуматься об иерархическом автомате.

HFSM позволяет группировать состояния. Применяется в игровых движках (вложенные состояния NPC), UI-фреймворках, протоколах с retry-логикой.

🧋 Реализация

#include <iostream>
#include <functional>
#include <map>
#include <optional>

enum class State { Idle, Running, Paused, Active, Stopped };
enum class Event { Start, Pause, Resume, Stop };

// Состояние может иметь родителя — тогда необработанные события
// делегируются вверх по иерархии
struct StateNode {
    std::optional<State>  parent;
    std::function<void()> onEnter;
    std::function<void()> onExit;
};

class HierarchicalFSM {
    State current_;
    std::map<State, StateNode>                 nodes_;
    std::map<std::pair<State,Event>, State>    transitions_;

public:
    explicit HierarchicalFSM(State init) : current_(init) {}

    void defState(State s,
                  std::optional<State> parent = std::nullopt,
                  std::function<void()> enter = {},
                  std::function<void()> exit  = {}) {
        nodes_[s] = {parent, std::move(enter), std::move(exit)};
    }

    void addTransition(State from, Event ev, State to) {
        transitions_[{from, ev}] = to;
    }

    bool process(Event ev) {
        // Ищем переход от текущего состояния вверх по иерархии
        std::optional<State> search = current_;
        while (search) {
            auto it = transitions_.find({*search, ev});
            if (it != transitions_.end()) {
                exitState(current_);
                current_ = it->second;
                enterState(current_);
                return true;
            }
            // Поднимаемся к родителю
            auto nodeIt = nodes_.find(*search);
            search = (nodeIt != nodes_.end()) ? nodeIt->second.parent
                                               : std::nullopt;
        }
        return false; // переход не найден
    }

    State state() const { return current_; }

private:
    void enterState(State s) {
        if (auto it = nodes_.find(s); it != nodes_.end())
            if (it->second.onEnter) it->second.onEnter();
    }
    void exitState(State s) {
        if (auto it = nodes_.find(s); it != nodes_.end())
            if (it->second.onExit) it->second.onExit();
    }
};

int main() {
    HierarchicalFSM fsm(State::Idle);

    // Active — виртуальный родитель для Running и Paused
    fsm.defState(State::Active);
    fsm.defState(State::Idle);
    fsm.defState(State::Running, State::Active,
        [] { std::cout << "[ENTER] Running\n"; },
        [] { std::cout << "[EXIT]  Running\n"; });
    fsm.defState(State::Paused, State::Active);
    fsm.defState(State::Stopped, std::nullopt,
        [] { std::cout << "[ENTER] Stopped\n"; });

    fsm.addTransition(State::Idle, Event::Start, State::Running);
    fsm.addTransition(State::Running, Event::Pause, State::Paused);
    fsm.addTransition(State::Paused, Event::Resume, State::Running);
    // Stop работает из любого Active-состояния
    fsm.addTransition(State::Active, Event::Stop, State::Stopped);

    fsm.process(Event::Start);
    fsm.process(Event::Pause);
    fsm.process(Event::Stop); // делегируется к Active -> Stopped
    return 0;
}

❗️ Добавь состояние — и оно автоматически наследует все переходы родителя. Не нужно дублировать Stop в каждое дочернее состояние.


✏️ Используешь FSM в продакшне?


🔥 Успейте на курс по ИИ-агентам! До 30 апреля осталось всего 4 места.
👉 Занять место по ссылке


📍Навигация: Вакансии • Задачи • Собесы

Библиотека C/C++ разработчика

#шаблонный_код

🍙 views::transform — ленивые преобразования в C++20

Если views::filter решает, какие элементы обработать, то views::transform — во что их превратить. Никакого копирования: это такая же ленивая обёртка над данными.

🌸 Базовое использование

#include <ranges>
#include <vector>
#include <string>
namespace views = std::views;

std::vector<std::string> words = {"hello", "world", "cpp"};

// Получаем длины слов
auto lengths = words | views::transform([](const std::string& s) {
    return s.size();
});
// При итерации: 5, 5, 3

Лямбда применяется к каждому элементу в момент итерации — ни раньше, ни позже.

🍪 Трансформация с изменением типа

transform не обязан возвращать тот же тип. Из string можно получить size_t, из double — int, из структуры — одно из её полей:

// Верхний регистр (#include <cctype>)
auto upper = words | views::transform([](std::string s) {
    for (char& c : s) c = std::toupper(c);
    return s;
});
// При итерации: "HELLO", "WORLD", "CPP"

Обратите внимание: здесь s принимается по значению — это намеренная копия, которую мы модифицируем.


🍀 filter + transform — классика

Главная сила адаптеров — в их цепочке. Сначала отсеиваем ненужное, потом преобразуем то, что осталось:

struct Employee {
    std::string name;
    double salary;
    bool is_active;
};

std::vector<Employee> employees = {
    {"Алиса",  80000,  true},
    {"Борис",  95000,  false},
    {"Виктор", 72000,  true},
    {"Галина", 110000, true},
};

// Имена активных сотрудников с зарплатой выше 75 000
auto high_earners = employees
    | views::filter([](const Employee& e) { return e.is_active; })
    | views::filter([](const Employee& e) { return e.salary > 75000; })
    | views::transform([](const Employee& e) { return e.name; });

for (const auto& name : high_earners) {
    std::cout << name << "\n"; // Алиса, Галина
}

Весь конвейер ленив: ни одна лямбда не вызывается, пока не начнётся итерация.


🌱 pipe-синтаксис vs явный тип

auto v1 = words | views::transform([](const std::string& s) { return s.size(); });
auto v2 = std::ranges::transform_view{words, [](const std::string& s) { return s.size(); }};

🍙 Материализация в вектор

transform_view — не контейнер. Чтобы получить std::vector, нужно явно материализовать:

// C++23
auto vec = words | views::transform([](const std::string& s) { return s.size(); })
                 | std::ranges::to<std::vector>();

// C++20
std::vector<size_t> vec(lengths.begin(), lengths.end());

❌ Ловушка: несовпадение типа возврата

// UB — возвращается ссылка на временный объект
auto bad = words | views::transform([](const std::string& s) -> const std::string& {
    std::string upper = s;
    return upper; // dangling reference!
});

// Правильно — возвращаем по значению
auto ok = words | views::transform([](const std::string& s) {
    std::string upper = s;
    for (char& c : upper) c = std::toupper(c);
    return upper;
});

🐸 Продолжение следует...

📍Навигация: Вакансии • Задачи • Собесы

Библиотека C/C++ разработчика

#константная_правильность

🔒 Планы hh.ru на 2026: привязка к Госуслугам и запрет накрутки опыта

С 2026 года hh.ru делит соискателей на три категории: верифицированные, «серые» и невидимые. Те, кто не привязал Госуслуги и не подтвердил опыт через ЭТК, рискуют отправлять отклики в пустоту.

Разбираем механику новой системы и даем рабочий план — что делать прямо сейчас, чтобы остаться в игре.

👉 Читать статью

🐸 Библиотека программиста

🔥 4 привычки кодеров

Вот сколько общаюсь с разработчиками, постоянно слышу убеждение, что есть какой-то правильный способ писать софт. Все ищут секретную архитектуру, вылизывают паттерны, чтобы хоба и тимлид заплакал от счастья от твоего идеального кода.

но, я собрал 4 привычки адептов «чистого кода», (которые обычно все практикуют) 🤡

• Бесконечный рефакторинг рабочего кода.
Кажется, что так ты делаешь продукт лучше. Итог: жестко падаешь в перфекционизм. Переписываешь функцию по три раза, а бизнес ждет релиз. Закрываешь вкладку и в голове абсолютная пустота, время потрачено, а новых фичей ноль.

• Упарывание в сложную архитектуру
Сеньоры на ютубе обещают золотые горы, если внедрить микросервисы куда угодно. Итог: получаешь красивый overengineering-проект для мамы и 0 запущенных продуктов в срок, пока конкуренты клепают MVP на коленке.

• Душные споры на ревью
Неплохо, но как итог: ты пишешь полотна текста и тратишь часы на поиск глупой придирки к стилю, потому что банально фокус сместился с реальной задачи на эго.

• Ручная микро-оптимизация
Классика для тех, кто любит алгоритмы из универа. Итог: убиваешь дни жизни и выжимаешь миллисекунды, хотя бизнесу нужен был просто грязный, но рабочий скрипт еще вчера.

Проблема в том, что ни один из этих путей не дает самого главного - скорости и проверки гипотез. Реальному рынку плевать на твой идеальный код за 3 дня. Бизнес предпочтет код от ИИ-агента за 5 минут, который уже завтра начнет приносить деньги.

Хочешь обкатанный на нас лично и 100х учениках метод, как перестать кодить руками и начать делегировать задачи автономным системам?

👉 Заходи сюда, но у нас осталось всего 4 места, набор идет до завтрашнего дня.

P. S. Если интересно еще что-нибудь почитать от меня, то заходите в «Азбуку Айтишника», там я рассказываю об айти-базе, также у меня там есть бесплатный гайд на 15 глав по ии-агентам

🍙 views::take и views::drop — срезы в C++

Если views::transform превращает элементы, то views::take и views::drop управляют тем, сколько элементов обработать. Та же ленивая логика, никакого лишнего копирования.

🌸 views::take — первые N элементов

#include <ranges>
#include <vector>
namespace views = std::views;

std::vector<int> v = {10, 20, 30, 40, 50};

auto first_three = v | views::take(3);
// При итерации: 10, 20, 30

Лямбда не нужна — достаточно числа. Адаптер остановит итерацию сам, как только наберёт нужное количество.


🍪 take_while — берём пока условие истинно

auto while_lt_40 = v | views::take_while([](int x) { return x < 40; });
// При итерации: 10, 20, 30

В отличие от take(n), здесь количество элементов заранее неизвестно — решает предикат.


🍀 views::drop — пропустить первые N элементов

auto skip_two = v | views::drop(2);
// При итерации: 30, 40, 50

// drop_while — пропускаем пока условие истинно
auto after_twenties = v | views::drop_while([](int x) { return x <= 20; });
// При итерации: 30, 40, 50

❗️Важный нюанс: drop_while проверяет предикат только до первого несовпадения, а затем отдаёт все оставшиеся элементы подряд — даже те, что снова удовлетворили бы условию. Это не фильтр — это одноразовый пропуск.


🌱 Срез в середине: drop + take

Комбинируя два адаптера, получаем аналог Python-срезов:

// Элементы с индекса 1 по 3 включительно (аналог v[1:4])
auto slice = v | views::drop(1) | views::take(3);
// При итерации: 20, 30, 40

Весь конвейер по-прежнему ленив: элементы не вычисляются до начала итерации.


🍙 Связка с filter и transform

struct Employee {
    std::string name;
    double salary;
    bool is_active;
};

std::vector<Employee> employees = { /* ... */ };

// Топ-2 активных сотрудника по имени
auto top_two = employees
    | views::filter([](const Employee& e) { return e.is_active; })
    | views::transform([](const Employee& e) { return e.name; })
    | views::take(2);

❌ Ловушка: drop на бесконечном диапазоне

// OK — take ограничивает бесконечный iota
auto ok = std::views::iota(1) | std::views::take(5);
// 1, 2, 3, 4, 5

// OK — drop сам по себе безопасен, view создаётся без проблем
auto dropped = std::views::iota(1) | std::views::drop(3);

// ОПАСНО — итерирование без терминатора зависнет навсегда
for (auto x : dropped) { /* никогда не остановится */ }

drop на бесконечном диапазоне создаётся без проблем. Опасность — в цикле без ограничителя. Всегда добавляйте take или аналог, если диапазон потенциально бесконечен.


🐸 Продолжение следует...

📍Навигация: Вакансии • Задачи • Собесы

Библиотека C/C++ разработчика

#константная_правильность

🏆 Задача на выходные: string_view vs string в API

Перед тобой два варианта API логгера. Выбери лучший и обоснуй. Нет единственно верного ответа — важна аргументация.

#include <string>
#include <string_view>

// Вариант А
class LoggerA {
public:
    void log(const std::string& msg);
    void setPrefix(const std::string& prefix);
    std::string getLastMessage() const;
};

// Вариант Б
class LoggerB {
public:
    void log(std::string_view msg);
    void setPrefix(std::string_view prefix);
    std::string_view getLastMessage() const;
};

// Контекст использования:
// 1. log() вызывается тысячи раз в секунду
// 2. setPrefix() — один раз при старте
// 3. getLastMessage() — для диагностики
// 4. Логгер хранит последнее сообщение внутри

✏️ Напиши в комментариях: какой метод в каком варианте правильный, а какой — нет. Предложи «идеальный» LoggerC.


📍Навигация: Вакансии • Задачи • Собесы

Библиотека C/C++ разработчика

#константная_правильность

🍿 Что скрывает auto(x): новый синтаксис C++23

В C++23 появился синтаксис auto(x) и auto{x}. Это не очередной сахар для объявления переменных. На самом деле — это именованная операция, у которой есть точная семантика.


🥳 Что происходит под капотом:

auto(x) — это decay-copy: создаётся prvalue того же типа, что и x, но после применения std::decay. То есть:

• Ссылки снимаются
• Cv-квалификаторы (const/volatile) удаляются
• Массивы → указатели
• Функции → указатели на функции

const int& r = 42;
auto copy = auto(r); // int, не const int&

⚡️ До C++23 для того же результата писали:

auto copy = std::decay_t<decltype(r)>(r);

❓ Зачем нужна явность?

В простых случаях auto copy = r тоже даст int — auto и так делает decay. Но в обобщённом коде важно явно сигнализировать намерение: "я хочу копию, а не прокси или view".

Главное применение — защита от UB при модификации контейнера. Классический пример — реализация pop_front:

void pop_front(auto& container) {
    std::erase(container, auto(container.front()));
    // Без auto() — UB: front() может инвалидироваться
    // в процессе удаления элементов
}

Без auto() мы передаём ссылку на элемент, который erase может разрушить до сравнения. С auto() — сначала создаётся копия значения, потом происходит удаление. Безопасно и читаемо.

❗️ auto(x) закрывает целый класс subtle-багов в шаблонном коде — там, где случайная ссылка вместо копии приводит к UB или неожиданному поведению.


📍Навигация: Вакансии • Задачи • Собесы

Библиотека C/C++ разработчика

#константная_правильность