##### cppreference.com

##### Search

Create account

##### Namespaces

- Page
- Discussion

##### Variants

##### Views

- View
- Edit
- History

##### Actions

# std::shared_ptr::owner_before

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

template< class Y > bool owner_before( const shared_ptr<Y>& other) const; |  |
template< class Y > bool owner_before( const std::weak_ptr<Y>& other) const; |  |

Checks whether this `shared_ptr` precedes `other` in implementation defined owner-based (as opposed to value-based) order. The order is such that two smart pointers compare equivalent only if they are both empty or if they both own the same object, even if the values of the pointers obtained by get() are different (e.g. because they point at different subobjects within the same object)

This ordering is used to make shared and weak pointers usable as keys in associative containers, typically through std::owner_less.

### [edit] Parameters

other | - | the std::shared_ptr or std::weak_ptr to be compared

### [edit] Return value

true if *this precedes `other`, false otherwise. Common implementations compare the addresses of the control blocks.

### Exceptions

(none) | (until C++17)
`noexcept` specification: noexcept | (since C++17)

### [edit] Example

Run this code

    #include <iostream>
    #include <memory>

    struct Foo {
        int n1;
        int n2;
        Foo(int a, int b) : n1(a), n2(b) {}
    };
    int main()
    {
        auto p1 = std::make_shared<Foo>(1, 2);
        std::shared_ptr<int> p2(p1, &p1->n1);
        std::shared_ptr<int> p3(p1, &p1->n2);

        std::cout << std::boolalpha
                  << "p2 < p3 " << (p2 < p3) << '\n'
                  << "p3 < p2 " << (p3 < p2) << '\n'
                  << "p2.owner_before(p3) " << p2.owner_before(p3) << '\n'
                  << "p3.owner_before(p2) " << p3.owner_before(p2) << '\n';

        std::weak_ptr<int> w2(p2);
        std::weak_ptr<int> w3(p3);
        std::cout
    //              << "w2 < w3 " << (w2 < w3) << '\n'  // won't compile
    //              << "w3 < w2 " << (w3 < w2) << '\n'  // won't compile
                  << "w2.owner_before(w3) " << w2.owner_before(w3) << '\n'
                  << "w3.owner_before(w2) " << w3.owner_before(w2) << '\n';

    }

Output:

    p2 < p3 true
    p3 < p2 false
    p2.owner_before(p3) false
    p3.owner_before(p2) false
    w2.owner_before(w3) false
    w3.owner_before(w2) false

### [edit] See also

owner_less (C++11) | provides mixed-type owner-based ordering of shared and weak pointers (class template) [edit]

Retrieved from "http://en.cppreference.com/mwiki/index.php?title=cpp/memory/shared_ptr/owner_before&oldid=42299"
Category:

- unconditionally noexcept

Hidden categories:

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