Перейти на PRO

Для чего нужен std::weak_ptr?

Тип вопроса: Управление памятью Вероятность: 38% Категория: C/C++ Разработчик

Ответ

std::weak_ptr<T> — это «слабый» умный указатель, который не владеет объектом и не увеличивает счетчик ссылок (use_count) std::shared_ptr. Его основное назначение — разрушение циклических ссылок между shared_ptr и безопасное наблюдение за объектом, время жизни которого управляется shared_ptr.

Основные сценарии использования:

  1. Разрушение циклических зависимостей: Классический пример — двунаправленная связь или родитель-ребенок в графах.
  2. Кэширование: Хранение «слабых» ссылок на объекты, которые могут быть удалены, если на них больше нет «сильных» ссылок (shared_ptr).
  3. Наблюдение (observer): Временное получение доступа к ресурсу, если он еще жив, без продления его времени жизни.

Как с ним работать: weak_ptr нельзя разыменовать напрямую. Сначала нужно получить из него shared_ptr с помощью метода lock().

Пример с циклической зависимостью:

#include <iostream>
#include <memory>

class Node {
public:
    std::string name;
    std::shared_ptr<Node> partner; // Сильная ссылка
    // std::weak_ptr<Node> partner; // Правильное решение: слабая ссылка

    Node(const std::string& n) : name(n) {
        std::cout << "Node " << name << " created.n";
    }
    ~Node() {
        std::cout << "Node " << name << " destroyed.n";
    }
};

int main() {
    std::cout << "=== Example with shared_ptr (Cyclic Reference) ===n";
    {
        auto alice = std::make_shared<Node>("Alice");
        auto bob = std::make_shared<Node>("Bob");
        alice->partner = bob; // bob.use_count() = 2
        bob->partner = alice; // alice.use_count() = 2 -> ЦИКЛ!
        // При выходе из области видимости деструкторы НЕ вызовутся из-за цикла.
    }
    std::cout << "Scope ended. Memory leak!nn";

    std::cout << "=== Example with weak_ptr (Correct) ===n";
    {
        auto alice = std::make_shared<Node>("Alice");
        auto bob = std::make_shared<Node>("Bob");
        // Используем weak_ptr для разрыва цикла владения
        std::weak_ptr<Node> aliceWeak = alice;
        std::weak_ptr<Node> bobWeak = bob;

        // Для доступа к партнеру используем lock()
        if (auto partnerPtr = bobWeak.lock()) { // Пытаемся получить shared_ptr
            std::cout << "Bob's partner (via weak_ptr) is: " << partnerPtr->name << std::endl;
        } else {
            std::cout << "Bob's partner no longer exists.n";
        }
        // При выходе из области видимости alice и bob будут корректно уничтожены,
        // т.к. weak_ptr не мешает счетчику ссылок достичь нуля.
    }
    std::cout << "Scope ended. No memory leak.n";
    return 0;
}

lock() возвращает shared_ptr на объект, если он еще существует (счетчик use_count > 0), или nullptr в противном случае. Это потокобезопасная операция.

Ответ 18+ 🔞

Давай разберем эту штуку, std::weak_ptr<T>, по косточкам, чтобы всё встало на свои места, а то голова кругом идёт от этих умных указателей.

Представь себе, shared_ptr — это как твой друг, который одалживает тебе свою тачку. Пока ты на ней катаешься (пока есть хотя бы один shared_ptr), тачка жива и ездит. А weak_ptr — это как твой другой кореш, который просто знает про эту тачку, смотрит на неё издалека, но ключей у него нет, и он не мешает тебе её в итоге в гараж загнать и разобрать на запчасти. Он не владеет объектом, счётчик ссылок (use_count) для него — хуй с горы, он его не увеличивает.

