Namespaces
Variants

    std::destroy

    From cppreference.com
     
    C++
     
    Algorithm library
    Constrained algorithms and algorithms on ranges (C++20)
    Constrained algorithms, e.g. ranges::copy, ranges::sort, ...
    Non-modifying sequence operations    
    Batch operations
    (C++17)
    Search operations
    Modifying sequence operations
    Copy operations
    (C++11)
    (C++11)
    (C++11)
    Swap operations
    Transformation operations
    Generation operations
    Removing operations
    Order-changing operations
    (until C++17)(C++11)
    (C++20)(C++20)
    Sampling operations
    (C++17)

    Sorting and related operations
    Partitioning operations
    (C++11)    
    (C++11)

    Sorting operations
    Binary search operations
    (on partitioned ranges)
    Set operations (on sorted ranges)
    Merge operations (on sorted ranges)
    Heap operations
    Minimum/maximum operations
    (C++11)
    (C++17)
    Lexicographical comparison operations
    (C++20)
    Permutation operations


     
    Specialized <memory> algorithms
    Helper templates (exposition only*)
    (C++17)
    Object (batch) construction
    Object (batch) destruction
    (C++17)
    (C++17)
    (C++17)
     
    Defined in header <memory> 
    template< class ForwardIt >
void destroy( ForwardIt first, ForwardIt last );
    		(1) (since C++17)
    (until C++20)    		 
    template< class ForwardIt >
constexpr void destroy( ForwardIt first, ForwardIt last );
    		(since C++20) 
    template< class ExecutionPolicy, class ForwardIt >
void destroy( ExecutionPolicy&& policy, ForwardIt first, ForwardIt last );
    		(2) (since C++17)
    1) Destroys elements in the target range [first, last) as if by 
    for (; first != last; ++first)
    std::destroy_at(std::addressof(*first));
    2) Same as (1), but executed according to policy.
    This overload participates in overload resolution only if the value of the following expression is true:

    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)

    Parameters

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

    Exceptions

    2) During the execution process:
    • If the temporary memory resources required for parallelization are not available, std::bad_alloc is thrown.
    • If an uncaught exception is thrown while accessing objects via an algorithm argument, the behavior is determined by the execution policy (for standard policies, std::terminate is invoked).

    Possible implementation

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

    Example

    The following example demonstrates how to use destroy 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) unsigned char 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 destructed
1 destructed
2 destructed
3 destructed
4 destructed
5 destructed
6 destructed
7 destructed

    See also

    (C++17)
    		 destroys a number of objects in a range
    (function template & algorithm function object)[edit]
    (C++20)
    (C++17)
    		 destroys an object at a given address
    (function template & algorithm function object)[edit]
    (C++20)
    (C++20)
    		 destroys a range of objects
    (algorithm function object)[edit]