std::hive

template<
    class T,
    class Allocator = std::allocator<T>
> class hive;

namespace pmr {
    template<class T>
    using hive = std::hive<T, std::pmr::polymorphic_allocator<T>>;
}

The hive automatically manages its storage in multiple memory blocks (element blocks). Insertion position is unspecified, so the container can reuse the memory locations of erased elements.

When active blocks (element blocks that contain elements) become empty, they can be either deallocated or become reserved blocks.

Reserved blocks become active blocks when they are reused to store elements. A user can create additional reserved blocks by calling reserve().

Erasure and iteration both have constant‑time complexity.

The capacity of each active block grows by an implementation‑defined factor (e.g., by 1.69). Both users and implementations can limit the minimum and maximum element capacities of element blocks.

A std::hive conforms to the requirements of Container, with the exception of operators == and !=. A std::hive also meets the requirements of ReversibleContainer, of AllocatorAwareContainer, and some of the requirements of SequenceContainer.

Template parameters

Member types

Data members

Member functions

Non-member functions

Helper classes

Notes

Example

#include <chrono>
#include <hive>
#include <iomanip>
#include <iostream>
#include <list>

int main()
{
    constexpr auto iterations{10'000'000};
    auto benchmark = [=](auto& container, auto rem)
    {
        const auto t0{std::chrono::system_clock::now()};
        auto it{container.cbegin()};
        for (auto n{0}; n != iterations; ++n)
            container.insert(it, n);
        while (container.size())
            container.erase(container.begin());
        const std::chrono::duration<double> diff{std::chrono::system_clock::now() - t0};
        std::cout << std::fixed << std::setprecision(3) << diff << rem << std::endl;
    };

    std::list<std::size_t> list;
    benchmark(list, " (cold list)");
    benchmark(list, " (warm list)");

    std::hive<std::size_t> hive;
    benchmark(hive, " (cold hive)");
    benchmark(hive, " (warm hive)");
}

0.684s (cold list)
0.481s (warm list)
0.302s (cold hive)
0.176s (warm hive)

See also

External links