🍪 Как выдать shared_ptr на себя из метода?

std::shared_ptr хранит рядом с объектом control block — счётчик владельцев. Несколько shared_ptr безопасны, пока делят один control block. Проблема: иногда объекту нужно отдать shared_ptr на себя, но внутри метода есть только сырой this, который о counter'е ничего не знает.


❌ Наивный способ:

struct S {
    std::shared_ptr<S> self() { return std::shared_ptr<S>(this); }
};
auto p = std::make_shared<S>();
auto q = p->self();

У p и q свои control block'и, у каждого счётчик = 1 → объект удалится дважды (UB).


✅ Решение — enable_shared_from_this:

struct S : std::enable_shared_from_this<S> {
    std::shared_ptr<S> self() { return shared_from_this(); }
};
auto p = std::make_shared<S>();
auto q = p->self();

База добавляет скрытый weak_ptr<S>. При первом заворачивании в shared_ptr его конструктор замечает эту базу и кладёт туда свой control block. Теперь q разделяет счётчик с p.


🍴 Что делает shared_from_this():

shared_ptr<S> shared_from_this() { return shared_ptr<S>(weak_this); }

Это конструктор из weak_ptr, а не lock(): без владельца он бросает bad_weak_ptr, а не молча возвращает пустой указатель.


🍙 Когда скрытый weak_ptr пуст:

S s;                            // на стеке — никто не владеет
s.shared_from_this();           // 💥 bad_weak_ptr (до C++17 — UB)

struct T : std::enable_shared_from_this<T> {
    T() { shared_from_this(); } // 💥 хук срабатывает после конструктора
};

Правила: наследовать публично, владеть через shared_ptr (лучше make_shared). Нужна проверка без исключения — в C++17 есть weak_from_this():


🍉 Правила:

• Наследуйте enable_shared_from_this публично.
• Владейте объектом через shared_ptr — лучше make_shared (одна аллокация + exception-safety).
• Не вызывайте shared_from_this() в конструкторе и на объектах со стека — будет bad_weak_ptr.
• Нужна проверка без исключения — в C++17 берите weak_from_this():

if (auto sp = obj.weak_from_this().lock()) { /* владелец есть */ }

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

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

#под_капотом

🐾 Алгоритмы диапазонов: Алгоритмы модификации

Разберём copy, transform, fill/generate, а также remove, reverse и unique — и заодно увидим, почему «удаление» в C++ удаляет не сразу.


🍵 ranges::copy / copy_if — копирование

std::vector<int> src = {1, 2, 3, 4, 5};
std::vector<int> dst(5);

std::ranges::copy(src, dst.begin());  // dst == {1, 2, 3, 4, 5}

// Копирование с условием
std::vector<int> evens;
std::ranges::copy_if(src, std::back_inserter(evens),
                     [](int x) { return x % 2 == 0; });
// evens == {2, 4}

Приёмник — один итератор (куда писать). Под copy буфер должен быть нужного размера; для copy_if берут std::back_inserter — он сам расширяет контейнер.

❗️ copy не терпит перекрытия источника и приёмника (UB). Для пересечения — copy_backward.


⬆️ ranges::move / swap_ranges — перемещение и обмен

std::vector<std::string> src = {"alpha", "beta", "gamma"};
std::vector<std::string> dst(3);

// Перемещение вместо копирования
std::ranges::move(src, dst.begin());
// dst == {"alpha", "beta", "gamma"}
// src содержит валидные, но "опустошённые" строки

// Обмен содержимым двух диапазонов
std::vector<int> a = {1, 2, 3};
std::vector<int> b = {4, 5, 6};

std::ranges::swap_ranges(a, b);
// a == {4, 5, 6}, b == {1, 2, 3}

move переносит ресурсы, а не копирует — дёшево для строк, векторов и прочих «тяжёлых» типов.

❗️ После move источник валиден, но содержимое не определено (valid but unspecified). Пустыми строки не гарантированы — только присвоить заново или уничтожить.


🌳 ranges::transform — преобразование

std::vector<int> src = {1, 2, 3, 4, 5};
std::vector<int> squared(5);

std::ranges::transform(src, squared.begin(), [](int x){ return x * x; });
// squared == {1, 4, 9, 16, 25}

Применяет функцию к каждому элементу и пишет результат в приёмник. Источник не меняется.


🍩 ranges::fill / generate — заполнение

std::vector<int> dst(5);

std::ranges::fill(dst, 0);  // {0, 0, 0, 0, 0}

std::ranges::generate(dst, [n = 0]() mutable { return n++; });
// {0, 1, 2, 3, 4}

fill кладёт одно и то же значение, generate зовёт функцию на каждый элемент — удобно для счётчиков, случайных чисел или любой генерации «на лету».


🥳 ranges::remove — удаление (erase-remove стал проще)

std::vector<int> data = {1, 2, 3, 2, 4, 2, 5};

// Старый способ:
data.erase(std::remove(data.begin(), data.end(), 2), data.end());

// Новый способ (C++20):
auto [first, last] = std::ranges::remove(data, 2);
data.erase(first, last);
// data == {1, 3, 4, 5}

