Movatterモバイル変換


[0]ホーム

URL:


cppreference.com
Namespaces
Variants
    Actions

      std::uninitialized_move

      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 NoThrowForwardIt>

      NoThrowForwardIt uninitialized_move( InputIt first, InputIt last,

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

               class ForwardIt,class NoThrowForwardIt>
      NoThrowForwardIt uninitialized_move( ExecutionPolicy&& policy,
                                           ForwardIt first, ForwardIt last,

                                           NoThrowForwardIt d_first);
      (2)(since C++17)
      1) Copies the elements from[firstlast) (using move semantics if supported) to an uninitialized memory area beginning atd_first as if by

      for(; first!= last;++d_first,(void)++first)
          ::new(voidify(*d_first))
              typenamestd::iterator_traits<NoThrowForwardIt>::value_type(/* value */);
      return 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 in[firstlast) 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 + [0std::distance(first, last)) overlaps with[firstlast), the behavior is undefined.

      (since C++20)

      Contents

      [edit]Parameters

      first, last - the pair of iterators defining therange of elements to move
      d_first - the beginning of the destination range
      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 in the distance betweenfirst andlast.

      [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 is same asstd::uninitialized_copy.

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

      [edit]Possible implementation

      template<class InputIt,class NoThrowForwardIt>constexpr NoThrowForwardIt uninitialized_move(InputIt first, InputIt last,                                              NoThrowForwardIt d_first){using ValueType=typenamestd::iterator_traits<NoThrowForwardIt>::value_type;auto current= d_first;try{for(; first!= last;++first,(void)++current){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);}return current;}catch(...){std::destroy(d_first, current);throw;}}

      [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[]{"Home","Work!"};    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(std::begin(in),std::end(in), 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: "Home" "Work!"after move, in: "" ""after move, out: "Home" "Work!"

      [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

      copies a range of objects to an uninitialized area of memory
      (function template)[edit]
      moves a number of objects to an uninitialized area of memory
      (function template)[edit]
      moves a range 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&oldid=180305"

      [8]ページ先頭

      ©2009-2025 Movatter.jp