Movatterモバイル変換

[0]ホーム
URL:

cppreference.com
Namespaces
Variants
    Actions

      std::uninitialized_copy

      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_copy( InputIt first, InputIt last,

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

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

                                           NoThrowForwardIt d_first);
      		 (2)(since C++17)
      1) Copies elements from the range[first, last) 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(*first);

      If an exception is thrown during the initialization, 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​, std::distance(first, last)) overlaps with[first, last), the behavior is undefined.

      		(since C++20)

      Contents

      [edit]Parameters

      first, last - the pair of iterators defining therange of elements to copy
      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. Applying&* to aNoThrowForwardIt value must yield a pointer to its value type.(until C++11)

      [edit]Return value

      Iterator to the element past the last element copied.

      [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

      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_copy(InputIt first, InputIt last,                                              NoThrowForwardIt d_first){using T=typenamestd::iterator_traits<NoThrowForwardIt>::value_type;    NoThrowForwardIt current= d_first;try{for(; first!= last;++first,(void)++current)::new(static_cast<void*>(std::addressof(*current))) T(*first);return current;}catch(...){for(; d_first!= current;++d_first)            d_first->~T();throw;}}

      [edit]Example

      Run this code
      #include <cstdlib>#include <iostream>#include <memory>#include <string> int main(){constchar*v[]={"This","is","an","example"}; auto sz=std::size(v); if(void*pbuf=std::aligned_alloc(alignof(std::string), sizeof(std::string)* sz)){try{auto first=static_cast<std::string*>(pbuf);auto last= std::uninitialized_copy(std::begin(v),std::end(v), first); for(auto it= first; it!= last;++it)std::cout<<*it<<'_';std::cout<<'\n'; std::destroy(first, last);}catch(...){}std::free(pbuf);}}

      Output:

      This_is_an_example_

      [edit]Defect reports

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

      DRApplied toBehavior as publishedCorrect behavior
      LWG 866C++98givenT as the value type ofNoThrowForwardIt, if
      T::operator new exists, the program might be ill-formed      		uses global replacement-
      new instead
      LWG 2133C++98the effect description used afor loop with the iteration
      expression++d_first,++first, which results
      in an argument-dependent lookup ofoperator,      		discards the value
      of one operand
      to disable that ADL
      LWG 2433C++11this algorithm might be hijacked by overloadedoperator&usesstd::addressof
      LWG 3870C++20this algorithm might create objects on aconst storagekept disallowed

      [edit]See also

      copies a number of objects to an uninitialized area of memory
      (function template)[edit]
      copies 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_copy&oldid=180308"
      [8]ページ先頭
      ©2009-2025 Movatter.jp