Важный момент: remove ничего физически не удаляет — он лишь сдвигает «выжившие» элементы в начало и возвращает поддиапазон «мусорного хвоста». Реально обрезает контейнер только последующий erase.

❗️ Если контейнер свой (а не чужой диапазон), ещё короче — свободная функция std::erase(data, 2): одна строка вместо пары.


🍿 ranges::reverse — разворот

std::vector<int> data = {1, 3, 4, 5};
std::ranges::reverse(data);  // {5, 4, 3, 1}

Переворачивает диапазон на месте, без дополнительной памяти.


🎵 ranges::unique — удаление соседних дубликатов

std::vector<int> dups = {1, 1, 2, 3, 3, 3, 4};

auto [u_first, u_last] = std::ranges::unique(dups);
dups.erase(u_first, u_last);
// dups == {1, 2, 3, 4}

Как и remove, возвращает поддиапазон хвоста и требует erase для реальной очистки.

❗️ Убирает только соседние повторы — чтобы вычистить все дубликаты, диапазон сначала надо отсортировать.


🍴 Проекции — работают и здесь

struct Task {
    std::string name;
    int priority;
};

std::vector<Task> tasks = {
    {"Код", 1}, {"Почта", 0}, {"Деплой", 2}, {"Черновик", 0}
};

// Удалить все задачи с priority == 0 — без лямбды
auto [first, last] = std::ranges::remove(tasks, 0, &Task::priority);
tasks.erase(first, last);
// Остались {"Код", 1} и {"Деплой", 2}

Проекция — последний аргумент: remove, copy_if, transform и другие умеют работать «по полю».

❗️ Но проекция — не предикат. У remove это лишь сравнение на равенство; для условий сложнее (priority > 0) нужен remove_if.


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

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

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

📤 export: что именно вы отдаёте наружу?

Из модуля наружу видно только то, что помечено export. Всё остальное снаружи не видно — но это не «закрытость» уровня файла: у непомеченных сущностей модульное связывание, то есть их видят другие единицы трансляции того же модуля, просто не видит код, который подключает модуль. Это противоположность заголовкам, где в чужой код текстуально попадает вообще всё.

export module geometry;

export struct Point { double x, y; };  // открыто наружу

double dist(Point a, Point b);          // скрыто снаружи,
                                        // но доступно внутри модуля

export double length(Point p) {         // открыто наружу
    return dist(p, {0, 0});
}

Открыть наружу можно почти любую сущность: функции, типы, шаблоны, переменные, псевдонимы using.


🪐 Удобные формы записи

export {                    // блок экспорта
    int foo();
    int bar();
}

export namespace net {      // только объявления ЭТОГО блока
    void connect();
}

export import utils;        // повторный экспорт: проброс
                            // чужого модуля дальше

❗️ export namespace открывает только то, что объявлено в этом блоке. Если позже снова открыть пространство имён net без export, новые имена наружу не уйдут.


❌ Ошибки

• export допустим только в единице, которая начинается с export module …;. В единице реализации (module geometry; без export) это ошибка компиляции
• export нельзя ставить на сущности в безымянном пространстве имён — у них внутреннее связывание
• функцию со static не открыть — она по определению локальна (внутреннее связывание)
• нельзя открывать что-либо из общей вступительной части модуля (того, что идёт до export module …;)


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

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

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

😎 Знакомьтесь с экспертом Proglib.academy: Senior Software Engineer и Team Lead в Yandex Cloud Роман Барлос

Роман — консультант нашего курса «Разработка ИИ-агентов». Он работает на стыке cloud-native архитектуры и AI, активно внедряя современные ИИ-подходы в реальные процессы разработки.

За что его ценит IT-комьюнити?

🟣 Team Lead и AI-евангелист в команде UX Yandex Cloud

14-лет в разработке. Занимается AI-адопшеном в команде Yandex Cloud, проводит мастер-классы и продвигает лучшие практики для повышения эффективности разработчиков.

🟣 Техлид Sourcecraft Code Assistant

С сильным практическим бэкграундом принимал участие как технический лид в создании мощного AI-расширения для VS Code.

🟣 Создатель полезного Open Source

Разрабатывает утилиты, которые позволяют быстро начать эксперименты с инференсом и агентами в локальном окружении: например, набор скриптов vllm-setup для быстрого запуска окружения и mini-proxy — минималистичный прокси для OpenAI API провайдеров.

🟣 Автор интерактивных ML-визуализаций

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

Роман регулярно делится инженерными наработками, инсайтами и экспертизой в своем авторском Telegram-канале

На курсе Роман выступает консультантом программы: он помогает формировать содержание уроков с опорой на актуальные инженерные практики и жесткие требования индустрии.

Узнать больше о программе и разработке автономных систем:
👉 Курс «Разработка ИИ-агентов»

Так, продолжаем знакомить вас с командой?
👍 — Да, ждем новых лиц
🔥 — Жду полезные материалы от Романа

🍴 Исследовательская задача: что именно изменил C++23

В C++23 приняли P2718R0 — и старый баг range-for тихо исчез. Но не для всех временных объектов и не безусловно.