Зачем это, блядь, нужно? Да похуй, шучу. На самом деле, причины есть, и они охуенно важные:

  1. Ломаем порочный круг. Классика жанра — два объекта держат друг на друга shared_ptr. Алиса владеет Бобом, Боб владеет Алисой. Вышли они из области видимости, а удалить их нихуя — счётчики ссылок у каждого по единице, и всё, пиши пропало, память потекла. Это пиздец. weak_ptr ломает этот круг, потому что он не владеет, а просто подсматривает.
  2. Кэш, который не мешает жить. Допустим, у тебя есть кэш объектов. Ты можешь хранить в нём weak_ptr. Если основной владелец (shared_ptr) объект удалил — окей, в кэше просто будет nullptr, когда мы попробуем его достать. Никаких утечек, потому что weak_ptr не держит объект насильно.
  3. Просто посмотреть, не трогая. Нужно проверить, жив ли ещё объект, но не продлевать ему жизнь? weak_ptr — твой выбор. Подсмотрел, убедился, и пошёл дальше.

Как с этим чудом работать, не обосравшись? Напрямую разыменовать weak_ptr — нихуя не выйдет, это не shared_ptr. Тут нужен подход. Берёшь метод lock(). Он делает вот что: смотрит, а жив ли ещё объект (т.е., есть ли на него хотя бы один shared_ptr)? Если жив — возвращает тебе полноценный shared_ptr на него (и счётчик увеличивается на время его жизни). Если объект уже сдох — возвращает nullptr. Всё честно.

Смотри, как это выглядит в коде, на примере той самой ебалы с циклической зависимостью:

#include <iostream>
#include <memory>

class Node {
public:
    std::string name;
    std::shared_ptr<Node> partner; // Сильная ссылка — вот она, проблема!
    // std::weak_ptr<Node> partner; // А вот так — правильно, слабая ссылка!

    Node(const std::string& n) : name(n) {
        std::cout << "Node " << name << " created.n";
    }
    ~Node() {
        std::cout << "Node " << name << " destroyed.n";
    }
};

int main() {
    std::cout << "=== Пример с shared_ptr (Цикл, пиздец!) ===n";
    {
        auto alice = std::make_shared<Node>("Alice");
        auto bob = std::make_shared<Node>("Bob");
        alice->partner = bob; // у Боба use_count() = 2
        bob->partner = alice; // у Алисы use_count() = 2 — ЁПЕРНЫЙ ТЕАТР, ЦИКЛ!
        // Выходим отсюда... а деструкторы не вызываются! Память уплыла, ядрёна вошь.
    }
    std::cout << "Область видимости закончилась. Утечка памяти!nn";

    std::cout << "=== Пример с weak_ptr (Всё пучком) ===n";
    {
        auto alice = std::make_shared<Node>("Alice");
        auto bob = std::make_shared<Node>("Bob");
        // Используем weak_ptr, чтобы не владеть друг другом
        std::weak_ptr<Node> aliceWeak = alice;
        std::weak_ptr<Node> bobWeak = bob;

        // Хочешь достучаться до партнёра? Используй lock()!
        if (auto partnerPtr = bobWeak.lock()) { // Пытаемся получить shared_ptr
            std::cout << "Партнёр Боба (через weak_ptr): " << partnerPtr->name << std::endl;
        } else {
            std::cout << "Партнёр Боба больше не существует.n";
        }
        // Теперь, когда выходим, счётчики ссылок у alice и bob спокойно падают до нуля,
        // и они оба благополучно сдохнут. Никаких циклов, всё чисто.
    }
    std::cout << "Область видимости закончилась. Утечек нет.n";
    return 0;
}

Метод lock() — твой спасательный круг. Он потокобезопасный и возвращает либо валидный shared_ptr (и тогда объект точно жив, пока ты этот shared_ptr держишь), либо nullptr. Просто и гениально, ебать мои старые костыли. Главное — помни, weak_ptr без lock() это как кот без хвоста: вроде кот, но нихуя не ловит.

© ХакСобесов, 2026
support@hacksobesov.com