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

NAME
     std::move_backward - std::move_backward

Synopsis
	template<  class  BidirIt1,  class  BidirIt2  > 		  (since
     C++11)
	BidirIt2 move_backward( BidirIt1 first, BidirIt1 last,	      (constexpr
     since C++20)
	BidirIt2 d_last );

	Moves the elements from the range [first, last), to another range ending
     at d_last.
	The  elements  are  moved  in  reverse	order (the last element is moved
     first), but their
	relative order is preserved.

	If d_last is within (first, last], the behavior is  undefined.	In  this
     case,
	std::move may be used instead.

Parameters
	first, last	      - 	  the range of the elements to move
	d_last		      - 	  end of the destination range

Type requirements
	-
	BidirIt1,  BidirIt2 must meet the requirements of LegacyBidirectionalIt-
     erator.

Return value
	Iterator in the destination range, pointing at the last element moved.

Complexity
	Exactly std::distance(first, last) move assignments.

Possible implementation
	template<class BidirIt1, class BidirIt2>
	BidirIt2 move_backward(BidirIt1 first, BidirIt1 last, BidirIt2 d_last)
	{
	    while (first != last)
		*(--d_last) = std::move(*(--last));

	    return d_last;
	}

Notes
	When moving overlapping ranges, std::move is appropriate when moving  to
     the left
	(beginning of the destination range is outside the source range) while
	std::move_backward  is	appropriate when moving to the right (end of the
     destination
	range is outside the source range).

Example
     // Run this code

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

      using container = std::vector<std::string>;

      void print(std::string_view comment,  const  container&  src,  const  con-
     tainer& dst = {})
      {
	  auto prn = [](std::string_view name, const container& cont)
	  {
	      std::cout << name;
	      for (const auto &s : cont)
		  std::cout << (s.empty() ? "a" : s.data()) << ' ';
	      std::cout << '\n';
	  };
	  std::cout << comment << '\n';
	  prn("src: ", src);
	  if (dst.empty())
	      return;
	  prn("dst: ", dst);
      }

      int main()
      {
	  container src{"foo", "bar", "baz"};
	  container dst{"qux", "quux", "quuz", "corge"};
	  print("Non-overlapping case; before move_backward:", src, dst);
	  std::move_backward(src.begin(), src.end(), dst.end());
	  print("After:", src, dst);

	  src = {"snap", "crackle", "pop", "lock", "drop"};
	  print("Overlapping case; before move_backward:", src);
	  std::move_backward(src.begin(), std::next(src.begin(), 3), src.end());
	  print("After:", src);
      }

Output:
      Non-overlapping case; before move_backward:
      src: foo bar baz
      dst: qux quux quuz corge
      After:
      src: a a a
      dst: qux foo bar baz
      Overlapping case; before move_backward:
      src: snap crackle pop lock drop
      After:
      src: a a snap crackle pop

See also
	move		      moves a range of elements to a new location
	(C++11) 	      (function template)
	ranges::move_backward  moves  a  range	of elements to a new location in
     backwards order
	(C++20) 	      (niebloid)

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