std::ranges::destroy() 算法

自 C++20 起

简化

// (1)
constexpr I destroy( I first, S last ) noexcept;

// (2)
constexpr ranges::borrowed_iterator_t<R> destroy( R&& r ) noexcept;

参数类型是泛型的，并具有以下约束：

• I - no-throw-input-iterator
• S - no-throw-sentinel-for<O>
• R - no-throw-input-range

此外，每个重载都有以下约束

• (1) std::destructible<std::iter_value_t<I>>
• (1) std::destructible<ranges::range_value_t<R>>

详细

// (1)
template< no-throw-input-iterator I, no-throw-sentinel-for<I> S
  requires std::destructible<std::iter_value_t<I>>
constexpr I destroy( I first, S last ) noexcept;

// (2)
template< no-throw-input-range R >
  requires std::destructible<ranges::range_value_t<R>>
constexpr ranges::borrowed_iterator_t<R> destroy( R&& r ) noexcept;

• (1) 销毁范围 [first; last) 中的对象，如同通过

  for (; first != last; ++first)
      std::ranges::destroy_at(std::addressof(*first));
  
  return first;
  注意

  如果在初始化期间抛出异常，则已在 [ofirst; olast) 中构造的对象将以未指定顺序销毁。

  此外，已移动的 [ifirst; ilast) 中的对象将处于有效但未指定的状态。

• (2) 同 (1)，但使用 in_range 作为第一个范围，out_range 作为第二个范围，如同使用 ranges::begin(in_range) 作为 ifirst，ranges::end(in_range) 作为 ilast，ranges::begin(out_range) 作为 ofirst，以及 ranges::end(out_range) 作为 olast。

本页描述的函数类实体是niebloids。

参数

first last	要销毁的元素范围。
r	要销毁的元素范围。

返回值

与 last 相等的迭代器。

复杂度

与 first 和 last 之间的距离成线性关系。

异常

构造目标范围中的元素时抛出的异常（如果有）。

可能的实现

destroy(1) 和 destroy(2)

struct destroy_fn
{
    template<no-throw-input-iterator I, no-throw-sentinel-for<I> S>
        requires std::destructible<std::iter_value_t<I>>
    constexpr I operator()(I first, S last) const noexcept
    {
        for (; first != last; ++first)
            std::ranges::destroy_at(std::addressof(*first));
        return first;
    }

    template<no-throw-input-range R>
        requires std::destructible<std::ranges::range_value_t<R>>
    constexpr std::ranges::borrowed_iterator_t<R> operator()(R&& r) const noexcept
    {
        return operator()(std::ranges::begin(r), std::ranges::end(r));
    }
};

inline constexpr destroy_fn destroy{};

示例

Main.cpp

#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::ranges::destroy(ptr, ptr + 8);
}

输出

0 destructed
1 destructed
2 destructed
3 destructed
4 destructed
5 destructed
6 destructed
7 destructed