Skip site navigation (1)Skip section navigation (2)

FreeBSD Manual Pages

  
 
  

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

NAME
       std::uninitialized_move_n - std::uninitialized_move_n

Synopsis
	  Defined in header <memory>
	  template< class InputIt, class Size, class NoThrowForwardIt >

	  std::pair<InputIt,				     NoThrowForwardIt>
       (1) (since C++17)

	  uninitialized_move_n(	InputIt	first, Size count, NoThrowForwardIt
	  d_first );
	  template< class ExecutionPolicy, class ForwardIt, class Size,
	  class	NoThrowForwardIt >

	  std::pair<ForwardIt,				     NoThrowForwardIt>
       (2) (since C++17)
	  uninitialized_move_n(	ExecutionPolicy&& policy, ForwardIt first,
	  Size count,

	  NoThrowForwardIt d_first );

	  1) Moves count elements from a range beginning at first to an	unini-
       tialized	memory
	  area beginning at d_first as if by

	for ( ;	n > 0; ++d_first, (void) ++first, --n)
	   ::new (/*VOIDIFY*/(*d_first))
	      typename			      std::iterator_traits<NoThrowFor-
       wardIt>::value_type(std::move(*first));

	  where	/*VOIDIFY*/(e) is:

	     static_cast<void*>(std::addressof(e))
       (until C++20)
	     const_cast<void*>(static_cast<const		      volatile
       (since C++20)
	     void*>(std::addressof(e)))

	  If an	exception is thrown during the initialization, some objects in
       the source
	  range	are left in a valid but	unspecified state, and the objects al-
       ready constructed
	  are destroyed	in an unspecified order.
	  2) Same as (1), but executed according to policy. This overload does
       not participate
	  in overload resolution unless
	  std::is_execution_policy_v<std::decay_t<ExecutionPolicy>>
	  (until C++20)
	  std::is_execution_policy_v<std::remove_cvref_t<ExecutionPolicy>>
	  (since C++20)	is true.

Parameters
	  first		     -		the beginning of the range of the ele-
       ments to	move
	  d_first	     -		the beginning of the destination range
	  count		     -		the number of elements to move
	  policy	      -		 the execution policy to use. See exe-
       cution policy for
					details.

Type requirements
	  -
	  InputIt must meet the	requirements of	LegacyInputIterator.
	  -
	  ForwardIt must meet the requirements of LegacyForwardIterator.
	  -
	  NoThrowForwardIt must	meet the requirements  of  LegacyForwardItera-
       tor.
	  -
	  No  increment,  assignment, comparison, or indirection through valid
       instances of
	  NoThrowForwardIt may throw exceptions.

Return value
	  A pair whose first element is	an iterator to the  element  past  the
       last element moved
	  in  the source range,	and whose second element is an iterator	to the
       element past the
	  last element moved in	the destination	range.

Complexity
	  Linear in count.

Exceptions
	  The overload with a template parameter named ExecutionPolicy reports
       errors as
	  follows:

	    * If execution of a	function invoked  as  part  of	the  algorithm
       throws an exception
	      and ExecutionPolicy is one of the	standard policies, std::termi-
       nate is called.
	      For  any	other ExecutionPolicy, the behavior is implementation-
       defined.
	    * If the algorithm fails to	 allocate  memory,  std::bad_alloc  is
       thrown.

Possible implementation
	  template<class InputIt, class	Size, class NoThrowForwardIt>
	  std::pair<InputIt, NoThrowForwardIt>
	      uninitialized_move_n(InputIt first, Size count, NoThrowForwardIt
       d_first)
	  {
	      using    Value   =   typename   std::iterator_traits<NoThrowFor-
       wardIt>::value_type;
	      NoThrowForwardIt current = d_first;
	      try {
		  for (; count > 0; ++first, (void) ++current, --count)	{
		      ::new   (const_cast<void*>(static_cast<const    volatile
       void*>(
			  std::addressof(*current))))
       Value(std::move(*first));
		  }
	      }	catch (...) {
		  std::destroy(d_first,	current);
		  throw;
	      }
	      return {first, current};
	  }

Example
       // Run this code

	#include <cstdlib>
	#include <iomanip>
	#include <iostream>
	#include <memory>
	#include <string>

	void print(auto	rem, auto first, auto last) {
	    for	(std::cout << rem; first != last; ++first)
		std::cout << std::quoted(*first) << ' ';
	    std::cout << '\n';
	}

	int main() {
	    std::string	in[] { "One", "Definition", "Rule" };
	    print("initially, in: ", std::begin(in), std::end(in));

	    if (
		constexpr auto sz = std::size(in);
		void*	  out	 =    std::aligned_alloc(alignof(std::string),
       sizeof(std::string) * sz)
	    ) {
		try {
		    auto first {static_cast<std::string*>(out)};
		    auto last {first + sz};
		    std::uninitialized_move_n(std::begin(in), sz, first);

		    print("after move, in: ", std::begin(in), std::end(in));
		    print("after move, out: ", first, last);

		    std::destroy(first,	last);
		}
		catch (...) {
		    std::cout << "Exception!\n";
		}
		std::free(out);
	    }
	}

Possible output:
	initially, in: "One" "Definition" "Rule"
	after move, in:	"" "" ""
	after move, out: "One" "Definition" "Rule"

See also
	  uninitialized_move	       moves a range of	objects	to  an	unini-
       tialized	area of
	  (C++17)		       memory
				       (function template)
	  uninitialized_copy_n	       copies a	number of objects to an	unini-
       tialized	area of
	  (C++11)		       memory
				       (function template)
	  ranges::uninitialized_move_n	moves a	number of objects to an	unini-
       tialized	area of
	  (C++20)		       memory
				       (niebloid)

http://cppreference.com		  2022.07.31	  std::uninitialized_move_n(3)

Want to link to this manual page? Use this URL:
<https://man.freebsd.org/cgi/man.cgi?query=std::uninitialized_move_n&sektion=3&manpath=FreeBSD+Ports+15.0>

home | help