# operator==,!=,<,<=,>,>=(std::unique_ptr)

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

template<class T1, class D1, class T2, class D2> bool operator==(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y); | (1) | (since C++11)
template<class T1, class D1, class T2, class D2> bool operator!=(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y); | (2) | (since C++11)
template<class T1, class D1, class T2, class D2> bool operator<(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y); | (3) | (since C++11)
template<class T1, class D1, class T2, class D2> bool operator<=(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y); | (4) | (since C++11)
template<class T1, class D1, class T2, class D2> bool operator>(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y); | (5) | (since C++11)
template<class T1, class D1, class T2, class D2> bool operator>=(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y); | (6) | (since C++11)
template <class T, class D> bool operator==(const unique_ptr<T, D>& x, nullptr_t) noexcept; | (7) | (since C++11)
template <class T, class D> bool operator==(nullptr_t, const unique_ptr<T, D>& x) noexcept; | (8) | (since C++11)
template <class T, class D> bool operator!=(const unique_ptr<T, D>& x, nullptr_t) noexcept; | (9) | (since C++11)
template <class T, class D> bool operator!=(nullptr_t, const unique_ptr<T, D>& x) noexcept; | (10) | (since C++11)
template <class T, class D> bool operator<(const unique_ptr<T, D>& x, nullptr_t); | (11) | (since C++11)
template <class T, class D> bool operator<(nullptr_t, const unique_ptr<T, D>& y); | (12) | (since C++11)
template <class T, class D> bool operator<=(const unique_ptr<T, D>& x, nullptr_t); | (13) | (since C++11)
template <class T, class D> bool operator<=(nullptr_t, const unique_ptr<T, D>& y); | (14) | (since C++11)
template <class T, class D> bool operator>(const unique_ptr<T, D>& x, nullptr_t); | (15) | (since C++11)
template <class T, class D> bool operator>(nullptr_t, const unique_ptr<T, D>& y); | (16) | (since C++11)
template <class T, class D> bool operator>=(const unique_ptr<T, D>& x, nullptr_t); | (17) | (since C++11)
template <class T, class D> bool operator>=(nullptr_t, const unique_ptr<T, D>& y); | (18) | (since C++11)

Compares the pointer values of two `unique_ptr`s, or a `unique_ptr` and nullptr.

1-6) Compares two `unique_ptr`s
7-18) Compares a `unique_ptr` and nullptr.

### Parameters

x, y | - | `unique_ptr`s to compare

### Return value

1) x.get() == y.get()

2) x.get() != y.get()

3) std::less<CT>()(x.get(), y.get()), where `CT` is std::common_type<unique_ptr<T1, D1>::pointer, unique_ptr<T2, D2>::pointer>::type

4) !(y < x)

5) y < x

6) !(x < y)

7-8) !x

9-10) (bool)x

11) std::less<unique_ptr<T,D>::pointer>()(x.get(), nullptr)

12) std::less<unique_ptr<T,D>::pointer>()(nullptr, y.get())

13) nullptr < x

14) y < nullptr

15) !(nullptr < x)

16) !(y < nullptr)

17) !(x < nullptr)

18) !(nullptr < y)

### Example

Run this code

    #include <iostream>
    #include <memory>

    int main()
    {
        std::unique_ptr<int> p1(new int(42));
        std::unique_ptr<int> p2(new int(42));

        std::cout << "p1 == p1: " << (p1 == p1) << '\n';

        // p1 and p2 point to different memory locations, so p1 != p2
        std::cout << "p1 == p2: " << (p1 == p2) << '\n';
    }

Output:

    p1 == p1: 1
    p1 == p2: 0

### See also

get | returns a pointer to the managed object (public member function)

Retrieved from "http://en.cppreference.com/mwiki/index.php?title=cpp/memory/unique_ptr/operator_cmp&oldid=62797"