std::weak_ptr::lock - cppreference.com

##### cppreference.com

##### Search

Create account

##### Namespaces

- Page
- Discussion

##### Variants

##### Views

- View
- Edit
- History

##### Actions

# std::weak_ptr::lock

From cppreference.com
< cpp‎ | memory‎ | weak ptr

std::shared_ptr<T> lock() const; |  | (since C++11)

Creates a new std::shared_ptr that shares ownership of the managed object. If there is no managed object, i.e. *this is empty, then the returned `shared_ptr` also is empty.

Effectively returns expired() ? shared_ptr<T>() : shared_ptr<T>(*this), executed atomically.

### [edit] Parameters

(none)

### [edit] Return value

A `shared_ptr` which shares ownership of the owned object if std::weak_ptr::expired returns `false`. Else returns default-constructed `shared_ptr` of type T.

### [edit] Exceptions

`noexcept` specification:
noexcept

### [edit] Notes

Both this function and the constructor of std::shared_ptr may be used to acquire temporary ownership of the managed object referred to by a `std::weak_ptr`. The difference is that the constructor of std::shared_ptr throws an exception when its `std::weak_ptr` argument is empty, while std::weak_ptr<T>::lock() constructs an empty std::shared_ptr<T>.

### [edit] Example

Run this code

    #include <iostream>
    #include <memory>

    void observe(std::weak_ptr<int> weak)
    {
        if (auto observe = weak.lock()) {
            std::cout << "\tobserve() able to lock weak_ptr<>, value=" << *observe << "\n";
        } else {
            std::cout << "\tobserve() unable to lock weak_ptr<>\n";
        }
    }

    int main()
    {
        std::weak_ptr<int> weak;
        std::cout << "weak_ptr<> not yet initialized\n";
        observe(weak);

        {
            auto shared = std::make_shared<int>(42);
            weak = shared;
            std::cout << "weak_ptr<> initialized with shared_ptr.\n";
            observe(weak);
        }

        std::cout << "shared_ptr<> has been destructed due to scope exit.\n";
        observe(weak);
    }

Output:

    weak_ptr<> not yet initialized
            observe() unable to lock weak_ptr<>
    weak_ptr<> initialized with shared_ptr.
            observe() able to lock weak_ptr<>, value=42
    shared_ptr<> has been destructed due to scope exit.
            observe() unable to lock weak_ptr<>

### [edit] Defect reports

The following behavior-changing defect reports were applied retroactively to previously published C++ standards.

DR | Applied to | Behavior as published | Correct behavior
--- | --- | --- | ---
LWG 2316 | C++11 | lock() was not required to be atomic, but required to be noexcept, which led to a contradiction | specified to be atomic

### [edit] See also

expired | checks whether the referenced object was already deleted (public member function) [edit]

Retrieved from "http://en.cppreference.com/mwiki/index.php?title=cpp/memory/weak_ptr/lock&oldid=91863"
Category:

- unconditionally noexcept

Hidden categories:

- Pages with unreviewed unconditional noexcept template
- Pages with unreviewed noexcept template