std::vector<int> getData() { return {1, 2, 3}; }

for (int x : getData()           // временный 1
                 | filtered)     // вью поверх него
    std::cout << x;

✏️Задание (research): найди в документации/предложении ответы:

1️⃣ Жизнь каких именно временных объектов продлевает P2718R0?
2️⃣ Почему до C++23 пример выше был UB, а теперь — нет?
3️⃣ Остались ли случаи, где даже в C++23 ты получишь висячую ссылку?


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

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

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

🥳 Алгоритмы диапазонов: Свёртки (fold)

В прошлый раз модифицировали диапазоны — теперь сворачиваем их в одно значение. В C++23 появилось семейство fold_*, которое наконец заменяет std::accumulate и аккуратно выводит типы.


🍰 ranges::fold_left — свёртка слева

std::vector<int> v = {1, 2, 3, 4, 5};
int sum     = std::ranges::fold_left(v, 0, std::plus{});       // 15
int product = std::ranges::fold_left(v, 1, std::multiplies{}); // 120

Левоассоциативная свёртка: аккумулятор — левый аргумент операции, элемент — правый. По шагам это (((( 0+1 )+2 )+3 )+4 )+5. Начальное значение задаёте сами.


🥨 ranges::fold_left_first — первый элемент как начало

std::vector<int> v = {3, 1, 4, 1, 5};
auto max_val = std::ranges::fold_left_first(v, [](int a, int b){
return std::max(a, b);
});
// max_val == std::optional<int>{5}

То же самое, но начальным значением берётся первый элемент диапазона — отдельный init не нужен. Удобно для max/min, где придумывать «нейтральный» элемент неловко (Для готовых max/min, конечно, есть ranges::max — fold_left_first интересен произвольной операцией).

❗️ Возвращает std::optional: у пустого диапазона нет первого элемента, поэтому на пустом входе придёт std::nullopt. Не забудьте проверить перед разыменованием.


🥖 ranges::fold_right — свёртка справа

std::vector<int> v = {1, 2, 3};
int r = std::ranges::fold_right(v, 0, std::minus{});
// 1 - (2 - (3 - 0)) == 2
int l = std::ranges::fold_left(v, 0, std::minus{});
// ((0 - 1) - 2) - 3 == -6

Идёт с правого конца: result = f(1, f(2, f(3, 0))). Для коммутативных операций (plus, multiplies) результат совпадёт с fold_left, а для некоммутативных — нет, как видно по вычитанию.

❗️ У fold_right порядок аргументов операции зеркальный: вызывается f(элемент, аккумулятор), то есть элемент идёт первым, а не вторым. Для своих лямбд это легко перепутать.


🥯 ranges::fold_right_last — последний элемент как начало

std::vector<int> v = {1, 2, 3};
auto res = std::ranges::fold_right_last(v, std::minus{});
// 1 - (2 - 3) == 2, внутри std::optional<int>{2}

Зеркало fold_left_first: начальным значением берётся последний элемент, результат — тоже std::optional с тем же поведением на пустом диапазоне.


🧇 ranges::fold_left_with_iter — результат и итератор

std::vector<int> v = {1, 2, 3, 4, 5};
auto [in, value] = std::ranges::fold_left_with_iter(v, 0, std::plus{});
// value == 15
// in == v.end()

Возвращает не просто значение, а структуру с полями in (итератор конца обработки) и value. Полезно, когда после свёртки нужно знать, где именно остановились — например, при работе с подсчётами в потоке.


❗️ Несколько подводных камней

• Главное отличие от accumulate — в том, как выводится тип накопления. У accumulate тип аккумулятора равен типу init, поэтому std::accumulate(vd.begin(), vd.end(), 0) на векторе double молча копит в int и теряет дробную часть. А fold_left выводит тип аккумулятора из РЕЗУЛЬТАТА операции (U = decay_t<invoke_result_t<F&, T, range_reference_t<R>>>), и здесь int-ный ноль на векторе double уже ничего не теряет: plus(int, double) даёт double, и всё копится в double.

std::vector<double> vd = {1.5, 2.5, 3.0};
auto s = std::ranges::fold_left(vd, 0, std::plus{});
// s == 7.0, а НЕ 6 — тип s выведен как double
// (то же самое через accumulate с init 0 дало бы int 6)

Это и есть причина, по которой fold_left лучше: он не обрезает молча.

• fold_left довольствуется однопроходным input-диапазоном (годится для istream_view и прочих потоков), а fold_right требует bidirectional-диапазона — ему нужно дойти до конца и пойти обратно. Поэтому «свернуть справа» поток на лету не выйдет.

• В отличие от remove, transform и copy_if из прошлого поста, свёртки НЕ принимают проекцию. «Свернуть по полю» одним аргументом не выйдет — нужна лямбда, которая сама достанет нужное:

std::vector<Task> tasks = { {"Код", 1}, {"Деплой", 2} };
int total = std::ranges::fold_left(tasks, 0,
[](int acc, const Task& t){ return acc + t.priority; });
// 3

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

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

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