Movatterモバイル変換


[0]ホーム

URL:


cppreference.com
Namespaces
Variants
    Actions

      std::destroy

      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 ForwardIt>
      void destroy( ForwardIt first, ForwardIt last);
      (1)(since C++17)
      (constexpr since C++20)
      template<class ExecutionPolicy,class ForwardIt>
      void destroy( ExecutionPolicy&& policy, ForwardIt first, ForwardIt last);
      (2)(since C++17)
      1) Destroys the objects in the range[firstlast), as if by
      for(; first!= last;++first)std::destroy_at(std::addressof(*first));
      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)

      Contents

      [edit]Parameters

      first, last - the pair of iterators defining therange of elements to destroy
      policy - theexecution policy to use
      Type requirements
      -
      ForwardIt must meet the requirements ofLegacyForwardIterator.
      -
      No increment, assignment, comparison, or indirection through valid instances ofForwardIt may throw exceptions.

      [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]Possible implementation

      template<class ForwardIt>constexpr// since C++20void destroy(ForwardIt first, ForwardIt last){for(; first!= last;++first)std::destroy_at(std::addressof(*first));}

      [edit]Example

      The following example demonstrates how to usedestroy to destroy a contiguous sequence of elements.

      Run this code
      #include <iostream>#include <memory>#include <new> struct Tracer{int value;    ~Tracer(){std::cout<< value<<" destructed\n";}}; int main(){    alignas(Tracer)unsignedchar buffer[sizeof(Tracer)*8]; for(int i=0; i!=8;++i)        new(buffer+ sizeof(Tracer)* i) Tracer{i};// manually construct objects auto ptr=std::launder(reinterpret_cast<Tracer*>(buffer));     std::destroy(ptr, ptr+8);}

      Output:

      0 destructed1 destructed2 destructed3 destructed4 destructed5 destructed6 destructed7 destructed

      [edit]See also

      (C++17)
      destroys a number of objects in a range
      (function template)[edit]
      (C++17)
      destroys an object at a given address
      (function template)[edit]
      destroys a range of objects
      (algorithm function object)[edit]
      Retrieved from "https://en.cppreference.com/mwiki/index.php?title=cpp/memory/destroy&oldid=183345"

      [8]ページ先頭

      ©2009-2025 Movatter.jp