From 17f9f9d073e0a40a19561e5393e6c314dabee9bc Mon Sep 17 00:00:00 2001 From: Akira Takahashi Date: Wed, 29 Jul 2026 11:07:26 +0900 Subject: [PATCH] =?UTF-8?q?C++26=E5=AF=BE=E5=BF=9C=E3=81=A8=E3=81=97?= =?UTF-8?q?=E3=81=A6hive=E3=82=92=E8=BF=BD=E5=8A=A0=20(close=20#1429)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- GLOBAL_QUALIFY_LIST.txt | 1 + lang/cpp26.md | 2 +- lang/cpp26/feature_test_macros.md | 2 +- reference.md | 1 + reference/hive.md | 47 ++++ reference/hive/hive.md | 240 ++++++++++++++++++ reference/hive/hive/assign.md | 110 ++++++++ reference/hive/hive/assign_range.md | 75 ++++++ reference/hive/hive/begin.md | 77 ++++++ .../hive/block_capacity_default_limits.md | 67 +++++ .../hive/hive/block_capacity_hard_limits.md | 74 ++++++ reference/hive/hive/block_capacity_limits.md | 69 +++++ reference/hive/hive/capacity.md | 75 ++++++ reference/hive/hive/cbegin.md | 68 +++++ reference/hive/hive/cend.md | 70 +++++ reference/hive/hive/clear.md | 85 +++++++ reference/hive/hive/crbegin.md | 68 +++++ reference/hive/hive/crend.md | 70 +++++ reference/hive/hive/emplace.md | 95 +++++++ reference/hive/hive/emplace_hint.md | 95 +++++++ reference/hive/hive/empty.md | 72 ++++++ reference/hive/hive/end.md | 71 ++++++ reference/hive/hive/erase.md | 107 ++++++++ reference/hive/hive/erase_free.md | 77 ++++++ reference/hive/hive/erase_if_free.md | 88 +++++++ reference/hive/hive/get_allocator.md | 58 +++++ reference/hive/hive/get_iterator.md | 82 ++++++ reference/hive/hive/insert.md | 127 +++++++++ reference/hive/hive/insert_range.md | 90 +++++++ reference/hive/hive/is_within_hard_limits.md | 79 ++++++ reference/hive/hive/max_size.md | 65 +++++ reference/hive/hive/op_assign.md | 112 ++++++++ reference/hive/hive/op_constructor.md | 180 +++++++++++++ reference/hive/hive/op_deduction_guide.md | 89 +++++++ reference/hive/hive/op_destructor.md | 36 +++ reference/hive/hive/rbegin.md | 69 +++++ reference/hive/hive/rend.md | 71 ++++++ reference/hive/hive/reserve.md | 92 +++++++ reference/hive/hive/reshape.md | 98 +++++++ reference/hive/hive/shrink_to_fit.md | 93 +++++++ reference/hive/hive/size.md | 65 +++++ reference/hive/hive/sort.md | 83 ++++++ reference/hive/hive/splice.md | 89 +++++++ reference/hive/hive/swap.md | 93 +++++++ reference/hive/hive/swap_free.md | 77 ++++++ reference/hive/hive/trim_capacity.md | 83 ++++++ reference/hive/hive/unique.md | 87 +++++++ reference/hive/hive_limits.md | 84 ++++++ 48 files changed, 3806 insertions(+), 2 deletions(-) create mode 100644 reference/hive.md create mode 100644 reference/hive/hive.md create mode 100644 reference/hive/hive/assign.md create mode 100644 reference/hive/hive/assign_range.md create mode 100644 reference/hive/hive/begin.md create mode 100644 reference/hive/hive/block_capacity_default_limits.md create mode 100644 reference/hive/hive/block_capacity_hard_limits.md create mode 100644 reference/hive/hive/block_capacity_limits.md create mode 100644 reference/hive/hive/capacity.md create mode 100644 reference/hive/hive/cbegin.md create mode 100644 reference/hive/hive/cend.md create mode 100644 reference/hive/hive/clear.md create mode 100644 reference/hive/hive/crbegin.md create mode 100644 reference/hive/hive/crend.md create mode 100644 reference/hive/hive/emplace.md create mode 100644 reference/hive/hive/emplace_hint.md create mode 100644 reference/hive/hive/empty.md create mode 100644 reference/hive/hive/end.md create mode 100644 reference/hive/hive/erase.md create mode 100644 reference/hive/hive/erase_free.md create mode 100644 reference/hive/hive/erase_if_free.md create mode 100644 reference/hive/hive/get_allocator.md create mode 100644 reference/hive/hive/get_iterator.md create mode 100644 reference/hive/hive/insert.md create mode 100644 reference/hive/hive/insert_range.md create mode 100644 reference/hive/hive/is_within_hard_limits.md create mode 100644 reference/hive/hive/max_size.md create mode 100644 reference/hive/hive/op_assign.md create mode 100644 reference/hive/hive/op_constructor.md create mode 100644 reference/hive/hive/op_deduction_guide.md create mode 100644 reference/hive/hive/op_destructor.md create mode 100644 reference/hive/hive/rbegin.md create mode 100644 reference/hive/hive/rend.md create mode 100644 reference/hive/hive/reserve.md create mode 100644 reference/hive/hive/reshape.md create mode 100644 reference/hive/hive/shrink_to_fit.md create mode 100644 reference/hive/hive/size.md create mode 100644 reference/hive/hive/sort.md create mode 100644 reference/hive/hive/splice.md create mode 100644 reference/hive/hive/swap.md create mode 100644 reference/hive/hive/swap_free.md create mode 100644 reference/hive/hive/trim_capacity.md create mode 100644 reference/hive/hive/unique.md create mode 100644 reference/hive/hive_limits.md diff --git a/GLOBAL_QUALIFY_LIST.txt b/GLOBAL_QUALIFY_LIST.txt index c462dde5eb..8e1d8c8e5d 100644 --- a/GLOBAL_QUALIFY_LIST.txt +++ b/GLOBAL_QUALIFY_LIST.txt @@ -168,6 +168,7 @@ * identity[link /reference/functional/identity.md] * [link /reference/future.md] * [link /reference/generator.md] +* [link /reference/hive.md] * [link /reference/initializer_list.md] * std::initializer_list[link /reference/initializer_list/initializer_list.md] * il.begin()[link /reference/initializer_list/initializer_list/begin.md] diff --git a/lang/cpp26.md b/lang/cpp26.md index c8d3fe56d0..178737d173 100644 --- a/lang/cpp26.md +++ b/lang/cpp26.md @@ -133,7 +133,7 @@ C++26とは、2026年中に改訂される予定の、C++バージョンの通 ## ライブラリ更新の概要 ### 新ライブラリ - 文字列エンコーディングを識別するライブラリとして、[``](/reference/text_encoding.md)を追加 -- 要素のメモリ位置が安定するシーケンスコンテナのライブラリとして[``](/reference/hive.md.nolink)を追加 +- 要素のメモリ位置が安定するシーケンスコンテナのライブラリとして[``](/reference/hive.md)を追加 - 並行処理におけるデータの参照・更新を行うRCU (Read Copy Update) のライブラリとして、[``](/reference/rcu.md)を追加 - 並行処理において参照中のデータが更新されないよう保護するハザードポインタのライブラリとして、[``](/reference/hazard_pointer.md.nolink)を追加 - データ並列ライブラリとして、[``](/reference/simd.md.nolink)を追加 diff --git a/lang/cpp26/feature_test_macros.md b/lang/cpp26/feature_test_macros.md index d156de4c3b..8003430ecc 100755 --- a/lang/cpp26/feature_test_macros.md +++ b/lang/cpp26/feature_test_macros.md @@ -108,7 +108,7 @@ |`__cpp_lib_fstream_native_handle`|`202306L`|[`std::basic_fstream`](/reference/fstream/basic_fstream.md)などのメンバに、ファイルのネイティブハンドルを追加|[``](/reference/fstream.md)| |`__cpp_lib_function_ref`|`202604L`|[``](/reference/functional.md)に[`std::function_ref`](/reference/functional/function_ref.md)を追加|[``](/reference/functional.md)| |`__cpp_lib_hazard_pointer`|`202306L`|ハザードポインタのライブラリ[``](/reference/hazard_pointer.md.nolink)を追加|[``](/reference/hazard_pointer.md.nolink)| -|`__cpp_lib_hive`|`202502L`|シーケンスコンテナのライブラリ[``](/reference/hive.md.nolink)を追加|[``](/reference/hive.md.nolink)| +|`__cpp_lib_hive`|`202502L`|シーケンスコンテナのライブラリ[``](/reference/hive.md)を追加|[``](/reference/hive.md)| |`__cpp_lib_indirect`|`202502L`|[``](/reference/memory.md)に[`std::indirect`](/reference/memory/indirect.md)と[`std::polymorphic`](/reference/memory/polymorphic.md)を追加|[``](/reference/memory.md)| |`__cpp_lib_inplace_vector`|`202603L`|容量固定の可変長配列のライブラリ[``](/reference/inplace_vector.md)を追加|[``](/reference/inplace_vector.md)| |`__cpp_lib_integer_sequence`|`202511L`|[`std::integer_sequence`](/reference/utility/integer_sequence.md)を[構造化束縛](/lang/cpp17/structured_bindings.md)と[`template for`文](/lang/cpp26/expansion_statements.md)で使用できるよう、タプルインタフェースの特殊化を追加|[``](/reference/utility.md)| diff --git a/reference.md b/reference.md index 21807e4ace..dd7282c3d3 100644 --- a/reference.md +++ b/reference.md @@ -104,6 +104,7 @@ | [``](/reference/array.md) | 配列 | C++11 | | [``](/reference/deque.md) | 両端キュー | | | [``](/reference/forward_list.md) | 単方向リスト | C++11 | +| [``](/reference/hive.md) | 要素のメモリ位置が安定したコンテナ | C++26 | | [``](/reference/list.md) | 双方向リスト | | | [``](/reference/queue.md) | FIFOキュー | | | [``](/reference/stack.md) | LIFOスタック | | diff --git a/reference/hive.md b/reference/hive.md new file mode 100644 index 0000000000..8218682686 --- /dev/null +++ b/reference/hive.md @@ -0,0 +1,47 @@ +# hive +* hive[meta header] +* cpp26[meta cpp] + +``ヘッダでは、要素のメモリ位置が安定したシーケンスコンテナである[`hive`](hive/hive.md)を提供する。 + +`hive`は、要素の挿入・削除を定数時間で行いつつ、削除されなかった要素のポインタ・参照・イテレータを無効化しないコンテナである。要素は複数のメモリブロック（要素ブロック）に格納され、削除された要素の位置はスキップされる。挿入位置はコンテナが決定するため、要素の順序は指定できない。 + +このヘッダでは、以下の標準ヘッダをインクルードする： + +- [``](initializer_list.md) (C++11) +- [``](compare.md) (C++20) + + +| 名前 | 説明 | 対応バージョン | +|------|------|----------------| +| [`hive`](hive/hive.md) | 要素のメモリ位置が安定したシーケンスコンテナ (class template) | C++26 | +| [`hive_limits`](hive/hive_limits.md) | 要素ブロックの容量の下限・上限を指定する構造体 (class) | C++26 | +| [`swap`](hive/hive/swap_free.md) | 2つの`hive`オブジェクトを入れ替える (function template) | C++26 | +| [`erase`](hive/hive/erase_free.md) | 指定した値の要素を削除する (function template) | C++26 | +| [`erase_if`](hive/hive/erase_if_free.md) | 条件を満たす要素を削除する (function template) | C++26 | + +`std::pmr`名前空間には、以下の型の別名が定義される。 + +| 名前 | 説明 | 対応バージョン | +|------|------|----------------| +| [`pmr::hive`](hive/hive.md) | アロケータとして[`pmr::polymorphic_allocator`](memory_resource/polymorphic_allocator.md)を使用する`hive`の別名 (alias template) | C++26 | + + +## バージョン +### 言語 +- C++26 + +### 処理系 +- [Clang](/implementation.md#clang): 22 [mark noimpl] +- [GCC](/implementation.md#gcc): 16.1 [mark noimpl] +- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl] + + +## 関連項目 +- [`std::list`](list.md) +- [`std::deque`](deque.md) + + +## 参照 +- [P0447R28 Introduction of `std::hive` to the standard library](https://open-std.org/jtc1/sc22/wg21/docs/papers/2024/p0447r28.html) + - C++26で``ヘッダが追加された diff --git a/reference/hive/hive.md b/reference/hive/hive.md new file mode 100644 index 0000000000..036683c8a9 --- /dev/null +++ b/reference/hive/hive.md @@ -0,0 +1,240 @@ +# hive +* hive[meta header] +* std[meta namespace] +* class template[meta id-type] +* cpp26[meta cpp] + +```cpp +namespace std { + template > + class hive; + + namespace pmr { + template + using hive = std::hive>; + } +} +``` +* allocator[link /reference/memory/allocator.md] +* polymorphic_allocator[link /reference/memory_resource/polymorphic_allocator.md] + +## 概要 +`std::hive`クラスは、要素のメモリ位置が安定したシーケンスコンテナである。要素の挿入と削除を定数時間で行いつつ、削除されなかった要素へのポインタ・参照・イテレータを無効化しない。 + +要素は複数のメモリブロック（要素ブロック、element block）に格納される。削除された要素の位置は、後続の要素を移動させる代わりに、定数時間の手法によってイテレーション時にスキップされる。削除によって空になった要素ブロックは、解放されるか、再利用のために予約ブロックとして保持される。 + +挿入位置はコンテナが決定し、削除された要素のメモリ位置が再利用されることがある。このため、`std::hive`クラスは要素の順序を指定した挿入をサポートしない（順序は未規定である）。この性質により、`std::hive`クラスは[`std::list`](/reference/list/list.md)クラスよりもキャッシュ効率のよいメモリレイアウトと高速なイテレーションを実現しつつ、[`std::vector`](/reference/vector/vector.md)クラスとは異なり要素の挿入・削除でポインタ・参照が無効化されない。 + +テンプレートパラメータは、以下を意味する： + +- `T`: 格納される要素の型 +- `Allocator`: メモリ確保に使用されるアロケータの型。デフォルトでは標準の[`std::allocator`](/reference/memory/allocator.md)クラスが使用される。 + + +## この機能が必要になった背景・経緯 +ゲーム開発やシミュレーション、GUIなどの分野では、多数のオブジェクトを頻繁に生成・破棄しながら、それらのオブジェクトを互いにポインタや参照で参照し合うことが多い。このような用途では、次の性質を同時に満たすコンテナが求められる。 + +- 要素の挿入・削除が高速（定数時間）であること +- 既存の要素へのポインタ・参照・イテレータが、他の要素の挿入・削除によって無効化されないこと +- イテレーションがキャッシュ効率よく行えること + +[`std::vector`](/reference/vector/vector.md)は連続したメモリにより高速なイテレーションが可能だが、再確保や要素の削除によってポインタ・参照が無効化される。[`std::list`](/reference/list/list.md)や[`std::forward_list`](/reference/forward_list/forward_list.md)は挿入・削除でポインタ・参照が無効化されないが、要素ごとにノードを個別確保するためイテレーションのキャッシュ効率が悪い。 + +`std::hive`クラスは、複数の要素ブロックに要素をまとめて格納し、削除された位置をスキップすることで、これらの要求を同時に満たす。この設計は、以前は「colony」という名称でBoost C++ Libraries等で提供されていたデータ構造をC++標準ライブラリに導入したものである。 + + +## メンバ関数 +### 構築／コピー／破棄 + +| 名前 | 説明 | 対応バージョン | +|-------------------------------------------|-----------------------------|----------------| +| [`(constructor)`](hive/op_constructor.md) | コンストラクタ | C++26 | +| [`(destructor)`](hive/op_destructor.md) | デストラクタ | C++26 | +| [`operator=`](hive/op_assign.md) | 代入演算子 | C++26 | +| [`assign`](hive/assign.md) | コンテナに値を代入する | C++26 | +| [`assign_range`](hive/assign_range.md) | コンテナにRangeを代入する | C++26 | +| [`get_allocator`](hive/get_allocator.md) | アロケータを取得する | C++26 | + +### イテレータ + +| 名前 | 説明 | 対応バージョン | +|------------------------------|--------------------------------------------------|----------------| +| [`begin`](hive/begin.md) | 先頭要素を指すイテレータを取得する | C++26 | +| [`end`](hive/end.md) | 末尾の次を指すイテレータを取得する | C++26 | +| [`cbegin`](hive/cbegin.md) | 先頭要素を指す読み取り専用イテレータを取得する | C++26 | +| [`cend`](hive/cend.md) | 末尾の次を指す読み取り専用イテレータを取得する | C++26 | +| [`rbegin`](hive/rbegin.md) | 末尾要素を指す逆イテレータを取得する | C++26 | +| [`rend`](hive/rend.md) | 先頭の前を指す逆イテレータを取得する | C++26 | +| [`crbegin`](hive/crbegin.md) | 末尾要素を指す読み取り専用逆イテレータを取得する | C++26 | +| [`crend`](hive/crend.md) | 先頭の前を指す読み取り専用逆イテレータを取得する | C++26 | + +### 領域 + +| 名前 | 説明 | 対応バージョン | +|----------------------------------------------------------|--------------------------------------------------------|----------------| +| [`empty`](hive/empty.md) | コンテナが空かどうかを判定する | C++26 | +| [`size`](hive/size.md) | 要素数を取得する | C++26 | +| [`max_size`](hive/max_size.md) | 格納可能な最大の要素数を取得する | C++26 | +| [`capacity`](hive/capacity.md) | 要素ブロックを追加確保せずに保持できる要素数を取得する | C++26 | +| [`reserve`](hive/reserve.md) | 指定した要素数を格納できるよう容量を確保する | C++26 | +| [`shrink_to_fit`](hive/shrink_to_fit.md) | 容量を要素数に近づける | C++26 | +| [`trim_capacity`](hive/trim_capacity.md) | 予約ブロックを解放して容量を削減する | C++26 | +| [`block_capacity_limits`](hive/block_capacity_limits.md) | 要素ブロックの容量制限を取得する | C++26 | +| [`reshape`](hive/reshape.md) | 要素ブロックの容量制限を変更する | C++26 | + +### 変更 + +| 名前 | 説明 | 対応バージョン | +|----------------------------------------|------------------------------------------|----------------| +| [`emplace`](hive/emplace.md) | 要素を直接構築で挿入する | C++26 | +| [`emplace_hint`](hive/emplace_hint.md) | ヒント付きで要素を直接構築で挿入する | C++26 | +| [`insert`](hive/insert.md) | 要素を挿入する | C++26 | +| [`insert_range`](hive/insert_range.md) | Rangeの要素を挿入する | C++26 | +| [`erase`](hive/erase.md) | 要素を削除する | C++26 | +| [`swap`](hive/swap.md) | 他の`hive`オブジェクトと内容を入れ替える | C++26 | +| [`clear`](hive/clear.md) | 全要素を削除する | C++26 | + +### `hive`操作 + +| 名前 | 説明 | 対応バージョン | +|----------------------------------------|------------------------------------------|----------------| +| [`splice`](hive/splice.md) | 他の`hive`の全要素を移動して連結する | C++26 | +| [`unique`](hive/unique.md) | 連続した重複要素を削除する | C++26 | +| [`sort`](hive/sort.md) | 要素を並べ替える | C++26 | +| [`get_iterator`](hive/get_iterator.md) | 要素へのポインタからイテレータを取得する | C++26 | + +## 静的メンバ関数 + +| 名前 | 説明 | 対応バージョン | +|-------------------------------------------------------------------------|--------------------------------------------------|----------------| +| [`block_capacity_default_limits`](hive/block_capacity_default_limits.md) | 処理系のデフォルトの容量制限を取得する | C++26 | +| [`block_capacity_hard_limits`](hive/block_capacity_hard_limits.md) | 処理系のハード制限を取得する | C++26 | +| [`is_within_hard_limits`](hive/is_within_hard_limits.md) | 指定した容量制限がハード制限の範囲内か判定する | C++26 | + +## メンバ型 + +| 名前 | 説明 | 対応バージョン | +|--------------------------|-------------------------------------------------------------------|----------------| +| `value_type` | 要素の型`T` | C++26 | +| `allocator_type` | アロケータの型`Allocator` | C++26 | +| `pointer` | 要素へのポインタ型 `allocator_traits::pointer` | C++26 | +| `const_pointer` | 要素への`const`ポインタ型 `allocator_traits::const_pointer` | C++26 | +| `reference` | 要素への参照型 `value_type&` | C++26 | +| `const_reference` | 要素への`const`参照型 `const value_type&` | C++26 | +| `size_type` | 要素数を表す符号なし整数型 (処理系定義) | C++26 | +| `difference_type` | 要素間の距離を表す符号付き整数型 (処理系定義) | C++26 | +| `iterator` | 双方向イテレータ (処理系定義) | C++26 | +| `const_iterator` | 読み取り専用双方向イテレータ (処理系定義) | C++26 | +| `reverse_iterator` | 逆順双方向イテレータ [`reverse_iterator`](/reference/iterator/reverse_iterator.md) | C++26 | +| `const_reverse_iterator` | 読み取り専用逆順双方向イテレータ [`reverse_iterator`](/reference/iterator/reverse_iterator.md) | C++26 | + +## 非メンバ関数 + +| 名前 | 説明 | 対応バージョン | +|-------------------------------------|-------------------------------------|----------------| +| [`swap`](hive/swap_free.md) | 2つの`hive`オブジェクトを入れ替える | C++26 | +| [`erase`](hive/erase_free.md) | 指定した値の要素を削除する | C++26 | +| [`erase_if`](hive/erase_if_free.md) | 条件を満たす要素を削除する | C++26 | + +## 推論補助 + +| 名前 | 説明 | 対応バージョン | +|---------------------------------------------|--------------------------------------|----------------| +| [`(deduction_guide)`](hive/op_deduction_guide.md) | クラステンプレートの推論補助 | C++26 | + + +## 例 +### 基本的な使い方 +```cpp example +#include +#include + +int main() +{ + std::hive h; + + // 要素を挿入する。挿入位置はコンテナが決定する + h.insert(1); + h.insert(2); + h.insert(3); + + // 要素を順番に出力する + for (int x : h) { + std::print("{} ", x); + } + std::println(""); + + std::println("size = {}", h.size()); +} +``` +* std::hive[color ff0000] +* h.insert[link hive/insert.md] +* h.size()[link hive/size.md] + +#### 出力例 +``` +1 2 3 +size = 3 +``` + +### 要素のポインタ・参照が安定していることを利用する +`std::hive`の最大の特徴は、要素の挿入・削除によって、削除されなかった要素へのポインタ・参照・イテレータが無効化されないことである。多数のオブジェクトを動的に生成・破棄しつつ、それらを互いにポインタで参照し合うような状況で有用となる。 + +```cpp example +#include +#include + +int main() +{ + std::hive h; + + // 要素を挿入し、そのポインタを保持しておく + int* p = &*h.insert(42); + + // 別の要素のイテレータも保持しておく + auto other = h.insert(99); + + // 大量の要素を追加しても、既存要素へのポインタは無効化されない + // (std::vectorでは再確保によってpが無効化されうる) + for (int i = 0; i < 10000; ++i) { + h.insert(i); + } + std::println("{}", *p); // 42 + + // 任意の要素を定数時間で削除でき、他の要素のポインタ・イテレータは無効化されない + // (std::vectorのeraseは後続要素を移動させ、ポインタを無効化する) + h.erase(other); + std::println("{}", *p); // 42（削除したのは別の要素なので有効なまま） +} +``` +* std::hive[color ff0000] +* h.insert[link hive/insert.md] +* h.erase[link hive/erase.md] + +#### 出力 +``` +42 +42 +``` + + +## バージョン +### 言語 +- C++26 + +### 処理系 +- [Clang](/implementation.md#clang): 22 [mark noimpl] +- [GCC](/implementation.md#gcc): 16.1 [mark noimpl] +- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl] + + +## 関連項目 +- [`std::list`](/reference/list/list.md) +- [`std::forward_list`](/reference/forward_list/forward_list.md) +- [`std::deque`](/reference/deque/deque.md) +- [`std::vector`](/reference/vector/vector.md) + + +## 参照 +- [P0447R28 Introduction of `std::hive` to the standard library](https://open-std.org/jtc1/sc22/wg21/docs/papers/2024/p0447r28.html) + - C++26で`hive`が追加された diff --git a/reference/hive/hive/assign.md b/reference/hive/hive/assign.md new file mode 100644 index 0000000000..04dfa8d3b1 --- /dev/null +++ b/reference/hive/hive/assign.md @@ -0,0 +1,110 @@ +# assign +* hive[meta header] +* std[meta namespace] +* hive[meta class] +* function[meta id-type] +* cpp26[meta cpp] + +```cpp +void assign(size_type n, const T& t); // (1) C++26 + +template +void assign(InputIterator first, InputIterator last); // (2) C++26 + +void assign(initializer_list il); // (3) C++26 +``` +* initializer_list[link /reference/initializer_list/initializer_list.md] + +## 概要 +コンテナに値を代入する。 + +- (1) : `n`個の値`t`のコピーを代入する。 +- (2) : イテレータ範囲`[first, last)`を代入する。 +- (3) : 初期化子リストを代入する。 + + +## 効果 +現在保持している要素を全て破棄し、指定された要素を代入する。それぞれ以下と等価である。 + +- (1) : +```cpp +clear(); +insert(n, t); +``` +* clear[link clear.md] +* insert[link insert.md] + +- (2) : +```cpp +clear(); +insert(first, last); +``` +* clear[link clear.md] +* insert[link insert.md] + +- (3) : +```cpp +clear(); +insert(il); +``` +* clear[link clear.md] +* insert[link insert.md] + + +## 戻り値 +なし + + +## 例 +```cpp example +#include +#include +#include + +int main() +{ + std::hive h; + + // n個の値を代入する + h.assign(3, 1); + std::println("size = {}", h.size()); + + // イテレータ範囲を代入する + int a[] = {1, 2, 3, 4}; + h.assign(std::begin(a), std::end(a)); + std::println("size = {}", h.size()); + + // 初期化子リストを代入する + h.assign({1, 2}); + std::println("size = {}", h.size()); +} +``` +* h.assign[color ff0000] +* h.size()[link size.md] + +### 出力 +``` +size = 3 +size = 4 +size = 2 +``` + + +## バージョン +### 言語 +- C++26 + +### 処理系 +- [Clang](/implementation.md#clang): 22 [mark noimpl] +- [GCC](/implementation.md#gcc): 16.1 [mark noimpl] +- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl] + + +## 関連項目 +- [`assign_range`](assign_range.md) +- [`operator=`](op_assign.md) + + +## 参照 +- [P0447R28 Introduction of `std::hive` to the standard library](https://open-std.org/jtc1/sc22/wg21/docs/papers/2024/p0447r28.html) + - C++26で追加された diff --git a/reference/hive/hive/assign_range.md b/reference/hive/hive/assign_range.md new file mode 100644 index 0000000000..c8afc485dc --- /dev/null +++ b/reference/hive/hive/assign_range.md @@ -0,0 +1,75 @@ +# assign_range +* hive[meta header] +* std[meta namespace] +* hive[meta class] +* function template[meta id-type] +* cpp26[meta cpp] + +```cpp +template R> +void assign_range(R&& rg); // (1) C++26 +``` + +## 概要 +コンテナにRangeを代入する。 + + +## 事前条件 +`*this`の要素の範囲とRange`rg`の要素の範囲が重複していないこと。 + + +## テンプレートパラメータ制約 +型`T`が`*ranges::begin(rg)`から`hive`コンテナへの`EmplaceConstructible`であること。 + + +## 効果 +現在保持している要素を全て破棄し、Range`rg`の各要素を代入する。 + + +## 戻り値 +なし + + +## 例 +```cpp example +#include +#include + +int main() +{ + std::hive h = {1, 2, 3}; + const int a[] = {4, 5, 6, 7}; + + // Rangeを代入する + h.assign_range(a); + + std::println("size = {}", h.size()); +} +``` +* h.assign_range[color ff0000] +* h.size()[link size.md] + +### 出力 +``` +size = 4 +``` + + +## バージョン +### 言語 +- C++26 + +### 処理系 +- [Clang](/implementation.md#clang): 22 [mark noimpl] +- [GCC](/implementation.md#gcc): 16.1 [mark noimpl] +- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl] + + +## 関連項目 +- [`assign`](assign.md) +- [`insert_range`](insert_range.md) + + +## 参照 +- [P0447R28 Introduction of `std::hive` to the standard library](https://open-std.org/jtc1/sc22/wg21/docs/papers/2024/p0447r28.html) + - C++26で追加された diff --git a/reference/hive/hive/begin.md b/reference/hive/hive/begin.md new file mode 100644 index 0000000000..59ac277547 --- /dev/null +++ b/reference/hive/hive/begin.md @@ -0,0 +1,77 @@ +# begin +* hive[meta header] +* std[meta namespace] +* hive[meta class] +* function[meta id-type] +* cpp26[meta cpp] + +```cpp +iterator begin() noexcept; // (1) C++26 +const_iterator begin() const noexcept; // (2) C++26 +``` + +## 概要 +先頭要素を指すイテレータを取得する。 + + +## 戻り値 +先頭要素を指すイテレータ + + +## 例外 +投げない + + +## 計算量 +定数時間 + + +## 例 +```cpp example +#include +#include + +int main() +{ + std::hive h; + h.insert(1); + h.insert(2); + h.insert(3); + + const std::hive& ch = h; + + decltype(h)::iterator i = h.begin(); // (1) + decltype(h)::const_iterator ci = ch.begin(); // (2) + + // begin()からend()まで走査する + for (auto it = i; it != h.end(); ++it) { + std::print("{} ", *it); + } + std::println(""); + + std::println("{}", *ci); +} +``` +* begin()[color ff0000] +* h.insert[link insert.md] +* h.end()[link end.md] + +### 出力例 +``` +1 2 3 +1 +``` + +## バージョン +### 言語 +- C++26 + +### 処理系 +- [Clang](/implementation.md#clang): 22 [mark noimpl] +- [GCC](/implementation.md#gcc): 16.1 [mark noimpl] +- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl] + + +## 参照 +- [P0447R28 Introduction of `std::hive` to the standard library](https://open-std.org/jtc1/sc22/wg21/docs/papers/2024/p0447r28.html) + - C++26で追加された diff --git a/reference/hive/hive/block_capacity_default_limits.md b/reference/hive/hive/block_capacity_default_limits.md new file mode 100644 index 0000000000..a979b8bbb7 --- /dev/null +++ b/reference/hive/hive/block_capacity_default_limits.md @@ -0,0 +1,67 @@ +# block_capacity_default_limits +* hive[meta header] +* std[meta namespace] +* hive[meta class] +* function[meta id-type] +* cpp26[meta cpp] + +```cpp +static constexpr hive_limits block_capacity_default_limits() noexcept; // C++26 +``` +* hive_limits[link ../hive_limits.md] + +## 概要 +処理系のデフォルトの容量制限を取得する。 + +ユーザーが容量制限を指定せずに`hive`オブジェクトを構築した場合に使用される、要素ブロックの容量制限（[`hive_limits`](../hive_limits.md)）を取得する。この関数は静的メンバ関数である。 + +なお、デフォルト制限は、処理系が要素ブロックに対してサポートできる容量の絶対的な限界であるハード制限（[`block_capacity_hard_limits`](block_capacity_hard_limits.md)）とは必ずしも一致しない。デフォルト制限は、処理系・ユーザー双方の最適化の余地を残すために、ハード制限より内側の値に定められることがある。 + + +## 戻り値 +`min`メンバと`max`メンバに処理系のデフォルト制限を設定した[`hive_limits`](../hive_limits.md)オブジェクト。 + + +## 計算量 +定数時間。 + + +## 例 +```cpp example +#include +#include + +int main() +{ + std::hive_limits limits = std::hive::block_capacity_default_limits(); + std::println("min={}, max={}", limits.min, limits.max); +} +``` +* block_capacity_default_limits[color ff0000] +* std::hive_limits[link ../hive_limits.md] + +### 出力例 +``` +min=8, max=8192 +``` + + +## バージョン +### 言語 +- C++26 + +### 処理系 +- [Clang](/implementation.md#clang): 22 [mark noimpl] +- [GCC](/implementation.md#gcc): 16.1 [mark noimpl] +- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl] + + +## 関連項目 +- [`hive_limits`](../hive_limits.md) +- [`hive::block_capacity_limits`](block_capacity_limits.md) +- [`hive::block_capacity_hard_limits`](block_capacity_hard_limits.md) + + +## 参照 +- [P0447R28 Introduction of `std::hive` to the standard library](https://open-std.org/jtc1/sc22/wg21/docs/papers/2024/p0447r28.html) + - C++26で追加された diff --git a/reference/hive/hive/block_capacity_hard_limits.md b/reference/hive/hive/block_capacity_hard_limits.md new file mode 100644 index 0000000000..7582692f93 --- /dev/null +++ b/reference/hive/hive/block_capacity_hard_limits.md @@ -0,0 +1,74 @@ +# block_capacity_hard_limits +* hive[meta header] +* std[meta namespace] +* hive[meta class] +* function[meta id-type] +* cpp26[meta cpp] + +```cpp +static constexpr hive_limits block_capacity_hard_limits() noexcept; // C++26 +``` +* hive_limits[link ../hive_limits.md] + +## 概要 +処理系のハード制限を取得する。 + +「ハード制限（hard limits）」とは、その処理系の実装が要素ブロックに対して実際にサポートできる、保持要素数の下限・上限の絶対的な限界値である。要素ブロックが保持できる要素数の最小値・最大値そのものであり、この範囲を超える容量制限を要素ブロックに設定することはできない。この関数は、そのハード制限を`min`・`max`メンバに設定した[`hive_limits`](../hive_limits.md)を返す静的メンバ関数である。 + +ユーザーが`hive`のコンストラクタや[`reshape`](reshape.md)に渡す容量制限（[`hive_limits`](../hive_limits.md)）は、必ずこのハード制限の範囲内でなければならない。範囲外の値を指定した場合の動作は「エラー性動作（erroneous behavior）」となる。指定した容量制限がハード制限の範囲内かどうかは、[`is_within_hard_limits()`](is_within_hard_limits.md)で事前に確認できる。 + +ハード制限は、ユーザーが制限を指定しなかったときに使われるデフォルト制限（[`block_capacity_default_limits`](block_capacity_default_limits.md)）とは必ずしも一致しない。デフォルト制限は、処理系・ユーザー双方の最適化の余地を残すために、ハード制限より内側の値に定められることがある。 + + +## 戻り値 +`min`メンバと`max`メンバに処理系のハード制限を設定した[`hive_limits`](../hive_limits.md)オブジェクト。 + + +## 計算量 +定数時間。 + + +## 備考 +ハード制限の`max`は、[`std::allocator_traits::max_size()`](/reference/memory/allocator_traits/max_size.md)以下である。 + + +## 例 +```cpp example +#include +#include + +int main() +{ + std::hive_limits limits = std::hive::block_capacity_hard_limits(); + std::println("min={}, max={}", limits.min, limits.max); +} +``` +* block_capacity_hard_limits[color ff0000] +* std::hive_limits[link ../hive_limits.md] + +### 出力例 +``` +min=3, max=255 +``` + + +## バージョン +### 言語 +- C++26 + +### 処理系 +- [Clang](/implementation.md#clang): 22 [mark noimpl] +- [GCC](/implementation.md#gcc): 16.1 [mark noimpl] +- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl] + + +## 関連項目 +- [`hive_limits`](../hive_limits.md) +- [`hive::block_capacity_limits`](block_capacity_limits.md) +- [`hive::block_capacity_default_limits`](block_capacity_default_limits.md) +- [`hive::is_within_hard_limits`](is_within_hard_limits.md) + + +## 参照 +- [P0447R28 Introduction of `std::hive` to the standard library](https://open-std.org/jtc1/sc22/wg21/docs/papers/2024/p0447r28.html) + - C++26で追加された diff --git a/reference/hive/hive/block_capacity_limits.md b/reference/hive/hive/block_capacity_limits.md new file mode 100644 index 0000000000..35e26406b6 --- /dev/null +++ b/reference/hive/hive/block_capacity_limits.md @@ -0,0 +1,69 @@ +# block_capacity_limits +* hive[meta header] +* std[meta namespace] +* hive[meta class] +* function[meta id-type] +* cpp26[meta cpp] + +```cpp +constexpr hive_limits block_capacity_limits() const noexcept; // C++26 +``` +* hive_limits[link ../hive_limits.md] + +## 概要 +要素ブロックの容量制限を取得する。 + +現在この`hive`オブジェクトに設定されている、要素ブロックが保持できる要素数の下限・上限（[`hive_limits`](../hive_limits.md)）を取得する。 + + +## 戻り値 +現在の容量制限を表す[`hive_limits`](../hive_limits.md)オブジェクト。 + + +## 計算量 +定数時間。 + + +## 例 +```cpp example +#include +#include + +int main() +{ + // 要素ブロックが保持できる要素数を、最小8・最大64に制限する + std::hive h{std::hive_limits{8, 64}}; + + std::hive_limits limits = h.block_capacity_limits(); + std::println("min={}, max={}", limits.min, limits.max); +} +``` +* block_capacity_limits[color ff0000] +* std::hive_limits[link ../hive_limits.md] + +### 出力 +``` +min=8, max=64 +``` + + +## バージョン +### 言語 +- C++26 + +### 処理系 +- [Clang](/implementation.md#clang): 22 [mark noimpl] +- [GCC](/implementation.md#gcc): 16.1 [mark noimpl] +- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl] + + +## 関連項目 +- [`hive_limits`](../hive_limits.md) +- [`hive::block_capacity_default_limits`](block_capacity_default_limits.md) +- [`hive::block_capacity_hard_limits`](block_capacity_hard_limits.md) +- [`hive::reshape`](reshape.md) + + +## 参照 +- [P0447R28 Introduction of `std::hive` to the standard library](https://open-std.org/jtc1/sc22/wg21/docs/papers/2024/p0447r28.html) + - C++26で追加された diff --git a/reference/hive/hive/capacity.md b/reference/hive/hive/capacity.md new file mode 100644 index 0000000000..af6c40b4f7 --- /dev/null +++ b/reference/hive/hive/capacity.md @@ -0,0 +1,75 @@ +# capacity +* hive[meta header] +* std[meta namespace] +* hive[meta class] +* function[meta id-type] +* cpp26[meta cpp] + +```cpp +size_type capacity() const noexcept; // (1) C++26 +``` + +## 概要 +要素ブロックを追加確保せずに保持できる要素数を取得する。 + + +## 戻り値 +要素ブロックの追加確保を必要とせずに`*this`が保持できる総要素数 + + +## 例外 +投げない + + +## 計算量 +定数時間 + + +## 例 +```cpp example +#include +#include + +int main() +{ + std::hive h; + + // 100要素分の領域を予約する + h.reserve(100); + + // 予約した領域を確認する + std::println("size = {}", h.size()); + std::println("capacity >= 100 : {}", h.capacity() >= 100); +} +``` +* capacity()[color ff0000] +* h.reserve[link reserve.md] +* h.size()[link size.md] + +### 出力 +``` +size = 0 +capacity >= 100 : true +``` + + +## バージョン +### 言語 +- C++26 + +### 処理系 +- [Clang](/implementation.md#clang): 22 [mark noimpl] +- [GCC](/implementation.md#gcc): 16.1 [mark noimpl] +- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl] + + +## 関連項目 +- [`hive::reserve`](reserve.md) +- [`hive::shrink_to_fit`](shrink_to_fit.md) +- [`hive::trim_capacity`](trim_capacity.md) +- [`hive::size`](size.md) + + +## 参照 +- [P0447R28 Introduction of `std::hive` to the standard library](https://open-std.org/jtc1/sc22/wg21/docs/papers/2024/p0447r28.html) + - C++26で`hive`が追加された diff --git a/reference/hive/hive/cbegin.md b/reference/hive/hive/cbegin.md new file mode 100644 index 0000000000..89967f557a --- /dev/null +++ b/reference/hive/hive/cbegin.md @@ -0,0 +1,68 @@ +# cbegin +* hive[meta header] +* std[meta namespace] +* hive[meta class] +* function[meta id-type] +* cpp26[meta cpp] + +```cpp +const_iterator cbegin() const noexcept; // (1) C++26 +``` + +## 概要 +先頭要素を指す読み取り専用イテレータを取得する。 + + +## 戻り値 +先頭要素を指す読み取り専用イテレータ + + +## 例外 +投げない + + +## 計算量 +定数時間 + + +## 例 +```cpp example +#include +#include + +int main() +{ + std::hive h; + h.insert(1); + h.insert(2); + h.insert(3); + + // cbegin()/cend()で読み取り専用に走査する + for (auto it = h.cbegin(); it != h.cend(); ++it) { + std::print("{} ", *it); + } + std::println(""); +} +``` +* cbegin()[color ff0000] +* h.insert[link insert.md] +* h.cend()[link cend.md] + +### 出力例 +``` +1 2 3 +``` + +## バージョン +### 言語 +- C++26 + +### 処理系 +- [Clang](/implementation.md#clang): 22 [mark noimpl] +- [GCC](/implementation.md#gcc): 16.1 [mark noimpl] +- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl] + + +## 参照 +- [P0447R28 Introduction of `std::hive` to the standard library](https://open-std.org/jtc1/sc22/wg21/docs/papers/2024/p0447r28.html) + - C++26で追加された diff --git a/reference/hive/hive/cend.md b/reference/hive/hive/cend.md new file mode 100644 index 0000000000..aab8442e36 --- /dev/null +++ b/reference/hive/hive/cend.md @@ -0,0 +1,70 @@ +# cend +* hive[meta header] +* std[meta namespace] +* hive[meta class] +* function[meta id-type] +* cpp26[meta cpp] + +```cpp +const_iterator cend() const noexcept; // (1) C++26 +``` + +## 概要 +末尾の次を指す読み取り専用イテレータを取得する。 + +このイテレータは、有効な要素を指さない終端を表す番兵として使用する。 + + +## 戻り値 +末尾の次を指す読み取り専用イテレータ + + +## 例外 +投げない + + +## 計算量 +定数時間 + + +## 例 +```cpp example +#include +#include + +int main() +{ + std::hive h; + h.insert(1); + h.insert(2); + h.insert(3); + + // cbegin()/cend()で読み取り専用に走査する + for (auto it = h.cbegin(); it != h.cend(); ++it) { + std::print("{} ", *it); + } + std::println(""); +} +``` +* cend()[color ff0000] +* h.insert[link insert.md] +* h.cbegin()[link cbegin.md] + +### 出力例 +``` +1 2 3 +``` + +## バージョン +### 言語 +- C++26 + +### 処理系 +- [Clang](/implementation.md#clang): 22 [mark noimpl] +- [GCC](/implementation.md#gcc): 16.1 [mark noimpl] +- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl] + + +## 参照 +- [P0447R28 Introduction of `std::hive` to the standard library](https://open-std.org/jtc1/sc22/wg21/docs/papers/2024/p0447r28.html) + - C++26で追加された diff --git a/reference/hive/hive/clear.md b/reference/hive/hive/clear.md new file mode 100644 index 0000000000..42233ea8cb --- /dev/null +++ b/reference/hive/hive/clear.md @@ -0,0 +1,85 @@ +# clear +* hive[meta header] +* std[meta namespace] +* hive[meta class] +* function[meta id-type] +* cpp26[meta cpp] + +```cpp +void clear() noexcept; // C++26 +``` + +## 概要 +全ての要素を削除する。 + + +## 効果 +`hive`オブジェクトが管理している全ての要素を破棄する。この呼び出しの後、[`size()`](size.md)は`0`を返す。 + + +## 戻り値 +なし + + +## 例外 +投げない + + +## 計算量 +線形時間。全ての要素に対してデストラクタを呼び出す。 + + +## 備考 +要素を指す全ての参照、ポインタ、イテレータは無効になる。終端イテレータ（past-the-end iterator）は無効にならない。 + + +## 例 +```cpp example +#include +#include +#include + +int main() +{ + std::hive h; + h.insert(1); + h.insert(2); + h.insert(3); + + h.clear(); + + assert(h.empty()); + std::println("size = {}", h.size()); +} +``` +* clear()[color ff0000] +* h.insert[link insert.md] +* h.empty()[link empty.md] +* h.size()[link size.md] + +### 出力 +``` +size = 0 +``` + + +## バージョン +### 言語 +- C++26 + +### 処理系 +- [Clang](/implementation.md#clang): 22 [mark noimpl] +- [GCC](/implementation.md#gcc): 16.1 [mark noimpl] +- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl] + + +## 関連項目 + +| 名前 | 説明 | +|---------------------|------------------| +| [`erase`](erase.md) | 要素を削除する | + + +## 参照 +- [P0447R28 Introduction of `std::hive` to the standard library](https://open-std.org/jtc1/sc22/wg21/docs/papers/2024/p0447r28.html) + - C++26で`hive`が追加された diff --git a/reference/hive/hive/crbegin.md b/reference/hive/hive/crbegin.md new file mode 100644 index 0000000000..e374a1a2d9 --- /dev/null +++ b/reference/hive/hive/crbegin.md @@ -0,0 +1,68 @@ +# crbegin +* hive[meta header] +* std[meta namespace] +* hive[meta class] +* function[meta id-type] +* cpp26[meta cpp] + +```cpp +const_reverse_iterator crbegin() const noexcept; // (1) C++26 +``` + +## 概要 +末尾要素を指す読み取り専用逆イテレータを取得する。 + + +## 戻り値 +末尾要素を指す読み取り専用逆イテレータ + + +## 例外 +投げない + + +## 計算量 +定数時間 + + +## 例 +```cpp example +#include +#include + +int main() +{ + std::hive h; + h.insert(1); + h.insert(2); + h.insert(3); + + // crbegin()/crend()で末尾から読み取り専用に逆順走査する + for (auto it = h.crbegin(); it != h.crend(); ++it) { + std::print("{} ", *it); + } + std::println(""); +} +``` +* crbegin()[color ff0000] +* h.insert[link insert.md] +* h.crend()[link crend.md] + +### 出力例 +``` +3 2 1 +``` + +## バージョン +### 言語 +- C++26 + +### 処理系 +- [Clang](/implementation.md#clang): 22 [mark noimpl] +- [GCC](/implementation.md#gcc): 16.1 [mark noimpl] +- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl] + + +## 参照 +- [P0447R28 Introduction of `std::hive` to the standard library](https://open-std.org/jtc1/sc22/wg21/docs/papers/2024/p0447r28.html) + - C++26で追加された diff --git a/reference/hive/hive/crend.md b/reference/hive/hive/crend.md new file mode 100644 index 0000000000..27b2f7aed5 --- /dev/null +++ b/reference/hive/hive/crend.md @@ -0,0 +1,70 @@ +# crend +* hive[meta header] +* std[meta namespace] +* hive[meta class] +* function[meta id-type] +* cpp26[meta cpp] + +```cpp +const_reverse_iterator crend() const noexcept; // (1) C++26 +``` + +## 概要 +先頭の前を指す読み取り専用逆イテレータを取得する。 + +このイテレータは、逆順走査における終端を表す番兵として使用する。 + + +## 戻り値 +先頭の前を指す読み取り専用逆イテレータ + + +## 例外 +投げない + + +## 計算量 +定数時間 + + +## 例 +```cpp example +#include +#include + +int main() +{ + std::hive h; + h.insert(1); + h.insert(2); + h.insert(3); + + // crbegin()/crend()で末尾から読み取り専用に逆順走査する + for (auto it = h.crbegin(); it != h.crend(); ++it) { + std::print("{} ", *it); + } + std::println(""); +} +``` +* crend()[color ff0000] +* h.insert[link insert.md] +* h.crbegin()[link crbegin.md] + +### 出力例 +``` +3 2 1 +``` + +## バージョン +### 言語 +- C++26 + +### 処理系 +- [Clang](/implementation.md#clang): 22 [mark noimpl] +- [GCC](/implementation.md#gcc): 16.1 [mark noimpl] +- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl] + + +## 参照 +- [P0447R28 Introduction of `std::hive` to the standard library](https://open-std.org/jtc1/sc22/wg21/docs/papers/2024/p0447r28.html) + - C++26で追加された diff --git a/reference/hive/hive/emplace.md b/reference/hive/hive/emplace.md new file mode 100644 index 0000000000..1fd9c15242 --- /dev/null +++ b/reference/hive/hive/emplace.md @@ -0,0 +1,95 @@ +# emplace +* hive[meta header] +* std[meta namespace] +* hive[meta class] +* function template[meta id-type] +* cpp26[meta cpp] + +```cpp +template +iterator emplace(Args&&... args); // C++26 +``` + +## 概要 +要素を直接構築で挿入する。 + +この関数の引数`args...`は、要素型`T`のコンストラクタ引数である。当関数の内部で要素型`T`のコンストラクタを呼び出し、追加する要素を構築する。 + +挿入位置はコンテナが決定するため、挿入する位置を指定することはできない（順序は未規定である）。 + + +## 適格要件 +型`T`が、`args...`から`hive`コンテナへの`EmplaceConstructible`であること。 + + +## 効果 +`std::forward(args)...`で構築した型`T`のオブジェクトを挿入する。 + +例外が送出された場合、副作用は生じない。 + + +## 戻り値 +新たに挿入された要素を指すイテレータ。 + + +## 計算量 +定数時間。型`T`のオブジェクトがちょうど1個構築される。 + + +## 備考 +この関数呼び出しにより、終端イテレータ（past-the-end iterator）は無効になる。削除されなかった既存要素へのポインタ・参照・イテレータは無効にならない。 + +引数`args...`は、直接的または間接的に`*this`が保持する値を参照してもよい。 + + +## 例 +```cpp example +#include +#include +#include +#include + +int main() +{ + std::hive> h; + + // pairを構築する引数を渡して、直接構築で挿入する + h.emplace(1, "a"); + h.emplace(2, "b"); + + for (const auto& x : h) { + std::println("{},{}", x.first, x.second); + } +} +``` +* emplace[color ff0000] + +### 出力例 +``` +1,a +2,b +``` + + +## バージョン +### 言語 +- C++26 + +### 処理系 +- [Clang](/implementation.md#clang): 22 [mark noimpl] +- [GCC](/implementation.md#gcc): 16.1 [mark noimpl] +- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl] + + +## 関連項目 + +| 名前 | 説明 | +|-----------------------------------|--------------------------------------| +| [`emplace_hint`](emplace_hint.md) | ヒント付きで要素を直接構築で挿入する | +| [`insert`](insert.md) | 要素を挿入する | +| [`insert_range`](insert_range.md) | Rangeの要素を挿入する | + + +## 参照 +- [P0447R28 Introduction of `std::hive` to the standard library](https://open-std.org/jtc1/sc22/wg21/docs/papers/2024/p0447r28.html) + - C++26で`hive`が追加された diff --git a/reference/hive/hive/emplace_hint.md b/reference/hive/hive/emplace_hint.md new file mode 100644 index 0000000000..625b63ca92 --- /dev/null +++ b/reference/hive/hive/emplace_hint.md @@ -0,0 +1,95 @@ +# emplace_hint +* hive[meta header] +* std[meta namespace] +* hive[meta class] +* function template[meta id-type] +* cpp26[meta cpp] + +```cpp +template +iterator emplace_hint(const_iterator hint, Args&&... args); // C++26 +``` + +## 概要 +ヒント付きで要素を直接構築で挿入する。 + +この関数の引数`args...`は、要素型`T`のコンストラクタ引数である。当関数の内部で要素型`T`のコンストラクタを呼び出し、追加する要素を構築する。 + +第1引数`hint`は挿入位置のヒントであるが、`hive`の挿入位置はコンテナが決定するため、この引数は無視される。この関数は、他のコンテナと同じインタフェースで扱えるようにするために提供されている。 + + +## 適格要件 +型`T`が、`args...`から`hive`コンテナへの`EmplaceConstructible`であること。 + + +## 効果 +`std::forward(args)...`で構築した型`T`のオブジェクトを挿入する。`hint`引数は無視される。 + +例外が送出された場合、副作用は生じない。 + + +## 戻り値 +新たに挿入された要素を指すイテレータ。 + + +## 計算量 +定数時間。型`T`のオブジェクトがちょうど1個構築される。 + + +## 備考 +この関数呼び出しにより、終端イテレータ（past-the-end iterator）は無効になる。削除されなかった既存要素へのポインタ・参照・イテレータは無効にならない。 + +引数`args...`は、直接的または間接的に`*this`が保持する値を参照してもよい。 + + +## 例 +```cpp example +#include +#include + +int main() +{ + std::hive h; + + // hintは無視される。emplaceと同じく直接構築で挿入する + h.emplace_hint(h.begin(), 1); + h.emplace_hint(h.end(), 2); + + for (int x : h) { + std::print("{} ", x); + } + std::println(""); +} +``` +* emplace_hint[color ff0000] +* h.begin()[link begin.md] +* h.end()[link end.md] + +### 出力例 +``` +1 2 +``` + + +## バージョン +### 言語 +- C++26 + +### 処理系 +- [Clang](/implementation.md#clang): 22 [mark noimpl] +- [GCC](/implementation.md#gcc): 16.1 [mark noimpl] +- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl] + + +## 関連項目 + +| 名前 | 説明 | +|-----------------------------------|--------------------------| +| [`emplace`](emplace.md) | 要素を直接構築で挿入する | +| [`insert`](insert.md) | 要素を挿入する | +| [`insert_range`](insert_range.md) | Rangeの要素を挿入する | + + +## 参照 +- [P0447R28 Introduction of `std::hive` to the standard library](https://open-std.org/jtc1/sc22/wg21/docs/papers/2024/p0447r28.html) + - C++26で`hive`が追加された diff --git a/reference/hive/hive/empty.md b/reference/hive/hive/empty.md new file mode 100644 index 0000000000..40d209fe95 --- /dev/null +++ b/reference/hive/hive/empty.md @@ -0,0 +1,72 @@ +# empty +* hive[meta header] +* std[meta namespace] +* hive[meta class] +* function[meta id-type] +* cpp26[meta cpp] + +```cpp +bool empty() const noexcept; // (1) C++26 +``` + +## 概要 +コンテナが空かどうかを判定する。 + + +## 戻り値 +コンテナが空であれば`true`、そうでなければ`false`を返す。 + + +## 例外 +投げない + + +## 計算量 +定数時間 + + +## 例 +```cpp example +#include +#include + +int main() +{ + // 空 + { + std::hive h; + std::println("{}", h.empty()); + } + // 空じゃない + { + std::hive h = {1, 2, 3}; + std::println("{}", h.empty()); + } +} +``` +* empty()[color ff0000] + +### 出力 +``` +true +false +``` + + +## バージョン +### 言語 +- C++26 + +### 処理系 +- [Clang](/implementation.md#clang): 22 [mark noimpl] +- [GCC](/implementation.md#gcc): 16.1 [mark noimpl] +- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl] + + +## 関連項目 +- [`hive::size`](size.md) + + +## 参照 +- [P0447R28 Introduction of `std::hive` to the standard library](https://open-std.org/jtc1/sc22/wg21/docs/papers/2024/p0447r28.html) + - C++26で`hive`が追加された diff --git a/reference/hive/hive/end.md b/reference/hive/hive/end.md new file mode 100644 index 0000000000..c8c0100fca --- /dev/null +++ b/reference/hive/hive/end.md @@ -0,0 +1,71 @@ +# end +* hive[meta header] +* std[meta namespace] +* hive[meta class] +* function[meta id-type] +* cpp26[meta cpp] + +```cpp +iterator end() noexcept; // (1) C++26 +const_iterator end() const noexcept; // (2) C++26 +``` + +## 概要 +末尾の次を指すイテレータを取得する。 + +このイテレータは、有効な要素を指さない終端を表す番兵として使用する。 + + +## 戻り値 +末尾の次を指すイテレータ + + +## 例外 +投げない + + +## 計算量 +定数時間 + + +## 例 +```cpp example +#include +#include + +int main() +{ + std::hive h; + h.insert(1); + h.insert(2); + h.insert(3); + + // begin()からend()まで走査する + for (auto it = h.begin(); it != h.end(); ++it) { + std::print("{} ", *it); + } + std::println(""); +} +``` +* end()[color ff0000] +* h.insert[link insert.md] +* h.begin()[link begin.md] + +### 出力例 +``` +1 2 3 +``` + +## バージョン +### 言語 +- C++26 + +### 処理系 +- [Clang](/implementation.md#clang): 22 [mark noimpl] +- [GCC](/implementation.md#gcc): 16.1 [mark noimpl] +- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl] + + +## 参照 +- [P0447R28 Introduction of `std::hive` to the standard library](https://open-std.org/jtc1/sc22/wg21/docs/papers/2024/p0447r28.html) + - C++26で追加された diff --git a/reference/hive/hive/erase.md b/reference/hive/hive/erase.md new file mode 100644 index 0000000000..51f3ea6839 --- /dev/null +++ b/reference/hive/hive/erase.md @@ -0,0 +1,107 @@ +# erase +* hive[meta header] +* std[meta namespace] +* hive[meta class] +* function[meta id-type] +* cpp26[meta cpp] + +```cpp +iterator erase(const_iterator position); // (1) C++26 +iterator erase(const_iterator first, const_iterator last); // (2) C++26 +``` + +## 概要 +指定された要素をコンテナから削除する。 + + +## 要件 +- (1) : `position`が間接参照可能なイテレータであること +- (2) : `[first, last)`が有効なイテレータ範囲であること + + +## 効果 +- (1) : `position`が指す要素を削除する +- (2) : イテレータ範囲`[first, last)`の要素を削除する + + +## 戻り値 +削除された要素の次の要素を指すイテレータを返す。そのような要素が存在しない場合は、[`end()`](end.md)を返す。 + + +## 例外 +投げない + + +## 計算量 +削除される要素数に比例して線形時間。加えて、この関数呼び出しの結果としてアクティブな要素ブロックのいずれかが空になる場合、最悪でも要素ブロック数に比例して線形時間。 + + +## 備考 +削除された要素を指す参照・ポインタ・イテレータは無効になる。削除されなかった要素へのポインタ・参照・イテレータは無効にならない。 + +`*this`の最後の要素を削除する操作は、終端イテレータ（past-the-end iterator）も無効にする。 + + +## 例 +```cpp example +#include +#include + +int main() +{ + std::hive h; + for (int i = 1; i <= 5; ++i) { + h.insert(i); + } + + // 値が3の要素を削除する + for (auto it = h.begin(); it != h.end();) { + if (*it == 3) { + // 削除された要素の次を指すイテレータが返される + it = h.erase(it); + } + else { + ++it; + } + } + + for (int x : h) { + std::print("{} ", x); + } + std::println(""); + std::println("size = {}", h.size()); +} +``` +* erase[color ff0000] +* h.begin()[link begin.md] +* h.end()[link end.md] +* h.size()[link size.md] + +### 出力例 +``` +1 2 4 5 +size = 4 +``` + + +## バージョン +### 言語 +- C++26 + +### 処理系 +- [Clang](/implementation.md#clang): 22 [mark noimpl] +- [GCC](/implementation.md#gcc): 16.1 [mark noimpl] +- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl] + + +## 関連項目 + +| 名前 | 説明 | +|-------------------------|--------------------------| +| [`clear`](clear.md) | 全要素を削除する | +| [`insert`](insert.md) | 要素を挿入する | + + +## 参照 +- [P0447R28 Introduction of `std::hive` to the standard library](https://open-std.org/jtc1/sc22/wg21/docs/papers/2024/p0447r28.html) + - C++26で`hive`が追加された diff --git a/reference/hive/hive/erase_free.md b/reference/hive/hive/erase_free.md new file mode 100644 index 0000000000..ee6ffde1f9 --- /dev/null +++ b/reference/hive/hive/erase_free.md @@ -0,0 +1,77 @@ +# erase (非メンバ関数) +* hive[meta header] +* std[meta namespace] +* function template[meta id-type] +* cpp26[meta cpp] + +```cpp +namespace std { + template + typename hive::size_type + erase(hive& c, const U& value); // (1) C++26 +} +``` + +## 概要 +指定した値をもつ要素とその分の領域を、コンテナから削除する。 + + +## 効果 +以下と等価である： + +```cpp +return erase_if(c, [&](const auto& elem) -> bool { return elem == value; }); +``` +* erase_if[link erase_if_free.md] + + +## 戻り値 +削除した要素数を返す。 + + +## 例 +```cpp example +#include +#include + +int main() +{ + std::hive h = {3, 1, 4, 1, 5}; + + // コンテナhから、値1をもつ要素をすべて削除する + std::hive::size_type n = std::erase(h, 1); + + std::println("erased = {}", n); + for (int x : h) { + std::print("{} ", x); + } + std::println(""); +} +``` +* std::erase[color ff0000] + +### 出力 +``` +erased = 2 +3 4 5 +``` + + +## バージョン +### 言語 +- C++26 + +### 処理系 +- [Clang](/implementation.md#clang): 22 [mark noimpl] +- [GCC](/implementation.md#gcc): 16.1 [mark noimpl] +- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl] + + +## 関連項目 +- [`hive::erase`](erase.md) +- [`std::erase_if`](erase_if_free.md) + + +## 参照 +- [P0447R28 Introduction of `std::hive` to the standard library](https://open-std.org/jtc1/sc22/wg21/docs/papers/2024/p0447r28.html) + - C++26で`hive`が追加された diff --git a/reference/hive/hive/erase_if_free.md b/reference/hive/hive/erase_if_free.md new file mode 100644 index 0000000000..eb9a90e675 --- /dev/null +++ b/reference/hive/hive/erase_if_free.md @@ -0,0 +1,88 @@ +# erase_if +* hive[meta header] +* std[meta namespace] +* function template[meta id-type] +* cpp26[meta cpp] + +```cpp +namespace std { + template + typename hive::size_type + erase_if(hive& c, Predicate pred); // (1) C++26 +} +``` + +## 概要 +指定した条件に合致する要素とその分の領域を、コンテナから削除する。 + + +## 効果 +以下と等価である： + +```cpp +auto original_size = c.size(); +for (auto i = c.begin(); i != c.end(); ) { + if (pred(*i)) { + i = c.erase(i); + } else { + ++i; + } +} +return original_size - c.size(); +``` +* c.size()[link size.md] +* c.begin()[link begin.md] +* c.end()[link end.md] +* c.erase[link erase.md] + + +## 戻り値 +削除した要素数を返す。 + + +## 例 +```cpp example +#include +#include + +int main() +{ + std::hive h = {3, 1, 4, 5, 2}; + + // コンテナhから、偶数をすべて削除する + std::hive::size_type n = std::erase_if(h, [](int x) { return x % 2 == 0; }); + + std::println("erased = {}", n); + for (int x : h) { + std::print("{} ", x); + } + std::println(""); +} +``` +* std::erase_if[color ff0000] + +### 出力 +``` +erased = 2 +3 1 5 +``` + + +## バージョン +### 言語 +- C++26 + +### 処理系 +- [Clang](/implementation.md#clang): 22 [mark noimpl] +- [GCC](/implementation.md#gcc): 16.1 [mark noimpl] +- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl] + + +## 関連項目 +- [`hive::erase`](erase.md) +- [`std::erase`](erase_free.md) + + +## 参照 +- [P0447R28 Introduction of `std::hive` to the standard library](https://open-std.org/jtc1/sc22/wg21/docs/papers/2024/p0447r28.html) + - C++26で`hive`が追加された diff --git a/reference/hive/hive/get_allocator.md b/reference/hive/hive/get_allocator.md new file mode 100644 index 0000000000..5e0075e141 --- /dev/null +++ b/reference/hive/hive/get_allocator.md @@ -0,0 +1,58 @@ +# get_allocator +* hive[meta header] +* std[meta namespace] +* hive[meta class] +* function[meta id-type] +* cpp26[meta cpp] + +```cpp +allocator_type get_allocator() const noexcept; // (1) C++26 +``` + +## 概要 +このコンテナで使用されているアロケータオブジェクトを取得する。 + + +## 戻り値 +このコンテナで使用されているアロケータオブジェクト + + +## 例外 +投げない + + +## 例 +```cpp example +#include +#include + +int main() +{ + std::allocator alloc; + std::hive h(alloc); + + std::allocator result = h.get_allocator(); + + assert(result == alloc); +} +``` +* get_allocator()[color ff0000] + +### 出力 +``` +``` + + +## バージョン +### 言語 +- C++26 + +### 処理系 +- [Clang](/implementation.md#clang): 22 [mark noimpl] +- [GCC](/implementation.md#gcc): 16.1 [mark noimpl] +- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl] + + +## 参照 +- [P0447R28 Introduction of `std::hive` to the standard library](https://open-std.org/jtc1/sc22/wg21/docs/papers/2024/p0447r28.html) + - C++26で追加された diff --git a/reference/hive/hive/get_iterator.md b/reference/hive/hive/get_iterator.md new file mode 100644 index 0000000000..22a23425f9 --- /dev/null +++ b/reference/hive/hive/get_iterator.md @@ -0,0 +1,82 @@ +# get_iterator +* hive[meta header] +* std[meta namespace] +* hive[meta class] +* function[meta id-type] +* cpp26[meta cpp] + +```cpp +iterator get_iterator(const_pointer p) noexcept; // (1) C++26 +const_iterator get_iterator(const_pointer p) const noexcept; // (2) C++26 +``` + +## 概要 +`*this`の要素を指すポインタ`p`から、その要素を指すイテレータを取得する。 + +`hive`は要素のポインタ・参照が安定しているため、要素のポインタを保持しておき、後からそのポインタを指すイテレータを復元する用途で使用できる。 + + +## 事前条件 +`p`が`*this`の要素を指していること。 + + +## 戻り値 +`p`と同じ要素を指す`iterator`または`const_iterator`。 + + +## 計算量 +`*this`のアクティブブロック数に対して線形時間 + + +## 例 +```cpp example +#include +#include + +int main() +{ + std::hive h = {1, 2, 3}; + + // 要素のポインタを保持しておく + const int* p = &*h.begin(); + + // ポインタからイテレータを復元する + std::hive::iterator it = h.get_iterator(p); + + std::println("{}", *it); + + // 復元したイテレータで要素を削除する + h.erase(it); + std::println("size = {}", h.size()); +} +``` +* get_iterator[color ff0000] +* h.begin()[link begin.md] +* h.erase[link erase.md] +* h.size()[link size.md] + +### 出力 +``` +1 +size = 2 +``` + + +## バージョン +### 言語 +- C++26 + +### 処理系 +- [Clang](/implementation.md#clang): 22 [mark noimpl] +- [GCC](/implementation.md#gcc): 16.1 [mark noimpl] +- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl] + + +## 関連項目 +- [`hive::begin`](begin.md) +- [`hive::erase`](erase.md) + + +## 参照 +- [P0447R28 Introduction of `std::hive` to the standard library](https://open-std.org/jtc1/sc22/wg21/docs/papers/2024/p0447r28.html) + - C++26で`hive`が追加された diff --git a/reference/hive/hive/insert.md b/reference/hive/hive/insert.md new file mode 100644 index 0000000000..4a4c6447bc --- /dev/null +++ b/reference/hive/hive/insert.md @@ -0,0 +1,127 @@ +# insert +* hive[meta header] +* std[meta namespace] +* hive[meta class] +* function[meta id-type] +* cpp26[meta cpp] + +```cpp +iterator insert(const T& x); // (1) C++26 +iterator insert(T&& x); // (2) C++26 + +iterator insert(const_iterator hint, + const T& x); // (3) C++26 +iterator insert(const_iterator hint, + T&& x); // (4) C++26 + +void insert(initializer_list il); // (5) C++26 + +void insert(size_type n, const T& x); // (6) C++26 + +template +void insert(InputIterator first, + InputIterator last); // (7) C++26 +``` +* initializer_list[link /reference/initializer_list/initializer_list.md] + +## 概要 +新たな要素を挿入する。 + +挿入位置はコンテナが決定するため、挿入する位置を指定することはできない（順序は未規定である）。 + +- (1), (2) : 新たな要素をひとつ挿入する +- (3), (4) : `hint`を無視して、新たな要素をひとつ挿入する +- (5) : `initializer_list`の全ての要素を挿入する +- (6) : 新たな要素`x`のコピーを`n`個挿入する +- (7) : イテレータ範囲`[first, last)`の要素を挿入する + + +## テンプレートパラメータ制約 +- (5), (7) : 型`T`が、`*ranges::begin(rg)`から`hive`コンテナへの`EmplaceInsertable`であること。ここで`rg`は挿入する要素のRangeである +- (6) : 型`T`が、`hive`コンテナへの`CopyInsertable`であること + + +## 効果 +- (1), (2) : `return emplace(std::forward(x));`と等価である +- (3), (4) : `hint`引数を無視し、(1), (2)と等価な処理を行う +- (5) : `initializer_list`の各要素のコピーを挿入する。各イテレータはちょうど1回だけ間接参照される +- (6) : `x`のコピーを`n`個挿入する +- (7) : `insert_range(ranges::subrange(first, last))`と等価である + + +## 戻り値 +- (1), (2), (3), (4) : 新たに挿入された要素を指すイテレータ +- (5), (6), (7) : なし + + +## 計算量 +- (1), (2), (3), (4) : 定数時間。型`T`のオブジェクトがちょうど1個構築される +- (5), (7) : 挿入する要素数に比例して線形時間。挿入する各要素に対して、型`T`のオブジェクトがちょうど1個構築される +- (6) : `n`に比例して線形時間。挿入する各要素に対して、型`T`のオブジェクトがちょうど1個構築される + + +## 備考 +要素が挿入された場合、終端イテレータ（past-the-end iterator）は無効になる。削除されなかった既存要素へのポインタ・参照・イテレータは無効にならない。 + + +## 例 +```cpp example +#include +#include +#include + +int main() +{ + std::hive h; + + // ひとつの要素を挿入する + h.insert(1); + + // 初期化子リストの要素を挿入する + h.insert({2, 3}); + + // 値のコピーを複数個挿入する + h.insert(2u, 4); + + // イテレータ範囲の要素を挿入する + const std::vector v = {5, 6}; + h.insert(v.begin(), v.end()); + + for (int x : h) { + std::print("{} ", x); + } + std::println(""); + std::println("size = {}", h.size()); +} +``` +* insert[color ff0000] +* h.size()[link size.md] + +### 出力例 +``` +1 2 3 4 4 5 6 +size = 7 +``` + + +## バージョン +### 言語 +- C++26 + +### 処理系 +- [Clang](/implementation.md#clang): 22 [mark noimpl] +- [GCC](/implementation.md#gcc): 16.1 [mark noimpl] +- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl] + + +## 関連項目 + +| 名前 | 説明 | +|-----------------------------------|--------------------------| +| [`emplace`](emplace.md) | 要素を直接構築で挿入する | +| [`insert_range`](insert_range.md) | Rangeの要素を挿入する | + + +## 参照 +- [P0447R28 Introduction of `std::hive` to the standard library](https://open-std.org/jtc1/sc22/wg21/docs/papers/2024/p0447r28.html) + - C++26で`hive`が追加された diff --git a/reference/hive/hive/insert_range.md b/reference/hive/hive/insert_range.md new file mode 100644 index 0000000000..dba0ca828a --- /dev/null +++ b/reference/hive/hive/insert_range.md @@ -0,0 +1,90 @@ +# insert_range +* hive[meta header] +* std[meta namespace] +* hive[meta class] +* function template[meta id-type] +* cpp26[meta cpp] + +```cpp +template R> +void insert_range(R&& rg); // C++26 +``` + +## 概要 +Rangeの各要素を挿入する。 + +挿入位置はコンテナが決定するため、挿入する位置を指定することはできない（順序は未規定である）。 + + +## テンプレートパラメータ制約 +- 型`T`が、`*ranges::begin(rg)`から`hive`コンテナへの`EmplaceInsertable`であること +- `rg`と`*this`が重なっていないこと + + +## 効果 +Range`rg`の各要素のコピーを挿入する。範囲`rg`の各イテレータは、ちょうど1回だけ間接参照される。 + + +## 戻り値 +なし + + +## 計算量 +挿入する要素数に比例して線形時間。挿入する各要素に対して、型`T`のオブジェクトがちょうど1個構築される。 + + +## 備考 +要素が挿入された場合、終端イテレータ（past-the-end iterator）は無効になる。削除されなかった既存要素へのポインタ・参照・イテレータは無効にならない。 + + +## 例 +```cpp example +#include +#include +#include + +int main() +{ + std::hive h; + h.insert(1); + + // Rangeの要素を挿入する + const std::vector v = {2, 3, 4}; + h.insert_range(v); + + for (int x : h) { + std::print("{} ", x); + } + std::println(""); +} +``` +* insert_range[color ff0000] +* h.insert[link insert.md] + +### 出力例 +``` +1 2 3 4 +``` + + +## バージョン +### 言語 +- C++26 + +### 処理系 +- [Clang](/implementation.md#clang): 22 [mark noimpl] +- [GCC](/implementation.md#gcc): 16.1 [mark noimpl] +- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl] + + +## 関連項目 + +| 名前 | 説明 | +|-------------------------|--------------------------| +| [`insert`](insert.md) | 要素を挿入する | +| [`emplace`](emplace.md) | 要素を直接構築で挿入する | + + +## 参照 +- [P0447R28 Introduction of `std::hive` to the standard library](https://open-std.org/jtc1/sc22/wg21/docs/papers/2024/p0447r28.html) + - C++26で`hive`が追加された diff --git a/reference/hive/hive/is_within_hard_limits.md b/reference/hive/hive/is_within_hard_limits.md new file mode 100644 index 0000000000..72f330d06c --- /dev/null +++ b/reference/hive/hive/is_within_hard_limits.md @@ -0,0 +1,79 @@ +# is_within_hard_limits +* hive[meta header] +* std[meta namespace] +* hive[meta class] +* function[meta id-type] +* cpp26[meta cpp] + +```cpp +static constexpr bool is_within_hard_limits(hive_limits lim) noexcept; // C++26 +``` +* hive_limits[link ../hive_limits.md] + +## 概要 +指定した容量制限がハード制限の範囲内か判定する。 + +指定した容量制限`lim`が、処理系のハード制限（[`block_capacity_hard_limits()`](block_capacity_hard_limits.md)）の範囲内にあり、かつ`lim.min <= lim.max`を満たすかどうかを判定する。この関数は静的メンバ関数である。 + +`hive`のコンストラクタや[`reshape`](reshape.md)に渡す容量制限が妥当かどうかを、事前に確認するために使用できる。 + + +## 戻り値 +`hl`を[`block_capacity_hard_limits()`](block_capacity_hard_limits.md)として、以下を返す。 + +```cpp +hl.min <= lim.min && lim.min <= lim.max && lim.max <= hl.max +``` +* hl.min[link ../hive_limits.md] +* hl.max[link ../hive_limits.md] +* lim.min[link ../hive_limits.md] +* lim.max[link ../hive_limits.md] + + +## 例 +```cpp example +#include +#include + +int main() +{ + using hive = std::hive; + + // min > max となる制限は、ハード制限によらず常に範囲外と判定される + std::println("{}", hive::is_within_hard_limits({64, 8})); + + // 処理系のハード制限そのものは、常に範囲内と判定される + std::hive_limits hard = hive::block_capacity_hard_limits(); + std::println("{}", hive::is_within_hard_limits({hard.min, hard.max})); +} +``` +* is_within_hard_limits[color ff0000] +* std::hive_limits[link ../hive_limits.md] +* hive::block_capacity_hard_limits[link block_capacity_hard_limits.md] + +### 出力 +``` +false +true +``` + + +## バージョン +### 言語 +- C++26 + +### 処理系 +- [Clang](/implementation.md#clang): 22 [mark noimpl] +- [GCC](/implementation.md#gcc): 16.1 [mark noimpl] +- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl] + + +## 関連項目 +- [`hive_limits`](../hive_limits.md) +- [`hive::block_capacity_hard_limits`](block_capacity_hard_limits.md) +- [`hive::reshape`](reshape.md) + + +## 参照 +- [P0447R28 Introduction of `std::hive` to the standard library](https://open-std.org/jtc1/sc22/wg21/docs/papers/2024/p0447r28.html) + - C++26で追加された diff --git a/reference/hive/hive/max_size.md b/reference/hive/hive/max_size.md new file mode 100644 index 0000000000..954db48807 --- /dev/null +++ b/reference/hive/hive/max_size.md @@ -0,0 +1,65 @@ +# max_size +* hive[meta header] +* std[meta namespace] +* hive[meta class] +* function[meta id-type] +* cpp26[meta cpp] + +```cpp +size_type max_size() const noexcept; // (1) C++26 +``` + +## 概要 +コンテナに格納可能な最大の要素数を取得する。 + + +## 戻り値 +コンテナに格納可能な最大の要素数 + + +## 例外 +投げない + + +## 計算量 +定数時間 + + +## 例 +```cpp example +#include +#include + +int main() +{ + std::hive h; + + std::println("{}", h.max_size()); +} +``` +* max_size()[color ff0000] + +### 出力例 +``` +768614336404564650 +``` + + +## バージョン +### 言語 +- C++26 + +### 処理系 +- [Clang](/implementation.md#clang): 22 [mark noimpl] +- [GCC](/implementation.md#gcc): 16.1 [mark noimpl] +- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl] + + +## 関連項目 +- [`hive::size`](size.md) +- [`hive::capacity`](capacity.md) + + +## 参照 +- [P0447R28 Introduction of `std::hive` to the standard library](https://open-std.org/jtc1/sc22/wg21/docs/papers/2024/p0447r28.html) + - C++26で`hive`が追加された diff --git a/reference/hive/hive/op_assign.md b/reference/hive/hive/op_assign.md new file mode 100644 index 0000000000..ae7bc0cfde --- /dev/null +++ b/reference/hive/hive/op_assign.md @@ -0,0 +1,112 @@ +# operator= +* hive[meta header] +* std[meta namespace] +* hive[meta class] +* function[meta id-type] +* cpp26[meta cpp] + +```cpp +hive& operator=(const hive& x); // (1) C++26 + +hive& operator=(hive&& x) + noexcept(allocator_traits::propagate_on_container_move_assignment::value || + allocator_traits::is_always_equal::value); // (2) C++26 + +hive& operator=(initializer_list il); // (3) C++26 +``` +* initializer_list[link /reference/initializer_list/initializer_list.md] + +## 概要 +- (1) : コピー代入。 +- (2) : ムーブ代入。 +- (3) : 初期化子リストを代入。 + + +## 事前条件 +- (1) : 型`T`が`hive`に対して`CopyInsertable`かつ`CopyAssignable`であること。 +- (2) : `allocator_traits::propagate_on_container_move_assignment::value || allocator_traits::is_always_equal::value`が`false`である場合、型`T`が`hive`に対して`MoveInsertable`かつ`MoveAssignable`であること。 + + +## 効果 +- (1) : `*this`の全ての要素は、コピー代入されるか破棄される。`x`の全ての要素は、相対順序を保ったまま`*this`にコピーされる。 +- (2) : `*this`の全ての要素は、ムーブ代入されるか破棄される。 + - `allocator_traits::propagate_on_container_move_assignment::value || get_allocator() == x.get_allocator()`が`true`の場合、`x`の各要素ブロックを`*this`へ移動する。`x`の要素を指すポインタ・参照は、`*this`のメンバとなった同じ要素を指し続ける。`x`の要素を指すイテレータは、それらの要素を指し続けるが、`*this`のイテレータとして振る舞う。 + - 上記が`false`の場合、`x`の各要素を`*this`へ移動する。`x`の要素を指す参照・ポインタ・イテレータ、および`x`の終端イテレータは無効になる。 +- (3) : `il`の全ての要素を`*this`にコピー代入する。 + + +## 事後条件 +- (2) : `x.empty() == true`となる。`*this`の要素の相対順序は、呼び出し前の`x`の要素の相対順序と同じである。 + + +## 戻り値 +`*this` + + +## 計算量 +- (1) : `size() + x.size()`に対して線形時間 +- (2) : `size()`に対して線形時間。さらに`allocator_traits::propagate_on_container_move_assignment::value || get_allocator() == x.get_allocator()`が`false`である場合、`x.size()`に対しても線形時間 +- (3) : `size() + il.size()`に対して線形時間 + + +## 備考 +- (1) : 要素ブロックの容量制限を表す説明専用メンバ*current-limits*は変更されない。 +- (2) : `x`の各要素ブロックを移動する場合、*current-limits*は`x`のものに設定される。 + + +## 例 +```cpp example +#include +#include + +int main() +{ + std::hive h1 = {1, 2, 3}; + std::hive h2; + + // コピー代入 + h2 = h1; + std::println("h2.size() = {}", h2.size()); + + // ムーブ代入 + std::hive h3; + h3 = std::move(h1); + std::println("h3.size() = {}", h3.size()); + + // 初期化子リストの代入 + std::hive h4; + h4 = {1, 2, 3, 4}; + std::println("h4.size() = {}", h4.size()); +} +``` +* std::move[link /reference/utility/move.md] +* h2.size()[link size.md] +* h3.size()[link size.md] +* h4.size()[link size.md] + +### 出力 +``` +h2.size() = 3 +h3.size() = 3 +h4.size() = 4 +``` + + +## バージョン +### 言語 +- C++26 + +### 処理系 +- [Clang](/implementation.md#clang): 22 [mark noimpl] +- [GCC](/implementation.md#gcc): 16.1 [mark noimpl] +- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl] + + +## 関連項目 +- [`assign`](assign.md) +- [`assign_range`](assign_range.md) + + +## 参照 +- [P0447R28 Introduction of `std::hive` to the standard library](https://open-std.org/jtc1/sc22/wg21/docs/papers/2024/p0447r28.html) + - C++26で追加された diff --git a/reference/hive/hive/op_constructor.md b/reference/hive/hive/op_constructor.md new file mode 100644 index 0000000000..a4c80ed327 --- /dev/null +++ b/reference/hive/hive/op_constructor.md @@ -0,0 +1,180 @@ +# コンストラクタ +* hive[meta header] +* std[meta namespace] +* hive[meta class] +* function[meta id-type] +* cpp26[meta cpp] + +```cpp +constexpr hive() noexcept(noexcept(Allocator())); // (1) C++26 +constexpr explicit hive(const Allocator&) noexcept; // (2) C++26 + +constexpr explicit hive(hive_limits block_limits); // (3) C++26 +constexpr hive(hive_limits block_limits, + const Allocator&); // (4) C++26 + +explicit hive(size_type n, + const Allocator& = Allocator()); // (5) C++26 +hive(size_type n, hive_limits block_limits, + const Allocator& = Allocator()); // (6) C++26 + +hive(size_type n, const T& value, + const Allocator& = Allocator()); // (7) C++26 +hive(size_type n, const T& value, hive_limits block_limits, + const Allocator& = Allocator()); // (8) C++26 + +template +hive(InputIterator first, InputIterator last, + const Allocator& = Allocator()); // (9) C++26 +template +hive(InputIterator first, InputIterator last, hive_limits block_limits, + const Allocator& = Allocator()); // (10) C++26 + +template R> +hive(from_range_t, R&& rg, + const Allocator& = Allocator()); // (11) C++26 +template R> +hive(from_range_t, R&& rg, hive_limits block_limits, + const Allocator& = Allocator()); // (12) C++26 + +hive(const hive& x); // (13) C++26 +hive(hive&&) noexcept; // (14) C++26 + +hive(const hive& x, + const type_identity_t& alloc); // (15) C++26 +hive(hive&&, + const type_identity_t& alloc); // (16) C++26 + +hive(initializer_list il, + const Allocator& = Allocator()); // (17) C++26 +hive(initializer_list il, hive_limits block_limits, + const Allocator& = Allocator()); // (18) C++26 +``` +* type_identity_t[link /reference/type_traits/type_identity.md] +* initializer_list[link /reference/initializer_list/initializer_list.md] +* from_range_t[link /reference/ranges/from_range_t.md] +* hive_limits[link ../hive_limits.md] + + +## 概要 +`hive`オブジェクトを構築する。 + +- (1) : デフォルトコンストラクタ。アロケータをデフォルト構築して、空の`hive`を構築する。 +- (2) : アロケータを指定して、空の`hive`を構築する。 +- (3) : 要素ブロックの容量制限を指定して、空の`hive`を構築する。 +- (4) : 要素ブロックの容量制限とアロケータを指定して、空の`hive`を構築する。 +- (5) : `n`個のデフォルト挿入された要素を保持する`hive`を構築する。 +- (6) : (5)に加えて、要素ブロックの容量制限を指定する。 +- (7) : `value`のコピーを`n`個要素として保持する`hive`を構築する。 +- (8) : (7)に加えて、要素ブロックの容量制限を指定する。 +- (9) : イテレータ範囲`[first, last)`を要素としてコピーした`hive`を構築する。 +- (10) : (9)に加えて、要素ブロックの容量制限を指定する。 +- (11) : Range`rg`の要素で`hive`を構築する。 +- (12) : (11)に加えて、要素ブロックの容量制限を指定する。 +- (13) : コピーコンストラクタ。`x`と同じ要素を保持する`hive`を構築する。 +- (14) : ムーブコンストラクタ。`x`の指す先を自分の領域として`hive`を構築する。 +- (15) : アロケータを指定したコピーコンストラクタ。 +- (16) : アロケータを指定したムーブコンストラクタ。 +- (17) : 初期化子リストを受け取るコンストラクタ。`il`の要素で`hive`を構築する。 +- (18) : (17)に加えて、要素ブロックの容量制限を指定する。 + +[`hive_limits`](../hive_limits.md)を受け取るオーバーロード ((3), (4), (6), (8), (10), (12), (18)) は、指定した容量制限で説明専用メンバ*current-limits*を初期化する。`block_limits`がハード制限 ([`block_capacity_hard_limits`](block_capacity_hard_limits.md)) の範囲外であるか、`block_limits.min > block_limits.max`である場合、その動作はエラー性動作 (erroneous behavior) であり、効果は処理系定義である。 + + +## 事前条件 +- (5), (6) : 型`T`が`hive`に対して`DefaultInsertable`であること。 +- (7), (8), (13), (15), (17), (18) : 型`T`が`hive`に対して`CopyInsertable`であること。 +- (16) : `allocator_traits::is_always_equal::value`が`false`である場合、型`T`が`hive`に対して`MoveInsertable`であること。 + + +## 効果 +- (14), (16) (`alloc == x.get_allocator()`が`true`の場合) : `x`の各要素ブロックを`*this`へ移動する。`x`の要素を指すポインタ・参照は、`*this`のメンバとなった同じ要素を指し続ける。`x`の要素を指すイテレータは、それらの要素を指し続けるが、`*this`のイテレータとして振る舞う。 +- (16) (`alloc == x.get_allocator()`が`false`の場合) : `x`の各要素を`*this`へ移動する。`x`の要素を指す参照・ポインタ・イテレータ、および`x`の終端イテレータは無効になる。 + + +## 事後条件 +- (14), (16) : `x.empty() == true`となる。`*this`の要素の相対順序は、呼び出し前の`x`の要素の相対順序と同じである。 + + +## 計算量 +- (1), (2), (3), (4) : 定数時間 +- (5), (6), (7), (8) : `n`に対して線形時間 +- (9), (10) : [`distance`](/reference/iterator/distance.md)`(first, last)`に対して線形時間 +- (11), (12) : [`ranges::distance`](/reference/iterator/ranges_distance.md)`(rg)`に対して線形時間 +- (13), (15) : `x.`[`size`](size.md)`()`に対して線形時間 +- (14) : 定数時間 +- (16) : `alloc == x.get_allocator()`が`false`であれば`x.`[`size`](size.md)`()`に対して線形時間。そうでなければ定数時間 +- (17), (18) : `il.`[`size`](/reference/initializer_list/initializer_list/size.md)`()`に対して線形時間 + + +## 備考 +- (13), (15) : `x`の*current-limits*で`*this`の*current-limits*を初期化する。 +- (14), (16) : `x`の各要素ブロックを移動する場合、*current-limits*は`x`のものに設定される。 + + +## 例 +```cpp example +#include +#include +#include + +int main() +{ + // デフォルト構築 + std::hive h1; + + // n個の値を保持する + std::hive h2(3, 1); + + // イテレータ範囲から構築 + int a[] = {1, 2, 3}; + std::hive h3(std::begin(a), std::end(a)); + + // 初期化子リストから構築 + std::hive h4 = {1, 2, 3}; + + // コピー構築 + std::hive h5 = h4; + + std::println("h1.size() = {}", h1.size()); + std::println("h2.size() = {}", h2.size()); + std::println("h3.size() = {}", h3.size()); + std::println("h4.size() = {}", h4.size()); + std::println("h5.size() = {}", h5.size()); +} +``` +* std::hive[color ff0000] +* h1.size()[link size.md] +* h2.size()[link size.md] +* h3.size()[link size.md] +* h4.size()[link size.md] +* h5.size()[link size.md] + +### 出力 +``` +h1.size() = 0 +h2.size() = 3 +h3.size() = 3 +h4.size() = 3 +h5.size() = 3 +``` + + +## バージョン +### 言語 +- C++26 + +### 処理系 +- [Clang](/implementation.md#clang): 22 [mark noimpl] +- [GCC](/implementation.md#gcc): 16.1 [mark noimpl] +- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl] + + +## 関連項目 +- [`assign`](assign.md) +- [`assign_range`](assign_range.md) + + +## 参照 +- [P0447R28 Introduction of `std::hive` to the standard library](https://open-std.org/jtc1/sc22/wg21/docs/papers/2024/p0447r28.html) + - C++26で追加された diff --git a/reference/hive/hive/op_deduction_guide.md b/reference/hive/hive/op_deduction_guide.md new file mode 100644 index 0000000000..9de2253b2e --- /dev/null +++ b/reference/hive/hive/op_deduction_guide.md @@ -0,0 +1,89 @@ +# 推論補助 +* hive[meta header] +* std[meta namespace] +* hive[meta class] +* cpp26[meta cpp] + +```cpp +namespace std { + template ::value_type>> + hive(InputIterator, InputIterator, Allocator = Allocator()) + -> hive::value_type, Allocator>; // (1) + + template ::value_type>> + hive(InputIterator, InputIterator, hive_limits, Allocator = Allocator()) + -> hive::value_type, Allocator>; // (2) + + template >> + hive(from_range_t, R&&, Allocator = Allocator()) + -> hive, Allocator>; // (3) + + template >> + hive(from_range_t, R&&, hive_limits, Allocator = Allocator()) + -> hive, Allocator>; // (4) +} +``` +* ranges::input_range[link /reference/ranges/input_range.md] +* allocator[link /reference/memory/allocator.md] +* ranges::range_value_t[link /reference/ranges/range_value_t.md] +* from_range_t[link /reference/ranges/from_range_t.md] +* hive_limits[link ../hive_limits.md] + +## 概要 +`std::hive`クラステンプレートの型推論補助。 + +- (1) : イテレータ範囲から推論する。 +- (2) : イテレータ範囲と要素ブロックの容量制限から推論する。 +- (3) : Rangeから推論する。 +- (4) : Rangeと要素ブロックの容量制限から推論する。 + + +## 例 +```cpp example +#include +#include +#include + +int main() +{ + std::vector v = {1, 2, 3}; + + // イテレータ範囲からの推論 + std::hive h1(v.begin(), v.end()); + static_assert(std::is_same_v>); + + // Rangeからの推論 + std::hive h2(std::from_range, v); + static_assert(std::is_same_v>); +} +``` +* std::from_range[link /reference/ranges/from_range_t.md] +* v.begin()[link /reference/vector/vector/begin.md] +* v.end()[link /reference/vector/vector/end.md] + +### 出力 +``` +``` + + +## バージョン +### 言語 +- C++26 + +### 処理系 +- [Clang](/implementation.md#clang): 22 [mark noimpl] +- [GCC](/implementation.md#gcc): 16.1 [mark noimpl] +- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl] + + +## 関連項目 +- [C++17 クラステンプレートのテンプレート引数推論](/lang/cpp17/type_deduction_for_class_templates.md) + + +## 参照 +- [P0447R28 Introduction of `std::hive` to the standard library](https://open-std.org/jtc1/sc22/wg21/docs/papers/2024/p0447r28.html) + - C++26で`hive`が追加された diff --git a/reference/hive/hive/op_destructor.md b/reference/hive/hive/op_destructor.md new file mode 100644 index 0000000000..1af11eefb8 --- /dev/null +++ b/reference/hive/hive/op_destructor.md @@ -0,0 +1,36 @@ +# デストラクタ +* hive[meta header] +* std[meta namespace] +* hive[meta class] +* function[meta id-type] +* cpp26[meta cpp] + +```cpp +~hive(); // (1) C++26 +``` + +## 概要 +`hive`が保持している全ての要素に対してデストラクタを実行し、確保していた全ての要素ブロックのメモリを解放する。 + + +## 例外 +投げない + + +## 計算量 +要素数に対して線形時間 + + +## バージョン +### 言語 +- C++26 + +### 処理系 +- [Clang](/implementation.md#clang): 22 [mark noimpl] +- [GCC](/implementation.md#gcc): 16.1 [mark noimpl] +- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl] + + +## 参照 +- [P0447R28 Introduction of `std::hive` to the standard library](https://open-std.org/jtc1/sc22/wg21/docs/papers/2024/p0447r28.html) + - C++26で追加された diff --git a/reference/hive/hive/rbegin.md b/reference/hive/hive/rbegin.md new file mode 100644 index 0000000000..b31a3831e3 --- /dev/null +++ b/reference/hive/hive/rbegin.md @@ -0,0 +1,69 @@ +# rbegin +* hive[meta header] +* std[meta namespace] +* hive[meta class] +* function[meta id-type] +* cpp26[meta cpp] + +```cpp +reverse_iterator rbegin() noexcept; // (1) C++26 +const_reverse_iterator rbegin() const noexcept; // (2) C++26 +``` + +## 概要 +末尾要素を指す逆イテレータを取得する。 + + +## 戻り値 +末尾要素を指す逆イテレータ + + +## 例外 +投げない + + +## 計算量 +定数時間 + + +## 例 +```cpp example +#include +#include + +int main() +{ + std::hive h; + h.insert(1); + h.insert(2); + h.insert(3); + + // rbegin()からrend()まで末尾から逆順に走査する + for (auto it = h.rbegin(); it != h.rend(); ++it) { + std::print("{} ", *it); + } + std::println(""); +} +``` +* rbegin()[color ff0000] +* h.insert[link insert.md] +* h.rend()[link rend.md] + +### 出力例 +``` +3 2 1 +``` + +## バージョン +### 言語 +- C++26 + +### 処理系 +- [Clang](/implementation.md#clang): 22 [mark noimpl] +- [GCC](/implementation.md#gcc): 16.1 [mark noimpl] +- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl] + + +## 参照 +- [P0447R28 Introduction of `std::hive` to the standard library](https://open-std.org/jtc1/sc22/wg21/docs/papers/2024/p0447r28.html) + - C++26で追加された diff --git a/reference/hive/hive/rend.md b/reference/hive/hive/rend.md new file mode 100644 index 0000000000..5a82bb9972 --- /dev/null +++ b/reference/hive/hive/rend.md @@ -0,0 +1,71 @@ +# rend +* hive[meta header] +* std[meta namespace] +* hive[meta class] +* function[meta id-type] +* cpp26[meta cpp] + +```cpp +reverse_iterator rend() noexcept; // (1) C++26 +const_reverse_iterator rend() const noexcept; // (2) C++26 +``` + +## 概要 +先頭の前を指す逆イテレータを取得する。 + +このイテレータは、逆順走査における終端を表す番兵として使用する。 + + +## 戻り値 +先頭の前を指す逆イテレータ + + +## 例外 +投げない + + +## 計算量 +定数時間 + + +## 例 +```cpp example +#include +#include + +int main() +{ + std::hive h; + h.insert(1); + h.insert(2); + h.insert(3); + + // rbegin()からrend()まで末尾から逆順に走査する + for (auto it = h.rbegin(); it != h.rend(); ++it) { + std::print("{} ", *it); + } + std::println(""); +} +``` +* rend()[color ff0000] +* h.insert[link insert.md] +* h.rbegin()[link rbegin.md] + +### 出力例 +``` +3 2 1 +``` + +## バージョン +### 言語 +- C++26 + +### 処理系 +- [Clang](/implementation.md#clang): 22 [mark noimpl] +- [GCC](/implementation.md#gcc): 16.1 [mark noimpl] +- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl] + + +## 参照 +- [P0447R28 Introduction of `std::hive` to the standard library](https://open-std.org/jtc1/sc22/wg21/docs/papers/2024/p0447r28.html) + - C++26で追加された diff --git a/reference/hive/hive/reserve.md b/reference/hive/hive/reserve.md new file mode 100644 index 0000000000..2ebb1254ea --- /dev/null +++ b/reference/hive/hive/reserve.md @@ -0,0 +1,92 @@ +# reserve +* hive[meta header] +* std[meta namespace] +* hive[meta class] +* function[meta id-type] +* cpp26[meta cpp] + +```cpp +void reserve(size_type n); // (1) C++26 +``` + +## 概要 +指定した要素数を格納できるよう容量を確保する。 + + +## 効果 +`n <= capacity()`である場合、何もしない。そうでなければ、予約ブロックを確保することで[`capacity()`](capacity.md)を増加させる。 + + +## 戻り値 +なし + + +## 事後条件 +`capacity() >= n`である。 + + +## 例外 +事後条件を満たすことで[`capacity()`](capacity.md)が[`max_size()`](max_size.md)を超える場合、`length_error`例外を送出する。また、アロケータが送出するあらゆる例外を送出する。 + + +## 計算量 +確保される予約ブロックの数に対して線形時間 + + +## 備考 +`*this`の要素を指す全ての参照・ポインタ・イテレータ、および終端イテレータは有効なまま保たれる。 + + +## 例 +```cpp example +#include +#include + +int main() +{ + std::hive h; + + // 100要素分の領域を予約する + h.reserve(100); + std::println("capacity >= 100 : {}", h.capacity() >= 100); + + // 予約済みの領域に要素を挿入する + int* p = &*h.insert(42); + + // 予約した容量の範囲内では、挿入時に新たなメモリ確保が発生しない + for (int i = 0; i < 50; ++i) { + h.insert(i); + } + std::println("{}", *p); +} +``` +* reserve[color ff0000] +* h.capacity()[link capacity.md] +* h.insert[link insert.md] + +### 出力 +``` +capacity >= 100 : true +42 +``` + + +## バージョン +### 言語 +- C++26 + +### 処理系 +- [Clang](/implementation.md#clang): 22 [mark noimpl] +- [GCC](/implementation.md#gcc): 16.1 [mark noimpl] +- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl] + + +## 関連項目 +- [`hive::capacity`](capacity.md) +- [`hive::shrink_to_fit`](shrink_to_fit.md) +- [`hive::trim_capacity`](trim_capacity.md) + + +## 参照 +- [P0447R28 Introduction of `std::hive` to the standard library](https://open-std.org/jtc1/sc22/wg21/docs/papers/2024/p0447r28.html) + - C++26で`hive`が追加された diff --git a/reference/hive/hive/reshape.md b/reference/hive/hive/reshape.md new file mode 100644 index 0000000000..9010d6ff73 --- /dev/null +++ b/reference/hive/hive/reshape.md @@ -0,0 +1,98 @@ +# reshape +* hive[meta header] +* std[meta namespace] +* hive[meta class] +* function[meta id-type] +* cpp26[meta cpp] + +```cpp +void reshape(hive_limits block_limits); // C++26 +``` +* hive_limits[link ../hive_limits.md] + +## 概要 +要素ブロックの容量制限を変更する。 + +要素ブロックが保持できる要素数の下限・上限（[`hive_limits`](../hive_limits.md)）を`block_limits`に変更する。新しい制限の範囲外となる要素ブロックがあれば、その要素を範囲内の要素ブロックに再割り当てし、範囲外の要素ブロックを解放する。 + + +## 事前条件 +型`T`が`*this`に対してムーブ挿入可能であること。 + + +## 効果 +`block_limits`の範囲外にあるすべてのアクティブブロックについて、そのブロック内の要素を、範囲内にある新規または既存の要素ブロックへ再割り当てする。`block_limits`の範囲外にある要素ブロックはすべて解放する。 + +新しい要素ブロックの確保中に例外が送出された場合、[`capacity()`](capacity.md)は削減されることがあり、再割り当てが発生することがあり、現在の容量制限に`block_limits`以外の値が設定されることがある。そうでない場合、現在の容量制限に`block_limits`が設定される。それ以外の例外が送出された場合の効果は未規定である。 + + +## 戻り値 +なし + + +## 事後条件 +[`size()`](size.md)は変化しない。 + + +## 計算量 +`*this`の要素ブロックの数に対して線形時間。再割り当てが発生する場合、加えて再割り当てされる要素の数に対して線形時間。 + + +## 備考 +この操作は[`capacity()`](capacity.md)を変化させることがある。再割り当てが発生する場合、`*this`の要素の順序が変化することがあり、`*this`の要素を指すすべての参照、ポインタ、イテレータ、および終端イテレータが無効になる。再割り当てが発生しなかった場合、これらは有効なままである。 + + +## 例 +```cpp example +#include +#include + +int main() +{ + // 最小3・最大16の容量制限で構築する + std::hive h{std::hive_limits{3, 16}}; + + for (int i = 0; i < 100; ++i) { + h.insert(i); + } + + // 容量制限をより大きなブロックへ変更する + h.reshape(std::hive_limits{32, 64}); + + std::println("min={}, max={}", h.block_capacity_limits().min, + h.block_capacity_limits().max); + std::println("size={}", h.size()); +} +``` +* reshape[color ff0000] +* std::hive_limits[link ../hive_limits.md] +* h.insert[link insert.md] +* h.block_capacity_limits()[link block_capacity_limits.md] +* h.size()[link size.md] + +### 出力 +``` +min=32, max=64 +size=100 +``` + + +## バージョン +### 言語 +- C++26 + +### 処理系 +- [Clang](/implementation.md#clang): 22 [mark noimpl] +- [GCC](/implementation.md#gcc): 16.1 [mark noimpl] +- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl] + + +## 関連項目 +- [`hive_limits`](../hive_limits.md) +- [`hive::block_capacity_limits`](block_capacity_limits.md) +- [`hive::is_within_hard_limits`](is_within_hard_limits.md) + + +## 参照 +- [P0447R28 Introduction of `std::hive` to the standard library](https://open-std.org/jtc1/sc22/wg21/docs/papers/2024/p0447r28.html) + - C++26で追加された diff --git a/reference/hive/hive/shrink_to_fit.md b/reference/hive/hive/shrink_to_fit.md new file mode 100644 index 0000000000..39eb457291 --- /dev/null +++ b/reference/hive/hive/shrink_to_fit.md @@ -0,0 +1,93 @@ +# shrink_to_fit +* hive[meta header] +* std[meta namespace] +* hive[meta class] +* function[meta id-type] +* cpp26[meta cpp] + +```cpp +void shrink_to_fit(); // (1) C++26 +``` + +## 概要 +容量を要素数に近づける。 + + +## 事前条件 +型`T`が`*this`に対してムーブ挿入可能であること。 + + +## 効果 +[`capacity()`](capacity.md)を[`size()`](size.md)に近づけるという非拘束の（non-binding）リクエストを行う。 + +- このリクエストは、実装依存の最適化を許可するために非拘束である。 +- この関数によって[`capacity()`](capacity.md)が増えることはないが、[`capacity()`](capacity.md)が縮小することはある。 +- 要素の再割り当てが発生する場合がある。 +- [`capacity()`](capacity.md)がすでに[`size()`](size.md)と等しい場合、何もしない。 +- 新たな要素ブロックの確保中に例外が送出された場合、[`capacity()`](capacity.md)が縮小されることや再割り当てが発生することがある。それ以外で例外が送出された場合、効果は未規定である。 + + +## 戻り値 +なし + + +## 計算量 +再割り当てが発生した場合、シーケンスのサイズに対して線形時間 + + +## 備考 +再割り当てが発生した場合、`*this`の要素の順序が変わる可能性があり、`*this`の要素を指す全ての参照・ポインタ・イテレータ、および終端イテレータは無効になる。 + + +## 例 +```cpp example +#include +#include + +int main() +{ + std::hive h; + h.reserve(100); + std::println("capacity >= 100 : {}", h.capacity() >= 100); + + h.insert(1); + h.insert(2); + h.insert(3); + + // 容量を要素数に近づけるよう要求する + h.shrink_to_fit(); + std::println("size = {}", h.size()); +} +``` +* shrink_to_fit()[color ff0000] +* h.reserve[link reserve.md] +* h.capacity()[link capacity.md] +* h.insert[link insert.md] +* h.size()[link size.md] + +### 出力 +``` +capacity >= 100 : true +size = 3 +``` + + +## バージョン +### 言語 +- C++26 + +### 処理系 +- [Clang](/implementation.md#clang): 22 [mark noimpl] +- [GCC](/implementation.md#gcc): 16.1 [mark noimpl] +- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl] + + +## 関連項目 +- [`hive::capacity`](capacity.md) +- [`hive::reserve`](reserve.md) +- [`hive::trim_capacity`](trim_capacity.md) + + +## 参照 +- [P0447R28 Introduction of `std::hive` to the standard library](https://open-std.org/jtc1/sc22/wg21/docs/papers/2024/p0447r28.html) + - C++26で`hive`が追加された diff --git a/reference/hive/hive/size.md b/reference/hive/hive/size.md new file mode 100644 index 0000000000..c0141869fc --- /dev/null +++ b/reference/hive/hive/size.md @@ -0,0 +1,65 @@ +# size +* hive[meta header] +* std[meta namespace] +* hive[meta class] +* function[meta id-type] +* cpp26[meta cpp] + +```cpp +size_type size() const noexcept; // (1) C++26 +``` + +## 概要 +コンテナの要素数を取得する。 + + +## 戻り値 +要素数を返す。 + + +## 例外 +投げない + + +## 計算量 +定数時間 + + +## 例 +```cpp example +#include +#include + +int main() +{ + std::hive h = {3, 1, 4, 5, 2}; + + std::println("{}", h.size()); +} +``` +* size()[color ff0000] + +### 出力 +``` +5 +``` + + +## バージョン +### 言語 +- C++26 + +### 処理系 +- [Clang](/implementation.md#clang): 22 [mark noimpl] +- [GCC](/implementation.md#gcc): 16.1 [mark noimpl] +- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl] + + +## 関連項目 +- [`hive::empty`](empty.md) +- [`hive::max_size`](max_size.md) + + +## 参照 +- [P0447R28 Introduction of `std::hive` to the standard library](https://open-std.org/jtc1/sc22/wg21/docs/papers/2024/p0447r28.html) + - C++26で`hive`が追加された diff --git a/reference/hive/hive/sort.md b/reference/hive/hive/sort.md new file mode 100644 index 0000000000..236eab697b --- /dev/null +++ b/reference/hive/hive/sort.md @@ -0,0 +1,83 @@ +# sort +* hive[meta header] +* std[meta namespace] +* hive[meta class] +* function[meta id-type] +* cpp26[meta cpp] + +```cpp +template > +void sort(Compare comp = Compare()); // (1) C++26 +``` +* less[link /reference/functional/less.md] + +## 概要 +要素を並べ替える。 + + +## 事前条件 +型`T`が`hive`に対して`MoveInsertable`であり、かつ`MoveAssignable`かつ`Swappable`であること。 + + +## 効果 +関数オブジェクト`comp`に基いて`*this`の要素を並べ替える。例外が送出された場合、`*this`の要素の順序は未規定である。 + + +## 戻り値 +なし + + +## 計算量 +`N`を[`size()`](size.md)として、$O(N \log N)$回の比較 + + +## 備考 +- メモリを確保する可能性がある。 +- `*this`の要素を指す参照・ポインタ・イテレータ、および終端イテレータは無効化される可能性がある。 +- この操作は安定であることを要求されない。 + + +## 例 +```cpp example +#include +#include + +int main() +{ + std::hive h = {3, 1, 4, 1, 5, 2}; + + // 昇順に並べ替える + h.sort(); + + for (int x : h) { + std::print("{} ", x); + } + std::println(""); +} +``` +* sort[color ff0000] + +### 出力 +``` +1 1 2 3 4 5 +``` + + +## バージョン +### 言語 +- C++26 + +### 処理系 +- [Clang](/implementation.md#clang): 22 [mark noimpl] +- [GCC](/implementation.md#gcc): 16.1 [mark noimpl] +- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl] + + +## 関連項目 +- [`hive::unique`](unique.md) +- [`std::sort`](/reference/algorithm/sort.md) + + +## 参照 +- [P0447R28 Introduction of `std::hive` to the standard library](https://open-std.org/jtc1/sc22/wg21/docs/papers/2024/p0447r28.html) + - C++26で`hive`が追加された diff --git a/reference/hive/hive/splice.md b/reference/hive/hive/splice.md new file mode 100644 index 0000000000..6440c78eec --- /dev/null +++ b/reference/hive/hive/splice.md @@ -0,0 +1,89 @@ +# splice +* hive[meta header] +* std[meta namespace] +* hive[meta class] +* function[meta id-type] +* cpp26[meta cpp] + +```cpp +void splice(hive& x); // (1) C++26 +void splice(hive&& x); // (2) C++26 +``` + +## 概要 +他の`hive`オブジェクト`x`の全ての要素を`*this`に移動して連結する。 + + +## 事前条件 +`get_allocator() == x.get_allocator()`が`true`であること。 + + +## 効果 +- [`addressof`](/reference/memory/addressof.md)`(x) == this`が`true`である場合、その動作はエラー性動作（erroneous behavior）であり、何もしない。 +- 例外が送出された場合、何もしない。 +- そうでなければ、`x`の全ての要素を`*this`に移動し、`x`を空にする。移動された`x`の要素を指すポインタおよび参照は、`*this`のメンバとしての同じ要素を指すようになる。移動された要素を指すイテレータは、引き続き同じ要素を指すが、`x`ではなく`*this`のイテレータとして振る舞う。 + + +## 戻り値 +なし + + +## 例外 +`x`のアクティブブロックのうち、いずれかが[`block_capacity_limits()`](block_capacity_limits.md)の範囲内にない場合、`length_error`例外を送出する。また、アロケータが送出するあらゆる例外を送出する。 + + +## 計算量 +`x`の全ての要素ブロック数と`*this`の全ての要素ブロック数の総和に対して線形時間 + + +## 備考 +- `x`の予約ブロックは`*this`に移動されない。 +- [`addressof`](/reference/memory/addressof.md)`(x) == this`が`false`である場合、`x`と`*this`の両方の終端イテレータを無効化する。 + + +## 例 +```cpp example +#include +#include + +int main() +{ + std::hive h1 = {1, 2, 3}; + std::hive h2 = {4, 5, 6}; + + // h2の全ての要素をh1に移動して連結する + h1.splice(h2); + + std::println("h1.size() = {}", h1.size()); + std::println("h2.empty() = {}", h2.empty()); +} +``` +* splice[color ff0000] +* h1.size()[link size.md] +* h2.empty()[link empty.md] + +### 出力 +``` +h1.size() = 6 +h2.empty() = true +``` + + +## バージョン +### 言語 +- C++26 + +### 処理系 +- [Clang](/implementation.md#clang): 22 [mark noimpl] +- [GCC](/implementation.md#gcc): 16.1 [mark noimpl] +- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl] + + +## 関連項目 +- [`hive::insert`](insert.md) +- [`hive::block_capacity_limits`](block_capacity_limits.md) + + +## 参照 +- [P0447R28 Introduction of `std::hive` to the standard library](https://open-std.org/jtc1/sc22/wg21/docs/papers/2024/p0447r28.html) + - C++26で`hive`が追加された diff --git a/reference/hive/hive/swap.md b/reference/hive/hive/swap.md new file mode 100644 index 0000000000..2d5d451ecc --- /dev/null +++ b/reference/hive/hive/swap.md @@ -0,0 +1,93 @@ +# swap +* hive[meta header] +* std[meta namespace] +* hive[meta class] +* function[meta id-type] +* cpp26[meta cpp] + +```cpp +void swap(hive& x) + noexcept(allocator_traits::propagate_on_container_swap::value || + allocator_traits::is_always_equal::value); // C++26 +``` + +## 概要 +他の`hive`オブジェクトと内容を入れ替える。 + + +## 効果 +`*this`の内容、[`capacity()`](capacity.md)、および要素ブロックの現在の容量制限（`current-limits`）を`x`のものと交換する。 + + +## 戻り値 +なし + + +## 計算量 +定数時間 + + +## 備考 +この操作によって、要素へのポインタ・参照・イテレータが指す先の要素は変わらず、交換後もそれぞれの要素を指し続ける。ただしそれらが所属するコンテナは入れ替わる。 + + +## 例 +```cpp example +#include +#include + +int main() +{ + std::hive h1; + h1.insert(1); + h1.insert(2); + + std::hive h2; + h2.insert(3); + + h1.swap(h2); + + std::print("h1: "); + for (int x : h1) { + std::print("{} ", x); + } + std::println(""); + + std::print("h2: "); + for (int x : h2) { + std::print("{} ", x); + } + std::println(""); +} +``` +* swap[color ff0000] +* h1.insert[link insert.md] +* h2.insert[link insert.md] + +### 出力例 +``` +h1: 3 +h2: 1 2 +``` + + +## バージョン +### 言語 +- C++26 + +### 処理系 +- [Clang](/implementation.md#clang): 22 [mark noimpl] +- [GCC](/implementation.md#gcc): 16.1 [mark noimpl] +- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl] + + +## 関連項目 + +| 名前 | 説明 | +|-------------------------------|-------------------------------------| +| [`swap`](swap_free.md) | 2つの`hive`オブジェクトを入れ替える | + + +## 参照 +- [P0447R28 Introduction of `std::hive` to the standard library](https://open-std.org/jtc1/sc22/wg21/docs/papers/2024/p0447r28.html) + - C++26で`hive`が追加された diff --git a/reference/hive/hive/swap_free.md b/reference/hive/hive/swap_free.md new file mode 100644 index 0000000000..573a450640 --- /dev/null +++ b/reference/hive/hive/swap_free.md @@ -0,0 +1,77 @@ +# swap (非メンバ関数) +* hive[meta header] +* std[meta namespace] +* function template[meta id-type] +* cpp26[meta cpp] + +```cpp +namespace std { + template + void swap(hive& x, + hive& y) noexcept(noexcept(x.swap(y))); // (1) C++26 +} +``` + +## 概要 +2つの`hive`オブジェクトを入れ替える。 + + +## 効果 +`x.`[`swap`](swap.md)`(y)`と等価である。 + + +## 戻り値 +なし + + +## 例 +```cpp example +#include +#include + +void print(const char* name, const std::hive& h) +{ + std::print("{} : ", name); + for (int x : h) { + std::print("{} ", x); + } + std::println(""); +} + +int main() +{ + std::hive h1 = {1, 2, 3}; + std::hive h2 = {4, 5, 6}; + + std::swap(h1, h2); + + print("h1", h1); + print("h2", h2); +} +``` +* std::swap[color ff0000] + +### 出力 +``` +h1 : 4 5 6 +h2 : 1 2 3 +``` + + +## バージョン +### 言語 +- C++26 + +### 処理系 +- [Clang](/implementation.md#clang): 22 [mark noimpl] +- [GCC](/implementation.md#gcc): 16.1 [mark noimpl] +- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl] + + +## 関連項目 +- [`hive::swap`](swap.md) + + +## 参照 +- [P0447R28 Introduction of `std::hive` to the standard library](https://open-std.org/jtc1/sc22/wg21/docs/papers/2024/p0447r28.html) + - C++26で`hive`が追加された diff --git a/reference/hive/hive/trim_capacity.md b/reference/hive/hive/trim_capacity.md new file mode 100644 index 0000000000..872d6e37a8 --- /dev/null +++ b/reference/hive/hive/trim_capacity.md @@ -0,0 +1,83 @@ +# trim_capacity +* hive[meta header] +* std[meta namespace] +* hive[meta class] +* function[meta id-type] +* cpp26[meta cpp] + +```cpp +void trim_capacity() noexcept; // (1) C++26 +void trim_capacity(size_type n) noexcept; // (2) C++26 +``` + +## 概要 +予約ブロックを解放して容量を削減する。 + +要素を格納していない要素ブロック（予約ブロック）を解放することで、[`capacity()`](capacity.md)を削減する。 + + +## 効果 +- (1) : すべての予約ブロックを解放し、それに応じて[`capacity()`](capacity.md)を削減する。 +- (2) : `n >= capacity()`が`true`である場合、何もしない。そうでない場合、[`capacity()`](capacity.md)を`n`以上の値まで削減する。 + + +## 戻り値 +なし + + +## 計算量 +解放される予約ブロックの数に対して線形時間。 + + +## 備考 +`*this`の要素を指すすべての参照、ポインタ、イテレータ、および終端イテレータは有効なままである。 + + +## 例 +```cpp example +#include +#include + +int main() +{ + std::hive h; + + // 100要素分の容量を予約する + h.reserve(100); + std::println("capacity = {}", h.capacity()); + + // 予約ブロックを解放して容量を削減する + h.trim_capacity(); + std::println("capacity = {}", h.capacity()); +} +``` +* trim_capacity[color ff0000] +* h.reserve[link reserve.md] +* h.capacity()[link capacity.md] + +### 出力例 +``` +capacity = 100 +capacity = 0 +``` + + +## バージョン +### 言語 +- C++26 + +### 処理系 +- [Clang](/implementation.md#clang): 22 [mark noimpl] +- [GCC](/implementation.md#gcc): 16.1 [mark noimpl] +- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl] + + +## 関連項目 +- [`hive::capacity`](capacity.md) +- [`hive::reserve`](reserve.md) +- [`hive::shrink_to_fit`](shrink_to_fit.md) + + +## 参照 +- [P0447R28 Introduction of `std::hive` to the standard library](https://open-std.org/jtc1/sc22/wg21/docs/papers/2024/p0447r28.html) + - C++26で追加された diff --git a/reference/hive/hive/unique.md b/reference/hive/hive/unique.md new file mode 100644 index 0000000000..99ce3f6a71 --- /dev/null +++ b/reference/hive/hive/unique.md @@ -0,0 +1,87 @@ +# unique +* hive[meta header] +* std[meta namespace] +* hive[meta class] +* function[meta id-type] +* cpp26[meta cpp] + +```cpp +template > +size_type unique(BinaryPredicate binary_pred = BinaryPredicate()); // (1) C++26 +``` +* equal_to[link /reference/functional/equal_to.md] + +## 概要 +連続した等価な要素群について、その先頭以外を削除する。 + + +## 事前条件 +`binary_pred`が同値関係であること。 + + +## 効果 +連続する等価な要素群のそれぞれについて、先頭以外の全ての要素を削除する。すなわち、空でない`hive`に対して、イテレータ範囲`[`[`begin()`](begin.md)` + 1,` [`end()`](end.md)`)`に含まれるイテレータ`i`のうち、`binary_pred(*i, *(i - 1))`が`true`となる要素を全て削除する。 + + +## 戻り値 +削除された要素数を返す。 + + +## 例外 +`binary_pred`が例外を送出する場合を除き、例外を送出しない。 + + +## 計算量 +[`empty()`](empty.md)が`false`である場合、述語をちょうど[`size()`](size.md)` - 1`回適用する。そうでなければ、述語を適用しない。 + + +## 備考 +削除された要素を指す参照・ポインタ・イテレータを無効化する。`*this`の末尾の要素が削除された場合、終端イテレータも無効化する。 + + +## 例 +```cpp example +#include +#include + +int main() +{ + std::hive h = {1, 1, 2, 2, 2, 3, 1}; + + // 連続する等価な要素群の先頭以外を削除する + std::hive::size_type n = h.unique(); + + std::println("erased = {}", n); + for (int x : h) { + std::print("{} ", x); + } + std::println(""); +} +``` +* unique[color ff0000] + +### 出力 +``` +erased = 3 +1 2 3 1 +``` + + +## バージョン +### 言語 +- C++26 + +### 処理系 +- [Clang](/implementation.md#clang): 22 [mark noimpl] +- [GCC](/implementation.md#gcc): 16.1 [mark noimpl] +- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl] + + +## 関連項目 +- [`hive::sort`](sort.md) +- [`hive::erase`](erase.md) + + +## 参照 +- [P0447R28 Introduction of `std::hive` to the standard library](https://open-std.org/jtc1/sc22/wg21/docs/papers/2024/p0447r28.html) + - C++26で`hive`が追加された diff --git a/reference/hive/hive_limits.md b/reference/hive/hive_limits.md new file mode 100644 index 0000000000..dbe2ae8d9f --- /dev/null +++ b/reference/hive/hive_limits.md @@ -0,0 +1,84 @@ +# hive_limits +* hive[meta header] +* std[meta namespace] +* class[meta id-type] +* cpp26[meta cpp] + +```cpp +namespace std { + struct hive_limits { + std::size_t min; + std::size_t max; + constexpr hive_limits(std::size_t minimum, std::size_t maximum) noexcept + : min(minimum), max(maximum) {} + }; +} +``` + +## 概要 +`hive_limits`は、[`hive`](hive.md)の要素ブロックが保持できる要素数の下限（`min`）と上限（`max`）を指定するためのクラスである。 + +[`std::hive`](hive.md)のコンストラクタや[`reshape()`](hive/reshape.md)メンバ関数に渡すことで要素ブロックの容量制限を指定でき、[`block_capacity_limits()`](hive/block_capacity_limits.md)や[`block_capacity_default_limits()`](hive/block_capacity_default_limits.md)、[`block_capacity_hard_limits()`](hive/block_capacity_hard_limits.md)の戻り値として得られる。 + +`min`は`max`以下でなければならず、両者は処理系が定めるハード制限（[`block_capacity_hard_limits()`](hive/block_capacity_hard_limits.md)）の範囲内でなければならない。範囲外の値や`min > max`となる値を指定した場合はエラー性動作（erroneous behavior）となり、その効果は処理系定義である。指定した値がハード制限の範囲内かどうかは[`is_within_hard_limits()`](hive/is_within_hard_limits.md)で確認できる。 + + +## メンバ変数 + +| 名前 | 説明 | 対応バージョン | +|-------|----------------------------------|----------------| +| `min` | 要素ブロックが保持できる要素数の下限 (`size_t`) | C++26 | +| `max` | 要素ブロックが保持できる要素数の上限 (`size_t`) | C++26 | + + +## メンバ関数 + +| 名前 | 説明 | 対応バージョン | +|-----------------|----------------|----------------| +| `(constructor)` | `min`を`minimum`で、`max`を`maximum`で初期化するコンストラクタ | C++26 | + + +## 例 +```cpp example +#include +#include + +int main() +{ + // 要素ブロックが保持できる要素数を、最小8・最大64に制限する + std::hive_limits limits{8, 64}; + + std::hive h{limits}; + + std::println("min={}, max={}", h.block_capacity_limits().min, + h.block_capacity_limits().max); +} +``` +* std::hive_limits[color ff0000] +* h.block_capacity_limits()[link hive/block_capacity_limits.md] + +### 出力例 +``` +min=8, max=64 +``` + + +## バージョン +### 言語 +- C++26 + +### 処理系 +- [Clang](/implementation.md#clang): 22 [mark noimpl] +- [GCC](/implementation.md#gcc): 16.1 [mark noimpl] +- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl] + + +## 関連項目 +- [`hive`](hive.md) +- [`hive::block_capacity_limits`](hive/block_capacity_limits.md) +- [`hive::reshape`](hive/reshape.md) + + +## 参照 +- [P0447R28 Introduction of `std::hive` to the standard library](https://open-std.org/jtc1/sc22/wg21/docs/papers/2024/p0447r28.html) + - C++26で`hive_limits`が追加された