Movatterモバイル変換

[0]ホーム
URL:

cppreference.com
Namespaces
Variants
    Actions

      std::uninitialized_move_n

      From cppreference.com
      <cpp‎ |memory
       
       
      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)
       
      Defined in header<memory>
      template<class InputIt,class Size,class NoThrowForwardIt>

      std::pair<InputIt, NoThrowForwardIt>
          uninitialized_move_n( InputIt first, Size count,

                                NoThrowForwardIt d_first);
      		 (1)(since C++17)
      (constexpr since C++26)
      template<class ExecutionPolicy,

               class ForwardIt,class Size,class NoThrowForwardIt>
      std::pair<ForwardIt, NoThrowForwardIt>
          uninitialized_move_n( ExecutionPolicy&& policy, ForwardIt first,

                                Size count, NoThrowForwardIt d_first);
      		 (2)(since C++17)
      1) Copies the elements fromfirst + [​0​, count) (using move semantics if supported) to an uninitialized memory area beginning atd_first as if by

      for(; count>0;++d_first,(void)++first,--count)
          ::new(voidify(*d_first))
              typenamestd::iterator_traits<NoThrowForwardIt>::value_type(/* value */);
      return{first, d_first};

      where/* value */ isstd::move(*first) if*first is of an lvalue reference type, or*first otherwise.
      If an exception is thrown during the initialization, some objects infirst + [​0​, count) are left in a valid but unspecified state, and the objects already constructed are destroyed in an unspecified order.
      2) Same as(1), but executed according topolicy.
      This overload participates in overload resolution only if all following conditions are satisfied:

      std::is_execution_policy_v<std::decay_t<ExecutionPolicy>> istrue.

      		(until C++20)

      std::is_execution_policy_v<std::remove_cvref_t<ExecutionPolicy>> istrue.

      		(since C++20)


      Ifd_first + [​0​, count) overlaps withfirst + [​0​, count), the behavior is undefined.

      		(since C++20)

      Contents

      [edit]Parameters

      first - the beginning of the range of the elements to move
      d_first - the beginning of the destination range
      count - the number of elements to move
      policy - theexecution policy to use
      Type requirements
      -
      InputIt must meet the requirements ofLegacyInputIterator.
      -
      ForwardIt must meet the requirements ofLegacyForwardIterator.
      -
      NoThrowForwardIt must meet the requirements ofLegacyForwardIterator.
      -
      No increment, assignment, comparison, or indirection through valid instances ofNoThrowForwardIt may throw exceptions.

      [edit]Return value

      As described above.

      [edit]Complexity

      Linear incount.

      [edit]Exceptions

      The overload with a template parameter namedExecutionPolicy reports errors as follows:

      • If execution of a function invoked as part of the algorithm throws an exception andExecutionPolicy is one of thestandard policies,std::terminate is called. For any otherExecutionPolicy, the behavior is implementation-defined.
      • If the algorithm fails to allocate memory,std::bad_alloc is thrown.

      [edit]Notes

      When the input iterator deferences to an rvalue, the behavior ofstd::uninitialized_move_n is same asstd::uninitialized_copy_n.

      Feature-test macroValueStdFeature
      __cpp_lib_raw_memory_algorithms202411L(C++26)constexpr forspecialized memory algorithms,(1)

      [edit]Possible implementation

      template<class InputIt,class Size,class NoThrowForwardIt>constexprstd::pair<InputIt, NoThrowForwardIt>    uninitialized_move_n(InputIt first, Size count, NoThrowForwardIt d_first){using ValueType=typenamestd::iterator_traits<NoThrowForwardIt>::value_type;    NoThrowForwardIt current= d_first;try{for(; count>0;++first,(void)++current,--count){auto addr=static_cast<void*>(std::addressof(*current));ifconstexpr(std::is_lvalue_reference_v<decltype(*first)>)::new(addr) ValueType(std::move(*first));else::new(addr) ValueType(*first);}}catch(...){std::destroy(d_first, current);throw;}return{first, current};}

      [edit]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(constexprauto 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"

      [edit]Defect reports

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

      DRApplied toBehavior as publishedCorrect behavior
      LWG 3870C++20this algorithm might create objects on aconst storagekept disallowed
      LWG 3918C++17additional temporary materialization was required
      when the input iterator deferences to a prvalue      		copies the element in this case

      [edit]See also

      moves a range of objects to an uninitialized area of memory
      (function template)[edit]
      copies a number of objects to an uninitialized area of memory
      (function template)[edit]
      moves a number of objects to an uninitialized area of memory
      (algorithm function object)[edit]
      Retrieved from "https://en.cppreference.com/mwiki/index.php?title=cpp/memory/uninitialized_move_n&oldid=179697"
      [8]ページ先頭
      ©2009-2025 Movatter.jp