close
Пространства имён
Варианты
Действия

std::weak_ptr<T>::lock

Материал из cppreference.com
 
 
Библиотека утилит
Языковая поддержка
Поддержка типов (базовые типы, RTTI)
Макросы тестирования функциональности библиотеки (C++20)    
Управление динамической памятью
Программные утилиты
Поддержка сопрограмм (C++20)
Вариативные функции
Трёхстороннее сравнение (C++20)
(C++20)
(C++20)(C++20)(C++20)(C++20)(C++20)(C++20)
Общие утилиты
Дата и время
Функциональные объекты
Библиотека форматирования (C++20)
(C++11)
Операторы отношения (устарело в C++20)
Целочисленные функции сравнения
(C++20)(C++20)(C++20)    
(C++20)
Операции обмена и типа
(C++14)
(C++11)
(C++11)
(C++11)
(C++17)
Общие лексические типы
(C++11)
(C++17)
(C++17)
(C++17)
(C++11)
(C++17)
(C++23)
Элементарные преобразования строк
(C++17)
(C++17)
 
Динамическое управление памятью
no section name
Ограниченные алгоритмы неинициализированной памяти
no section name
Поддержка сбора мусора
(C++11)(до C++23)
(C++11)(до C++23)
(C++11)(до C++23)
(C++11)(до C++23)
(C++11)(до C++23)
(C++11)(до C++23)



no section name
 
std::weak_ptr
Функции-элементы
Модификаторы
Наблюдатели
Функции, не являющиеся элементами
Вспомогательные классы
Правила вывода(C++17)
 
<tbody> </tbody>
std::shared_ptr<T> lock() const noexcept;
(начиная с C++11)

Создаёт новый std::shared_ptr, который разделяет владение управляемым объектом. Если управляемого объекта нет, т.е. *this пусто, возвращаемый shared_ptr также пуст.

Эффективно возвращает expired() ? shared_ptr<T>() : shared_ptr<T>(*this), выполнясь атомарно.

Параметры

(нет)

Возвращаемое значение

shared_ptr, который разделяет владение принадлежащим ему объектом, если std::weak_ptr::expired возвращает false. Иначе возвращает построенный по умолчанию shared_ptr типа T.

Примечание

И эта функция, и конструктор std::shared_ptr могут использоваться для временного владения управляемым объектом, на который ссылается std::weak_ptr. Разница в том, что конструктор std::shared_ptr генерирует исключение, когда его аргумент std::weak_ptr пуст, а std::weak_ptr<T>::lock() создаёт пустой std::shared_ptr<T>.

Пример

#include <iostream>
#include <memory>

void observe(std::weak_ptr<int> weak)
{
    if (auto p = weak.lock())
        std::cout << "\tobserve() может заблокировать weak_ptr<>, значение=" << *p << '\n';
    else
        std::cout << "\tobserve() не может заблокировать lock weak_ptr<>\n";
}

int main()
{
    std::weak_ptr<int> weak;
    std::cout << "weak_ptr<> ещё не инициализирован\n";
    observe(weak);
    
    {
        auto shared = std::make_shared<int>(42);
        weak = shared;
        std::cout << "weak_ptr<> инициализируется с помощью shared_ptr\n";
        observe(weak);
    }

    std::cout << "shared_ptr<> был уничтожен при выходе из области видимости\n";
    observe(weak);
}

Вывод:

weak_ptr<> ещё не инициализирован
        observe() не может заблокировать weak_ptr<>
weak_ptr<> инициализируется с помощью shared_ptr
        observe() может заблокировать weak_ptr<>, value=42
shared_ptr<> был уничтожен при выходе из области видимости
        observe() не может заблокировать weak_ptr<>

Отчёты о дефектах

Следующие изменения поведения были применены с обратной силой к ранее опубликованным стандартам C++:

Номер Применён Поведение в стандарте Корректное поведение
LWG 2316 C++11 lock() не должен был быть атомарным, но должен был быть noexcept,
что приводило к противоречию
указан как атомарный

Смотрите также

проверяет, был ли удалён объект, на который ссылается weak_ptr
(public функция-элемент) [править]