home | help 
std::shared...owner_before(3)  C++ Standard Libary std::shared...owner_before(3)

NAME
     std::shared_ptr::owner_before - std::shared_ptr::owner_before

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

	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 ob-
     ject, 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.

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

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

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

	Defect reports

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

	   DR	 Applied to	    Behavior as published	    Correct  be-
     havior
	LWG  2873  C++11       owner_before  was  not declared noexcept declared
     noexcept

See also
	owner_less provides mixed-type owner-based ordering of shared  and  weak
     pointers
	(C++11)    (class template)

http://cppreference.com 	   2024.06.10	   std::shared...owner_before(3)
home | help