Movatterモバイル変換

[0]ホーム
URL:

cppreference.com
Namespaces
Variants
    Actions

      operator==, !=, <, <=, >, >=, <=>(std::shared_ptr)

      From cppreference.com
      <cpp‎ |memory‎ |shared ptr
       
       
      Memory management library
      (exposition only*)
      Allocators
      Uninitialized memory algorithms
      Constrained uninitialized memory algorithms
      Memory resources
      Uninitialized storage(until C++20)
      (until C++20*)
      (until C++20*)
      Garbage collector support(until C++23)
      (C++11)(until C++23)
      (C++11)(until C++23)
      (C++11)(until C++23)
      (C++11)(until C++23)
      (C++11)(until C++23)
      (C++11)(until C++23)
       
      std::shared_ptr
      Member functions
      Modifiers
      Observers
      (until C++20*)
      Non-member functions
      operator==operator!=operator<operator<=operator>operator>=operator<=>
      (until C++20)(until C++20)(until C++20)(until C++20)(until C++20)(C++20)
      functions(until C++26*)
      Helper classes
      Deduction guides(C++17)
       
      Defined in header<memory>
      Compare twoshared_ptr objects.
      template<class T,class U>

      bool operator==(conststd::shared_ptr<T>& lhs,

                       conststd::shared_ptr<U>& rhs)noexcept;
      		 (1)(since C++11)
      template<class T,class U>

      bool operator!=(conststd::shared_ptr<T>& lhs,

                       conststd::shared_ptr<U>& rhs)noexcept;
      		 (2)(since C++11)
      (until C++20)
      template<class T,class U>

      bool operator<(conststd::shared_ptr<T>& lhs,

                     conststd::shared_ptr<U>& rhs)noexcept;
      		 (3)(since C++11)
      (until C++20)
      template<class T,class U>

      bool operator>(conststd::shared_ptr<T>& lhs,

                     conststd::shared_ptr<U>& rhs)noexcept;
      		 (4)(since C++11)
      (until C++20)
      template<class T,class U>

      bool operator<=(conststd::shared_ptr<T>& lhs,

                       conststd::shared_ptr<U>& rhs)noexcept;
      		 (5)(since C++11)
      (until C++20)
      template<class T,class U>

      bool operator>=(conststd::shared_ptr<T>& lhs,

                       conststd::shared_ptr<U>& rhs)noexcept;
      		 (6)(since C++11)
      (until C++20)
      template<class T,class U>

      std::strong_ordering operator<=>(conststd::shared_ptr<T>& lhs,

                                       conststd::shared_ptr<U>& rhs)noexcept;
      		 (7)(since C++20)
      Compare ashared_ptr with a null pointer.
      template<class T>
      bool operator==(conststd::shared_ptr<T>& lhs,std::nullptr_t)noexcept;
      		 (8)(since C++11)
      template<class T>
      bool operator==(std::nullptr_t,conststd::shared_ptr<T>& rhs)noexcept;
      		 (9)(since C++11)
      (until C++20)
      template<class T>
      bool operator!=(conststd::shared_ptr<T>& lhs,std::nullptr_t)noexcept;
      		 (10)(since C++11)
      (until C++20)
      template<class T>
      bool operator!=(std::nullptr_t,conststd::shared_ptr<T>& rhs)noexcept;
      		 (11)(since C++11)
      (until C++20)
      template<class T>
      bool operator<(conststd::shared_ptr<T>& lhs,std::nullptr_t)noexcept;
      		 (12)(since C++11)
      (until C++20)
      template<class T>
      bool operator<(std::nullptr_t,conststd::shared_ptr<T>& rhs)noexcept;
      		 (13)(since C++11)
      (until C++20)
      template<class T>
      bool operator>(conststd::shared_ptr<T>& lhs,std::nullptr_t)noexcept;
      		 (14)(since C++11)
      (until C++20)
      template<class T>
      bool operator>(std::nullptr_t,conststd::shared_ptr<T>& rhs)noexcept;
      		 (15)(since C++11)
      (until C++20)
      template<class T>
      bool operator<=(conststd::shared_ptr<T>& lhs,std::nullptr_t)noexcept;
      		 (16)(since C++11)
      (until C++20)
      template<class T>
      bool operator<=(std::nullptr_t,conststd::shared_ptr<T>& rhs)noexcept;
      		 (17)(since C++11)
      (until C++20)
      template<class T>
      bool operator>=(conststd::shared_ptr<T>& lhs,std::nullptr_t)noexcept;
      		 (18)(since C++11)
      (until C++20)
      template<class T>
      bool operator>=(std::nullptr_t,conststd::shared_ptr<T>& rhs)noexcept;
      		 (19)(since C++11)
      (until C++20)
      template<class T>

      std::strong_ordering operator<=>(conststd::shared_ptr<T>& lhs,

                                       std::nullptr_t)noexcept;
      		 (20)(since C++20)

      Compares twoshared_ptr<T> objects or comparesshared_ptr<T> with a null pointer.

      Note that the comparison operators forshared_ptr simply compare pointer values; the actual objects pointed to arenot compared. Havingoperator< defined forshared_ptr allowsshared_ptrs to be used as keys in associative containers, likestd::map andstd::set.

      The<,<=,>,>=, and!= operators aresynthesized fromoperator<=> andoperator== respectively.

      		(since C++20)

      Contents

      [edit]Parameters

      lhs - the left-handshared_ptr to compare
      rhs - the right-handshared_ptr to compare

      [edit]Return value

      1)lhs.get()== rhs.get()
      2)!(lhs== rhs)
      3)std::less<V>()(lhs.get(), rhs.get()), where V is thecomposite pointer type ofstd::shared_ptr<T>::element_type* andstd::shared_ptr<U>::element_type*.
      4)rhs< lhs
      5)!(rhs< lhs)
      6)!(lhs< rhs)
      7)std::compare_three_way{}(x.get(), y.get())
      8)!lhs
      9)!rhs
      10)(bool)lhs
      11)(bool)rhs
      12)std::less<std::shared_ptr<T>::element_type*>()(lhs.get(), nullptr)
      13)std::less<std::shared_ptr<T>::element_type*>()(nullptr, rhs.get())
      14)nullptr< lhs
      15)rhs< nullptr
      16)!(nullptr< lhs)
      17)!(rhs< nullptr)
      18)!(lhs< nullptr)
      19)!(nullptr< rhs)
      20)std::compare_three_way{}(x.get(),static_cast<std::shared_ptr<T>::element_type*>(nullptr))

      [edit]Notes

      In all cases, it is the stored pointer (the one returned byget()) that is compared, rather than the managed pointer (the one passed to the deleter whenuse_count goes to zero). The two pointers may differ in ashared_ptr created using the aliasing constructor.

      [edit]Example

      Run this code
      #include <iostream>#include <memory> int main(){std::shared_ptr<int> p1(newint(42));std::shared_ptr<int> p2(newint(42)); std::cout<<std::boolalpha<<"(p1 == p1)       : "<<(p1== p1)<<'\n'<<"(p1 <=> p1) == 0 : "<<((p1<=> p1)==0)<<'\n'// Since C++20 // p1 and p2 point to different memory locations, so p1 != p2<<"(p1 == p2)       : "<<(p1== p2)<<'\n'<<"(p1 < p2)        : "<<(p1< p2)<<'\n'<<"(p1 <=> p2) < 0  : "<<((p1<=> p2)<0)<<'\n'// Since C++20<<"(p1 <=> p2) == 0 : "<<((p1<=> p2)==0)<<'\n';// Since C++20}

      Possible output:

      (p1 == p1)       : true(p1 <=> p1) == 0 : true(p1 == p2)       : false(p1 < p2)        : true(p1 <=> p2) < 0  : true(p1 <=> p2) == 0 : false

      [edit]Defect reports

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

      DRApplied toBehavior as publishedCorrect behavior
      LWG 3427C++20operator<=>(shared_ptr, nullptr_t) was ill-formeddefinition fixed

      [edit]See also

      returns the stored pointer
      (public member function)[edit]
      Retrieved from "https://en.cppreference.com/mwiki/index.php?title=cpp/memory/shared_ptr/operator_cmp&oldid=153804"
      [8]ページ先頭
      ©2009-2025 Movatter.jp