home | help 
std::move_iterator(3)	       C++ Standard Libary	   std::move_iterator(3)

NAME
     std::move_iterator - std::move_iterator

Synopsis
	Defined in header <iterator>
	template< class Iter >	      (since C++11)
	class move_iterator;

	std::move_iterator is an iterator adaptor which behaves exactly like the
     underlying
	iterator (which must be at least a LegacyInputIterator
	or model input_iterator
	(since C++20)
	, or stronger iterator concept
	(since C++23)), except that dereferencing converts the value returned by
     the
	underlying iterator into an rvalue. If this iterator is used as an input
     iterator,
	the effect is that the values are moved from, rather than copied from.

Member functions
	constructor		     constructs a new iterator adaptor
	(C++11) 		     (public member function)
	operator=		     assigns another iterator adaptor
	(C++11) 		     (public member function)
	base			     accesses the underlying iterator
	(C++11) 		     (public member function)
	operator*
	operator->		     accesses the pointed-to element
	(C++11) 		     (public member function)
	(C++11)(deprecated in C++20)
	operator[]		     accesses an element by index
	(C++11) 		     (public member function)
	operator++
	operator++(int)
	operator+=
	operator+		     advances or decrements the iterator
	operator--		     (public member function)
	operator--(int)
	operator-=
	operator-
	(C++11)

Non-member functions
	operator==
	operator!=
	operator<
	operator<=
	operator>
	operator>=
	operator<=>		       compares the underlying iterators
	(C++11) 		       (function template)
	(C++11)(removed in C++20)
	(C++11)
	(C++11)
	(C++11)
	(C++11)
	(C++20)
	operator==(std::move_sentinel)	compares the underlying iterator and the
     underlying
	(C++20) 		       sentinel
				       (function template)
	operator+		       advances the iterator
	(C++11) 		       (function template)
	operator-		       computes the distance between two  itera-
     tor adaptors
	(C++11) 		       (function template)
	operator-(std::move_sentinel)	computes the distance between the under-
     lying iterator
	(C++20) 		       and the underlying sentinel
				       (function template)
	iter_move		       casts the result of dereferencing the un-
     derlying
	(C++20) 		       iterator to its associated rvalue  refer-
     ence type
				       (function)
	iter_swap			swaps  the objects pointed to by two un-
     derlying
	(C++20) 		       iterators
				       (function template)
	make_move_iterator	       creates a std::move_iterator of type  in-
     ferred from
	(C++11) 		       the argument
				       (function template)

	Helper templates

	template< class Iterator1, class Iterator2 >

	    requires (!std::sized_sentinel_for<Iterator1, Iterator2>)
	constexpr  bool  disable_sized_sentinel_for<			  (since
     C++20)
	    std::move_iterator<Iterator1>,

	    std::move_iterator<Iterator2>> = true;

	This partial specialization of std::disable_sized_sentinel_for prevents
	specializations of move_iterator from satisfying  sized_sentinel_for  if
     their
	underlying iterators do not satisfy the concept.

Notes
	      Feature-test macro	 Value	  Std		      Feature
	__cpp_lib_move_iterator_concept  202207L  (C++23)  Make std::move_itera-
     tor<T*> a random
							access iterator

Example
     // Run this code

      #include <algorithm>
      #include <iomanip>
      #include <iostream>
      #include <iterator>
      #include <ranges>
      #include <string>
      #include <string_view>
      #include <vector>

      void print(const std::string_view rem, const auto& v)
      {
	  std::cout << rem;
	  for (const auto& s : v)
	      std::cout << std::quoted(s) << ' ';
	  std::cout << '\n';
      };

      int main()
      {
	  std::vector<std::string> v{"this", "_", "is", "_", "an",  "_",  "exam-
     ple"};
	  print("Old contents of the vector: ", v);
	  std::string concat;
	  for (auto begin = std::make_move_iterator(v.begin()),
		    end = std::make_move_iterator(v.end());
	       begin != end; ++begin)
	  {
	      std::string temp{*begin}; // moves the contents of *begin to temp
	      concat += temp;
	  }

	  //  Starting	from C++17, which introduced class template argument de-
     duction,
	  // the constructor of std::move_iterator can be used directly:
	  // std::string concat = std::accumulate(std::move_iterator(v.begin()),
	  //					  std::move_iterator(v.end()),
	  //					  std::string());

	  print("New contents of the vector: ", v);
	  print("Concatenated as string: ", std::ranges::single_view(concat));
      }

Possible output:
      Old contents of the vector: "this" "_" "is" "_" "an" "_" "example"
      New contents of the vector: "" "" "" "" "" "" ""
      Concatenated as string: "this_is_an_example"

	Defect reports

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

	   DR	  Applied		Behavior as published		    Cor-
     rect behavior
		   to
			 dereferencing a move_iterator could return a
	LWG 2106 C++11	 dangling  reference				     re-
     turns the
			 if  the  dereferencing the underlying iterator      ob-
     ject instead
			 returns a prvalue
	LWG 3736 C++20	 move_iterator was missing			   added
			 disable_sized_sentinel_for specialization
			 member iterator_category was defined even if	   iter-
     ator_category
	P2259R1  C++20	 std::iterator_traits<Iter>::iterator_category is  is
			 not  defined					     not
     defined in
									   this
     case

See also
	make_move_iterator  creates  a	std::move_iterator of type inferred from
     the argument
	(C++11) 	   (function template)
	move_sentinel	   sentinel adaptor for use with std::move_iterator
	(C++20) 	   (class template)

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