cpprefjp - C++日本語リファレンス

is_enumerable_type -- is_enumerable_type : 列挙可能型になる条件を修正

2026-05-25T16:34:33+09:00

diff --git a/reference/meta/is_enumerable_type.md b/reference/meta/is_enumerable_type.md
index 9aca8d338..c1a09bc25 100644
--- a/reference/meta/is_enumerable_type.md
+++ b/reference/meta/is_enumerable_type.md
@@ -12,22 +12,38 @@ namespace std::meta {
 * info[link info.md]
 
 ## 概要
-型が列挙可能型であるかを判定する。列挙可能型とは、[`enumerators_of()`](enumerators_of.md)で列挙子を取得できる列挙型である。
+型が列挙可能型であるかを判定する。
+
+列挙可能型とは、次のいずれかを満たす型である：
+
+- クラス型であり、完全型である
+- 列挙型であり、その宣言に到達可能である（[`enumerators_of()`](enumerators_of.md)で列挙子を取得できる）
+    - ただし、その列挙型の宣言内では列挙可能型にならない
 
 
 ## 戻り値
-`r`が列挙可能な列挙型を表す場合に`true`を返す。
+`r`が列挙可能型を表す場合に`true`を返す。
 
 
 ## 例
 ```cpp example
 #include <meta>
 
-enum Color { red, green, blue };
+enum class Color;
+static_assert(!std::meta::is_enumerable_type(^^Color));
+enum class Color { red, green, blue };
+static_assert( std::meta::is_enumerable_type(^^Color));
 
-int main() {
-  static_assert(std::meta::is_enumerable_type(^^Color));
-}
+class S {};
+static_assert( std::meta::is_enumerable_type(^^S));  // 完全なクラス型も列挙可能型
+
+enum class E {
+  FALSE, TRUE,
+  A = std::meta::is_enumerable_type(^^E) ? TRUE : FALSE
+};
+static_assert(E::A == E::FALSE);  // 列挙型自身の宣言内では、列挙可能型にならない
+
+int main() {}
 ```
 
 ### 出力

機能テストマクロ -- filter_view : 未定義動作の条件を緩和するためのC++26の変更を記載 (close #1634)

2026-05-22T12:23:59+09:00

機能テストマクロ(C++26)

このページはC++26に採用された言語機能の変更を解説しています。

のちのC++規格でさらに変更される場合があるため関連項目を参照してください。

概要

言語機能

マクロ名	値	機能
`__cpp_constexpr`	`202406L`	定数式での`void*`からポインタ型へのキャストを許可 `constexpr`配置`new`
`__cpp_constexpr_exceptions`	`202411L`	定数評価での例外送出を許可
`__cpp_constexpr_virtual_inheritance`	`202506L`	`constexpr`仮想継承を許可
`__cpp_contracts`	`202502L`	契約プログラミングをサポートする
`__cpp_deleted_function`	`202403L`	関数宣言を削除する理由を指定できるようにする
`__cpp_expansion_statements`	`202506L`	コンパイル時のタプルやリストを展開処理する`template for`文
`__cpp_impl_reflection`	`202506L`	静的リフレクション
`__cpp_pack_indexing`	`202311L`	パラメータパックへのインデックスアクセスを許可
`__cpp_placeholder_variables`	`202306L`	宣言のみで使用しない変数の名前として`_`をサポート
`__cpp_pp_embed`	`202502L`	ファイルを読み込む`#embed`命令を追加
`__cpp_static_assert`	`202306L`	`static_assert`の診断メッセージにユーザーが生成した文字列の指定を許可
`__cpp_structured_bindings`	`202411L`	構造化束縛への属性を許可構造化束縛でパックを導入できるようにする
`__cpp_template_parameters`	`202502L`	コンセプトと変数テンプレートをテンプレート引数として渡せるようにする
`__cpp_trivial_relocatability`	`202502L`	トリビアルな再配置
`__cpp_trivial_union`	`202502L`	共用体の特殊メンバ関数のトリビアル化
`__cpp_variadic_friend`	`202403L`	可変引数テンプレートで`friend`宣言をできるようにする

ライブラリ

ライブラリの機能テストマクロは全て<version>でも提供される。

マクロ名	値	機能	ヘッダ
`__cpp_lib_algorithm_default_value_type`	`202603L`	一部アルゴリズムに、値を波カッコ初期化で渡せるよう制約を追加 (P3787R2で`uninitialized_fill`/`uninitialized_fill_n`を追加)	`<algorithm>`, `<ranges>`, `<string>`, `<deque>`, `<list>`, `<forward_list>`, `<vector>`, `<memory>`
`__cpp_lib_aligned_accessor`	`202411L`	`<mdspan>`に、要素アクセスにアライメント保証を与える`std::aligned_accessor`を追加	`<mdspan>`
`__cpp_lib_associative_heterogeneous_insertion`	`202306L`	連想コンテナの一部メンバ関数に、一時オブジェクト生成のコストを抑える拡張を追加	`<map>`, `<set>`, `<unordered_map>`, `<unordered_set>`
`__cpp_lib_apply`	`202506L`	`std::apply`の戻り値型推論をやめて、戻り値型用の`std::apply_result`クラスを追加	`<tuple>`, `<type_traits>`
`__cpp_lib_atomic_min_max`	`202506L`	`std::atomic`オブジェクトに対する2つの値の最大値・最小値を取得する関数を追加	`<atomic>`
`__cpp_lib_atomic_reductions`	`202506L`	`std::atomic`と`std::atomic_ref`に高速な縮約用の操作を追加	`<atomic>`
`__cpp_lib_atomic_ref`	`202411L`	`std::atomic_ref`に`address()`メンバ関数を追加	`<atomic>`
`__cpp_lib_bind_back`	`202306L`	`std::bind_back()`に、非型テンプレート引数として関数を指定するオーバーロードを追加	`<functional>`
`__cpp_lib_bind_front`	`202306L`	`std::bind_front()`に、非型テンプレート引数として関数を指定するオーバーロードを追加	`<functional>`
`__cpp_lib_bitset`	`202306L`	`std::bitset`に、`std::basic_string_view`を受け取るコンストラクタを追加	`<bitset>`
`__cpp_lib_chrono`	`202306L`	`<chrono>`のクラスに、ハッシュ値サポートとして`std::hash`の特殊化を追加	`<chrono>`
`__cpp_lib_constant_wrapper`	`202506L`	`<type_traits>`に`std::constant_wrapper`を追加	`<type_traits>`
`__cpp_lib_constexpr_algorithms`	`202306L`	`std::stable_sort()` / `std::ranges::stable_sort()`を`constexpr`対応	`<algorithm>`, `<utility>`
`__cpp_lib_constexpr_atomic`	`202411L`	`<atomic>`ライブラリのアトミック操作を`constexpr`対応	`<atomic>`
`__cpp_lib_constexpr_cmath`	`202306L`	`<cmath>`の関数 (特殊関数と丸めモードに依存する関数以外の全て) を`constexpr`対応	`<cmath>`, `<cstdlib>`
`__cpp_lib_constexpr_complex`	`202306L`	`std::complex`の全関数を`constexpr`対応	`<complex>`
`__cpp_lib_constexpr_deque`	`202502L`	`std::deque`を`constexpr`対応	`<deque>`
`__cpp_lib_constexpr_exceptions`	`202502L`	定数式での例外送出が許可されることにともない、例外クラスの関連機能を`constexpr`対応	`<exception>`, `<stdexcept>`, `<expected>`, `<optional>`, `<variant>`, `<format>`
`__cpp_lib_constexpr_flat_map`	`202502L`	`std::flat_map` / `std::flat_multimap`を`constexpr`対応	`<flat_map>`
`__cpp_lib_constexpr_flat_set`	`202502L`	`std::flat_set` / `std::flat_multiset`を`constexpr`対応	`<flat_set>`
`__cpp_lib_constexpr_forward_list`	`202502L`	`std::forward_list`を`constexpr`対応	`<forward_list>`
`__cpp_lib_constexpr_inplace_vector`	`202603L`	`std::inplace_vector`を`constexpr`対応	`<inplace_vector>`
`__cpp_lib_constexpr_list`	`202502L`	`std::list`を`constexpr`対応	`<list>`
`__cpp_lib_constexpr_map`	`202502L`	`std::map` / `std::multimap`を`constexpr`対応	`<map>`
`__cpp_lib_constexpr_memory`	`202506L`	`std::shared_ptr`クラスとその関連機能を`constexpr`対応	`<memory>`
`__cpp_lib_constexpr_new`	`202406L`	`constexpr`配置`new`	`<new>`
`__cpp_lib_constexpr_queue`	`202502L`	`std::queue` / `std::priority_queue`を`constexpr`対応	`<queue>`
`__cpp_lib_constexpr_set`	`202502L`	`std::set` / `std::multiset`を`constexpr`対応	`<set>`
`__cpp_lib_constexpr_stack`	`202502L`	`std::stack`を`constexpr`対応	`<stack>`
`__cpp_lib_constexpr_unordered_map`	`202502L`	`std::unordered_map` / `std::unordered_multimap`を`constexpr`対応	`<unordered_map>`
`__cpp_lib_constexpr_unordered_set`	`202502L`	`std::unordered_set` / `std::unordered_multiset`を`constexpr`対応	`<unordered_set>`
`__cpp_lib_constrained_equality`	`202411L`	`std::reference_wrapper`に、比較演算子`==`と`<=>`を追加	`<utility>`, `<tuple>`, `<optional>`, `<variant>`, `<expected>`
`__cpp_lib_contracts`	`202502L`	契約プログラミングをサポートする	`<contracts>`
`__cpp_lib_copyable_function`	`202306L`	`<functional>`に`std::copyable_function`を追加	`<functional>`
`__cpp_lib_counting_scope`	`202506L`	`<execution>`に`std::execution::spawn`、`std::execution::scope_token`などを追加	`<execution>`
`__cpp_lib_debugging`	`202403L`	デバッグサポートのライブラリとして`<debugging>`を追加	`<debugging>`
`__cpp_lib_define_static`	`202506L`		`<meta>`
`__cpp_lib_exception_ptr_cast`	`202603L`	`std::exception_ptr`を指定した例外型にキャストする`std::exception_ptr_cast()`関数を追加	`<exception>`
`__cpp_lib_format`	`202603L`	`std::dynamic_format`	`<format>`
`__cpp_lib_format_path`	`202506L`	`std::filesystem::path`クラスに、文字列フォーマットのサポートを追加 `std::filesystem::path`クラスに、出力用の文字列を取得するためのメンバ関数を追加	`<filesystem>`
`__cpp_lib_format_uchar`	`202311L`	`std::format`が`char`を数値出力する際は符号なしとして扱う	`<format>`
`__cpp_lib_freestanding_algorithm`	`202502L`		`<algorithm>`
`__cpp_lib_freestanding_array`	`202311L`		`<array>`
`__cpp_lib_freestanding_char_traits`	`202306L`		`<string>`
`__cpp_lib_freestanding_charconv`	`202306L`		`<charconv>`
`__cpp_lib_freestanding_cstdlib`	`202306L`		`<cstdlib>`, `<cmath>`
`__cpp_lib_freestanding_cstring`	`202311L`		`<cstring>`
`__cpp_lib_freestanding_cwchar`	`202306L`		`<cwchar>`
`__cpp_lib_freestanding_errc`	`202306L`		`<cerrno>`, `<system_error>`
`__cpp_lib_freestanding_execution`	`202502L`		`<execution>`
`__cpp_lib_freestanding_expected`	`202311L`		`<expected>`
`__cpp_lib_freestanding_feature_test_macros`	`202306L`
`__cpp_lib_freestanding_functional`	`202306L`		`<functional>`
`__cpp_lib_freestanding_iterator`	`202306L`		`<iterator>`
`__cpp_lib_freestanding_mdspan`	`202311L`		`<mdspan>`
`__cpp_lib_freestanding_memory`	`202502L`		`<memory>`
`__cpp_lib_freestanding_numeric`	`202502L`		`<numeric>`
`__cpp_lib_freestanding_operator_new`	`202306L` or `0`		`<new>`
`__cpp_lib_freestanding_optional`	`202506L`		`<optional>`
`__cpp_lib_freestanding_random`	`202502L`		`<random>`
`__cpp_lib_freestanding_ranges`	`202306L`		`<ranges>`
`__cpp_lib_freestanding_ratio`	`202306L`		`<ratio>`
`__cpp_lib_freestanding_string_view`	`202311L`		`<string_view>`
`__cpp_lib_freestanding_tuple`	`202306L`		`<tuple>`
`__cpp_lib_freestanding_utility`	`202306L`		`<utility>`
`__cpp_lib_freestanding_variant`	`202311L`		`<variant>`
`__cpp_lib_fstream_native_handle`	`202306L`	`std::basic_fstream`などのメンバに、ファイルのネイティブハンドルを追加	`<fstream>`
`__cpp_lib_function_ref`	`202306L`	`<functional>`に`std::function_ref`を追加	`<functional>`
`__cpp_lib_hazard_pointer`	`202306L`	ハザードポインタのライブラリ`<hazard_pointer>`を追加	`<hazard_pointer>`
`__cpp_lib_hive`	`202502L`	シーケンスコンテナのライブラリ`<hive>`を追加	`<hive>`
`__cpp_lib_indirect`	`202502L`	`<memory>`に`std::indirect`と`std::polymorphic`を追加	`<memory>`
`__cpp_lib_inplace_vector`	`202603L`	容量固定の可変長配列のライブラリ`<inplace_vector>`を追加	`<inplace_vector>`
`__cpp_lib_integer_sequence`	`202511L`	`std::integer_sequence`を構造化束縛と`template for`文で使用できるよう、タプルインタフェースの特殊化を追加	`<utility>`
`__cpp_lib_is_sufficiently_aligned`	`202411L`	`<mdspan>`に、要素アクセスにアライメント保証を与える`std::aligned_accessor`を追加	`<memory>`
`__cpp_lib_is_structural`	`202603L`	`<type_traits>`に`std::is_structural`を追加	`<type_traits>`, `<meta>`
`__cpp_lib_is_virtual_base_of`	`202406L`	`<type_traits>`に`std::is_virtual_base_of`を追加	`<type_traits>`
`__cpp_lib_is_within_lifetime`	`202306L`	`<type_traits>`に`std::is_within_lifetime()`を追加	`<type_traits>`
`__cpp_lib_linalg`	`202412L`	線形代数ライブラリとして`<linalg>`を追加	`<linalg>`
`__cpp_lib_mdspan`	`202406L`	`std::mdspan`に対する`std::dextents`指定の冗長さを解決する`std::dims`を追加	`<mdspan>`
`__cpp_lib_not_fn`	`202306L`	`std::not_fn()`に、非型テンプレート引数として関数を指定するオーバーロードを追加	`<functional>`
`__cpp_lib_observable_checkpoint`	`202506L`	`<utility>`に`std::observable_checkpoint()`を追加	`<utility>`
`__cpp_lib_optional`	`202506L`	`std::optional`に、参照を保持するための`T&`の部分特殊化を追加	`<optional>`
`__cpp_lib_optional_range_support`	`202406L`	`std::optional`にイテレータインタフェースを追加	`<optional>`
`__cpp_lib_out_ptr`	`202311L`		`<memory>`
`__cpp_lib_parallel_algorithm`	`202506L`	`<algorithm>`と`<memory>`のアルゴリズムを並列実行に対応	`<algorithm>`, `<numeric>`, `<memory>`
`__cpp_lib_parallel_scheduler`	`202506L`	`<execution>`に`std::execution::parallel_scheduler`を追加	`<execution>`
`__cpp_lib_philox_engine`	`202406L`	`<random>`に`std::philox_engine`、`std::philox4x32`、`std::philox4x64`を追加	`<random>`
`__cpp_lib_polymorphic`	`202502L`	`<memory>`に`std::indirect`と`std::polymorphic`を追加	`<memory>`
`__cpp_lib_print`	`202406L`	`std::print()`と`std::println()`にロックを取得せず高速に書き出す最適化を許可 `std::enable_nonlocking_formatter_optimization`を追加	`<print>`, `<ostream>`
`__cpp_lib_ranges`	`202406L`	`std::indirectly_unary_invocable`などのコンセプトの共通参照要件を削除	`<algorithm>`, `<functional>`, `<iterator>`, `<memory>`, `<ranges>`
`__cpp_lib_ranges_as_const`	`202311L`	`std::basic_const_iterator`を元の要素へのキャストを可能にする	`<ranges>`
`__cpp_lib_ranges_cache_latest`	`202411L`	`std::views::cache_latest`を追加	`<ranges>`
`__cpp_lib_ranges_concat`	`202403L`	`std::views::concat`を追加	`<ranges>`
`__cpp_lib_ranges_filter`	`202603L`	`std::ranges::filter_view`に、入力Rangeに対する`const`版の`begin()`/`end()`を追加	`<ranges>`
`__cpp_lib_ranges_generate_random`	`202403L`	`<random>`に、乱数列を生成する`std::ranges::generate_random()`関数を追加	`<random>`
`__cpp_lib_ranges_indices`	`202506L`	インデックス列を生成する`std::views::indices`を追加	`<ranges>`
`__cpp_lib_ranges_reserve_hint`	`202502L`	各viewクラスに`reserve_hint()`メンバ関数を追加 `std::ranges::reserve_hint()`関数を追加 `std::ranges::approximately_sized_range`コンセプトを追加	`<ranges>`
`__cpp_lib_ranges_as_input`	`202502L`	`std::views::as_input`を追加	`<ranges>`
`__cpp_lib_ratio`	`202306L`	`<ratio>`に、新たなSI接頭辞を追加	`<ratio>`
`__cpp_lib_raw_memory_algorithms`	`202411L`	`std::uninitialized_default_construct()`などの未初期化領域に対する操作を`constexpr`対応	`<memory>`
`__cpp_lib_rcu`	`202306L`	RCU (Read Copy Update) のライブラリとして`<rcu>`を追加	`<rcu>`
`__cpp_lib_reference_wrapper`	`202403L`	`std::reference_wrapper`に、比較演算子`==`と`<=>`を追加	`<functional>`
`__cpp_lib_reflection`	`202506L`	静的リフレクションのライブラリ機能	`<meta>`
`__cpp_lib_saturation_arithmetic`	`202603L`	`<numeric>`に飽和演算 (Saturation Arithmetic) として`std::saturating_add()`などの関数を追加	`<numeric>`
`__cpp_lib_senders`	`202506L`		`<execution>`
`__cpp_lib_simd`	`202506L`	データ並列ライブラリとして、`<simd>`を追加	`<simd>`
`__cpp_lib_simd_complex`	`202502L`	`<simd>`が`std::complex`をサポートする	`<simd>`
`__cpp_lib_simd_permutations`	`202506L`	`<simd>`に`permute()`などを追加する	`<simd>`
`__cpp_lib_smart_ptr_owner_equality`	`202306L`	`<memory>`に`std::owner_hash`と`std::owner_equal`を追加	`<memory>`
`__cpp_lib_span`	`202311L`	`std::mdspan`に`at()`メンバ関数を追加	`<span>`
`__cpp_lib_span_initializer_list`	`202311L`	`std::span`に`std::initializer_list`をとるコンストラクタを追加	`<span>`
`__cpp_lib_sstream_from_string_view`	`202306L`	`std::basic_stringstream`などが`std::basic_string_view`から構築可能に	`<sstream>`
`__cpp_lib_string_subview`	`202506L`	`std::basic_string`と`std::basic_string_view`に`subview()`を追加	`<string>`, `<string_view>`
`__cpp_lib_string_view`	`202403L`	`std::basic_string`と`std::basic_string_view`を連結させる`operator+`を追加	`<string>`, `<string_view>`
`__cpp_lib_submdspan`	`202411L`	`std::mdspan`から部分ビューを取り出す`std::submdspan()`を追加	`<mdspan>`
`__cpp_lib_task`	`202506L`		`<execution>`
`__cpp_lib_text_encoding`	`202306L`	文字列エンコーディングを識別するライブラリ`<text_encoding>`を追加	`<text_encoding>`
`__cpp_lib_to_chars`	`202306L`	`std::to_chars_result`と`std::from_chars_result`に`operator bool`を追加	`<charconv>`
`__cpp_lib_to_string`	`202306L`	`std::to_string`の変換結果を`sprintf()`ベースから`std::format()`ベースに変更	`<string>`
`__cpp_lib_trivially_relocatable`	`202502L`	トリビアルな再配置	`<memory>`, `<type_traits>`
`__cpp_lib_tuple_like`	`202311L`	`std::complex`にタプルインタフェースの特殊化を追加	`<utility>`, `<tuple>`, `<map>`, `<unordered_map>`
`__cpp_lib_type_order`	`202506L`	`std::type_order`を追加	`<compare>`
`__cpp_lib_variant`	`202306L`	`std::variant`クラスに、メンバ関数版の`visit()`を追加	`<variant>`

実装依存のマクロ。

マクロ名	値	ヘッダ
`__cpp_lib_hardened_array`	`202502L`	`<array>`
`__cpp_lib_hardened_basic_stacktrace`	`202506L`	`<stacktrace>`
`__cpp_lib_hardened_basic_string`	`202502L`	`<string>`
`__cpp_lib_hardened_basic_string_view`	`202502L`	`<string_view>`
`__cpp_lib_hardened_bitset`	`202502L`	`<bitset>`
`__cpp_lib_hardened_common_iterator`	`202506L`	`<iterator>`
`__cpp_lib_hardened_counted_iterator`	`202506L`	`<iterator>`
`__cpp_lib_hardened_deque`	`202502L`	`<deque>`
`__cpp_lib_hardened_expected`	`202502L`	`<expected>`
`__cpp_lib_hardened_forward_list`	`202502L`	`<forward_list>`
`__cpp_lib_hardened_inplace_vector`	`202502L`	`<inplace_vector>`
`__cpp_lib_hardened_list`	`202502L`	`<list>`
`__cpp_lib_hardened_mdspan`	`202502L`	`<mdspan>`
`__cpp_lib_hardened_optional`	`202502L`	`<optional>`
`__cpp_lib_hardened_shared_ptr_array`	`202506L`	`<memory>`
`__cpp_lib_hardened_span`	`202502L`	`<span>`
`__cpp_lib_hardened_valarray`	`202502L`	`<valarray>`
`__cpp_lib_hardened_vector`	`202502L`	`<vector>`
`__cpp_lib_hardened_view_interface`	`202506L`	`<ranges>`

参照

SD-FeatureTest: Feature-Test Macros and Policies - isocpp

filter_view -- filter_view : 未定義動作の条件を緩和するためのC++26の変更を記載 (close #1634)

2026-05-22T12:23:59+09:00

diff --git a/reference/ranges/filter_view.md b/reference/ranges/filter_view.md
index 520a81288..2bf9b5be1 100644
--- a/reference/ranges/filter_view.md
+++ b/reference/ranges/filter_view.md
@@ -26,7 +26,10 @@ namespace std::ranges {
     - 探索は [`ranges::find_if`](/reference/algorithm/ranges_find_if.md) と同様に行われる。
 - [`begin`](filter_view/begin.md)は償却定数時間で実行できなければならないため、[`begin`](filter_view/begin.md)の値はキャッシュされる。
 
-`filter_view`の要素を書き換えてもよいが、書き換えた後の要素が`Pred`を満たさない場合は未定義動作を引き起こす。
+`filter_view`の要素を書き換えてもよいが、書き換えた結果`Pred`を満たさない場合は未定義動作を引き起こす可能性がある。具体的な条件は言語バージョンによって異なる：
+
+- C++20 : 書き換えた後の要素が`Pred`を満たさない場合は未定義動作
+- C++26 : 元のRangeが[`forward_range`](forward_range.md)であり、書き換えた後の要素が次に`Pred`の評価を受けた際に `Pred`を満たさない場合に限り未定義動作 (要素が再評価されない限り問題なし、と緩和された)
 
 ### Rangeコンセプト
 
@@ -133,3 +136,5 @@ int main() {
 - [N4861 24.7.4 Filter view](https://timsong-cpp.github.io/cppwp/n4861/range.filter)
 - [C++20 ranges](https://techbookfest.org/product/5134506308665344)
 - [P2367R0 Remove misuses of list-initialization from Clause 24](https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2021/p2367r0.html) (本提案文書はC++20に遡って適用されている)
+- [P3725R3 Filter View Extensions for Safer Use](https://open-std.org/jtc1/sc22/wg21/docs/papers/2026/p3725r3.pdf)
+    - C++26で、入力Range (非forward) に対する`const`版の[`begin()`](filter_view/begin.md)と[`end()`](filter_view/end.md)を追加。また、要素書き換えによる未定義動作の文言を緩和

begin -- filter_view : 未定義動作の条件を緩和するためのC++26の変更を記載 (close #1634)

2026-05-22T12:23:59+09:00

diff --git a/reference/ranges/filter_view/begin.md b/reference/ranges/filter_view/begin.md
index d898a7d49..45d7b339d 100644
--- a/reference/ranges/filter_view/begin.md
+++ b/reference/ranges/filter_view/begin.md
@@ -6,23 +6,39 @@
 * cpp20[meta cpp]
 
 ```cpp
-constexpr iterator begin();
+constexpr iterator begin();                     // (1) C++20
+constexpr iterator<false> begin();              // (1) C++26
+
+constexpr iterator<true> begin() const
+  requires (input_range<const V> && !forward_range<const V> &&
+            indirect_unary_predicate<const Pred, iterator_t<const V>>); // (2) C++26
 ```
 * iterator[link iterator.md]
+* input_range[link /reference/ranges/input_range.md]
+* forward_range[link /reference/ranges/forward_range.md]
+* indirect_unary_predicate[link /reference/iterator/indirect_unary_predicate.md]
 
 ## 概要
 
 `view`の先頭要素を指すイテレータを取得する。
 
+- (1) : 非`const`版
+- (2) : `const`版。元のRangeが[`input_range`](/reference/ranges/input_range.md)であり、かつ[`forward_range`](/reference/ranges/forward_range.md)ではない場合に限り提供される
+
+
 ## 事前条件
 
 `pred_.`[`has_value`](/reference/optional/optional/has_value.md)`()`が`true`であること。
 
+
 ## 戻り値
 
 `{*this,` [`ranges::find_if`](/reference/algorithm/ranges_find_if.md)`(base_,` [`ref`](/reference/functional/ref.md)`(*pred_))}`
 
-[`range`](../range.md)のモデルとなるためにはこの関数が償却定数時間で実行できなければならないため、値はキャッシュされる。
+
+## 備考
+- (1) : [`range`](../range.md)のモデルとなるためにはこの関数が償却定数時間で実行できなければならないため、値はキャッシュされる
+- (2) : この関数は値をキャッシュしない
 
 ## 例
 
@@ -63,3 +79,5 @@ int main() {
 ## 参照
 - [N4861 24.7.4 Filter view](https://timsong-cpp.github.io/cppwp/n4861/range.filter)
 - [N4950 26.7.8 Filter view](https://timsong-cpp.github.io/cppwp/n4950/range.filter)
+- [P3725R3 Filter View Extensions for Safer Use](https://open-std.org/jtc1/sc22/wg21/docs/papers/2026/p3725r3.pdf)
+    - C++26で、(2)の`const`版オーバーロードを追加 (入力Rangeの場合の`const`イテレーションをサポート)

end -- filter_view : 未定義動作の条件を緩和するためのC++26の変更を記載 (close #1634)

2026-05-22T12:23:59+09:00

diff --git a/reference/ranges/filter_view/end.md b/reference/ranges/filter_view/end.md
index dc564514e..0f78fc43a 100644
--- a/reference/ranges/filter_view/end.md
+++ b/reference/ranges/filter_view/end.md
@@ -6,20 +6,37 @@
 * cpp20[meta cpp]
 
 ```cpp
-constexpr auto end() {
+constexpr auto end() {                            // (1) C++20
   if constexpr (common_range<V>)
     return iterator{*this, ranges::end(base_)};
   else
     return sentinel{*this};
 }
+
+constexpr auto end() {                            // (1) C++26
+  if constexpr (common_range<V>)
+    return iterator<false>{*this, ranges::end(base_)};
+  else
+    return sentinel<false>{*this};
+}
+
+constexpr sentinel<true> end() const
+  requires (input_range<const V> && !forward_range<const V> &&
+            indirect_unary_predicate<const Pred, iterator_t<const V>>); // (2) C++26
 ```
 * iterator[link iterator.md]
 * sentinel[link sentinel.md]
+* input_range[link /reference/ranges/input_range.md]
+* forward_range[link /reference/ranges/forward_range.md]
+* indirect_unary_predicate[link /reference/iterator/indirect_unary_predicate.md]
 
 ## 概要
 
 番兵を取得する。
 
+- (1) : 非`const`版
+- (2) : `const`版。元のRangeが[`input_range`](/reference/ranges/input_range.md)であり、かつ[`forward_range`](/reference/ranges/forward_range.md)ではない場合に限り提供される
+
 ## 例
 
 ```cpp example
@@ -61,3 +78,5 @@ int main() {
 ## 参照
 - [N4861 24.7.4 Filter view](https://timsong-cpp.github.io/cppwp/n4861/range.filter)
 - [N4950 26.7.8 Filter view](https://timsong-cpp.github.io/cppwp/n4950/range.filter)
+- [P3725R3 Filter View Extensions for Safer Use](https://open-std.org/jtc1/sc22/wg21/docs/papers/2026/p3725r3.pdf)
+    - C++26で、(2)の`const`版オーバーロードを追加 (入力Rangeの場合の`const`イテレーションをサポート)

as_const_view -- ranges : C++26でのoptional関係の最適化を導入 (close #1577)

2026-05-22T11:42:20+09:00

diff --git a/reference/ranges/as_const_view.md b/reference/ranges/as_const_view.md
index 62e7e393d..948c2386d 100644
--- a/reference/ranges/as_const_view.md
+++ b/reference/ranges/as_const_view.md
@@ -33,6 +33,7 @@ namespace std::ranges {
 - (2): 式`views::as_const(E)`の効果は次のいずれか（`T = decltype((E))`、`U = remove_cvref_t<T>`とする）
     - `views::all_t<T>`が`constant_range`のモデルとなる場合 : `views::all(E)`
     - 任意の型`X`に対して、`U`が`empty_view<X>`である場合 : `auto(views::empty<const X>)`
+    - C++26 : 任意の型`X`に対して、`U`が[`optional`](/reference/optional/optional.md)`<X&>`である場合 : [`optional`](/reference/optional/optional.md)`<const X&>(E)`
     - 任意の型`X`と整数値`Extent`に対して、`U`が`span<X, Extent>`である場合 : `span<const X, Extent>(E)`
     - 任意の型`X`に対して、`U`が`ref_view<X>`であり、`const X`が`constant_range`のモデルとなる場合 : `ref_view(static_cast<const X&>(E.base()))`
     - `E`が左辺値であり、`const U`が`constant_range`のモデルとなり、かつ`U`は`view`のモデルとならない場合 : `ref_view(static_cast<const U&>(E))`
@@ -103,3 +104,5 @@ int main() {
 ## 参照
 
 - [P2278R4 `cbegin` should always return a constant iterator](https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2022/p2278r4.html)
+- [P3913R1 Optimize for `std::optional` in range adaptors](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3913r1.pdf)
+    - C++26で、入力が[`optional`](/reference/optional/optional.md)`<X&>`の場合の特殊化を追加

drop_view -- ranges : C++26でのoptional関係の最適化を導入 (close #1577)

2026-05-22T11:42:20+09:00

diff --git a/reference/ranges/drop_view.md b/reference/ranges/drop_view.md
index e9f76b6b4..23707ac63 100644
--- a/reference/ranges/drop_view.md
+++ b/reference/ranges/drop_view.md
@@ -38,6 +38,7 @@ namespace std::ranges {
 - (2): `E`および`F`を式、型`T`を[`remove_cvref_t`](/reference/type_traits/remove_cvref.md)`<`[`decltype`](/lang/cpp11/decltype.md)`((E))>`、型`D`を[`range_difference_t`](range_difference_t.md)`<`[`decltype`](/lang/cpp11/decltype.md)`((E))>`とする。式`views::drop(E, F)`の効果は以下の通り
     - [`decltype`](/lang/cpp11/decltype.md)`((F))`が[`convertible_to`](/reference/concepts/convertible_to.md)`<D>`のモデルでなければ、呼び出しは不適格
     - `T`が[`ranges::empty_view`](empty_view.md)の特殊化であれば、`((void) F,` [`decay-copy`](/reference/exposition-only/decay-copy.md)`(E))`と等しい。ただし、`E`と`F`の評価順序は不定順で序列化(indeterminately sequenced)される
+    - C++26 : `T`が[`std::optional`](/reference/optional/optional.md)の特殊化で[`view`](view.md)のモデルであれば、`F`が0と等しいとき[`decay-copy`](/reference/exposition-only/decay-copy.md)`(E)`、そうでないとき空の`T()`と等しい
     - `T`が[`random_access_range`](random_access_range.md)および[`sized_range`](sized_range.md)のモデルであり、かつ次のいずれかの特殊化であるとき、`T(`[`ranges::begin`](begin.md)`(E) +` [`min`](/reference/algorithm/min.md)`<D>(`[`ranges::size`](size.md)`(E), F),` [`ranges::end`](end.md)`(E))`と等しい。ただし、`E`は1度だけ評価される
         - [`span`](/reference/span/span.md) (ただし、`T::extent ==` [`dynamic_extent`](/reference/span/dynamic_extent.md)であること)
         - [`basic_string_view`](/reference/string_view/basic_string_view.md)
@@ -116,3 +117,5 @@ int main() {
 - [P2367R0 Remove misuses of list-initialization from Clause 24](https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2021/p2367r0.html) (本提案文書はC++20に遡って適用されている)
 - [P2393R1 Cleaning up integer-class types](https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2021/p2393r1.html)
 - [P2017R1 Conditionally borrowed ranges](https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2020/p2017r1.html)
+- [P3913R1 Optimize for `std::optional` in range adaptors](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3913r1.pdf)
+    - C++26で、入力が[`std::optional`](/reference/optional/optional.md)の場合の特殊化を追加

reverse_view -- ranges : C++26でのoptional関係の最適化を導入 (close #1577)

2026-05-22T11:42:20+09:00

diff --git a/reference/ranges/reverse_view.md b/reference/ranges/reverse_view.md
index 761b00149..63e8d9e9d 100644
--- a/reference/ranges/reverse_view.md
+++ b/reference/ranges/reverse_view.md
@@ -37,6 +37,7 @@ namespace std::ranges {
 
 - (2): 式`views::reverse(E)`の効果は次の通り
     - `E`の型が`reverse_view`の特殊化であれば、`E.base()`と等しい (CV修飾されている場合を含む)
+    - C++26 : `E`の型が[`std::optional`](/reference/optional/optional.md)の特殊化で[`view`](view.md)のモデルであれば、[`decay-copy`](/reference/exposition-only/decay-copy.md)`(E)`と等しい (要素数が0または1のため反転の必要がない)
     - イテレータ型`I`、[`subrange_kind`](subrange_kind.md)の値`K`に対し、`E`の型がCV修飾された[`subrange`](subrange.md)`<`[`reverse_iterator`](/reference/iterator/reverse_iterator.md)`<I>,` [`reverse_iterator`](/reference/iterator/reverse_iterator.md)`<I>, K>`であるとする。このとき、`E`は一度しか評価されないとして、
         - `K`が[`subrange_kind::sized`](subrange_kind.md)であれば、[`subrange`](subrange.md)`<I, I, K>(E.end().base(), E.begin().base(), E.size())`と等しい
         - それ以外のとき、[`subrange`](subrange.md)`<I, I, K>(E.end().base(), E.begin().base())`と等しい
@@ -172,3 +173,5 @@ namespace std::ranges {
 - [N4861 24 Ranges library](https://timsong-cpp.github.io/cppwp/n4861/ranges)
 - [C++20 ranges](https://techbookfest.org/product/5134506308665344)
 - [P2017R1 Conditionally borrowed ranges](https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2020/p2017r1.html)
+- [P3913R1 Optimize for `std::optional` in range adaptors](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3913r1.pdf)
+    - C++26で、入力が[`std::optional`](/reference/optional/optional.md)の場合の特殊化を追加

take_view -- ranges : C++26でのoptional関係の最適化を導入 (close #1577)

2026-05-22T11:42:20+09:00

diff --git a/reference/ranges/take_view.md b/reference/ranges/take_view.md
index 53ecc23ad..8ee03e989 100644
--- a/reference/ranges/take_view.md
+++ b/reference/ranges/take_view.md
@@ -38,6 +38,7 @@ namespace std::ranges {
 - (2): `E`および`F`を式、型`T`を[`remove_cvref_t`](/reference/type_traits/remove_cvref.md)`<`[`decltype`](/lang/cpp11/decltype.md)`((E))>`、型`D`を[`range_difference_t`](range_difference_t.md)`<`[`decltype`](/lang/cpp11/decltype.md)`((E))>`とする。式`views::take(E, F)`の効果は以下の通り
     - [`decltype`](/lang/cpp11/decltype.md)`((F))`が[`convertible_to`](/reference/concepts/convertible_to.md)`<D>`のモデルでなければ、呼び出しは不適格
     - `T`が[`ranges::empty_view`](empty_view.md)の特殊化であれば、`((void) F,` [`decay-copy`](/reference/exposition-only/decay-copy.md)`(E))`と等しい。ただし、`E`と`F`の評価順序は不定順で序列化(indeterminately sequenced)される
+    - C++26 : `T`が[`std::optional`](/reference/optional/optional.md)の特殊化で[`view`](view.md)のモデルであれば、`F`が0と等しいとき空の`T()`、そうでないとき[`decay-copy`](/reference/exposition-only/decay-copy.md)`(E)`と等しい
     - `T`が[`random_access_range`](random_access_range.md)および[`sized_range`](sized_range.md)のモデルであり、かつ次のいずれかの特殊化であるとき、`T(`[`ranges::begin`](begin.md)`(E),` [`ranges::begin`](begin.md)`(E) +` [`min`](/reference/algorithm/min.md)`<D>(`[`ranges::size`](size.md)`(E), F))`と等しい。ただし、`E`は1度だけ評価される
         - [`span`](/reference/span/span.md) (ただし、`T::extent ==` [`dynamic_extent`](/reference/span/dynamic_extent.md)であること)
         - [`basic_string_view`](/reference/string_view/basic_string_view.md)
@@ -181,3 +182,5 @@ int main() {
 - [P2393R1 Cleaning up integer-class types](https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2021/p2393r1.html)
 - [P2406R2 Add `lazy_counted_iterator`](https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2023/p2406r2.html)
 - [P2017R1 Conditionally borrowed ranges](https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2020/p2017r1.html)
+- [P3913R1 Optimize for `std::optional` in range adaptors](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3913r1.pdf)
+    - C++26で、入力が[`std::optional`](/reference/optional/optional.md)の場合の特殊化を追加

コンストラクタ -- ranges : iterator/sentinelのユーザー定義コンストラクタをprivateに移動 (close #1633)

2026-05-21T16:00:02+09:00

diff --git a/reference/ranges/filter_view/iterator/op_constructor.md b/reference/ranges/filter_view/iterator/op_constructor.md
index 384af180f..06911a4f2 100644
--- a/reference/ranges/filter_view/iterator/op_constructor.md
+++ b/reference/ranges/filter_view/iterator/op_constructor.md
@@ -6,15 +6,21 @@
 * cpp20[meta cpp]
 
 ```cpp
-iterator() requires default_initializable<iterator_t<V>> = default;    // (1)
+public:
+  iterator() requires default_initializable<iterator_t<V>> = default;  // (1)
 
-constexpr iterator(filter_view& parent, iterator_t<V> current);        // (2)
+private:
+  constexpr iterator(filter_view& parent, iterator_t<V> current);      // (2) 説明専用
 ```
 
 ## 概要
 
 [`filter_view::iterator`](../iterator.md)オブジェクトを構築する。
 
+- (1) : デフォルトコンストラクタ
+- (2) : `private`な説明専用コンストラクタ。[`filter_view`](../../filter_view.md)の[`begin()`](../begin.md)から呼び出される
+
+
 ## 効果
 
 - (1) : `current_`、`parent_`をデフォルト構築する
@@ -27,14 +33,12 @@ constexpr iterator(filter_view& parent, iterator_t<V> current);        // (2)
 #include <iostream>
 
 int main() {
-  using std::ranges::filter_view;
-  using std::ranges::iterator_t;
-
   std::vector<int> vec = {0, 1, 2, 3, 4, 5};
 
-  filter_view fv{vec, [](int x){ return x % 2 == 0; }};
+  std::ranges::filter_view fv{vec, [](int x){ return x % 2 == 0; }};
 
-  iterator_t<decltype(fv)> i(fv, vec.begin());
+  // begin()を経由してイテレータを取得する
+  auto i = fv.begin();
 
   std::cout << *i << '\n';
   i++;
@@ -43,7 +47,7 @@ int main() {
   std::cout << *i << '\n';
 }
 ```
-* iterator_t<decltype(fv)>[color ff0000]
+* fv.begin()[link ../begin.md]
 
 ### 出力
 ```
@@ -65,3 +69,5 @@ int main() {
 ## 参照
 - [N4861 24.7.4 Filter view](https://timsong-cpp.github.io/cppwp/n4861/range.filter)
 - [N4950 26.7.8 Filter view](https://timsong-cpp.github.io/cppwp/n4950/range.filter)
+- [P3059R2 Making user-defined constructors of view iterators/sentinels private](https://open-std.org/jtc1/sc22/wg21/docs/papers/2026/p3059r2.html)
+    - C++26で、(2)のユーザー定義コンストラクタを`public`から`private`に移動

コンストラクタ -- ranges : iterator/sentinelのユーザー定義コンストラクタをprivateに移動 (close #1633)

2026-05-21T16:00:02+09:00

diff --git a/reference/ranges/filter_view/sentinel/op_constructor.md b/reference/ranges/filter_view/sentinel/op_constructor.md
index c320f1d1d..9f99a167a 100644
--- a/reference/ranges/filter_view/sentinel/op_constructor.md
+++ b/reference/ranges/filter_view/sentinel/op_constructor.md
@@ -6,14 +6,21 @@
 * cpp20[meta cpp]
 
 ```cpp
-sentinel() = default;                             // (1)
-constexpr explicit sentinel(filter_view& parent); // (2)
+public:
+  sentinel() = default;                             // (1)
+
+private:
+  constexpr explicit sentinel(filter_view& parent); // (2) 説明専用
 ```
 
 ## 概要
 
 [`filter_view::sentinel`](../sentinel.md)オブジェクトを構築する。
 
+- (1) : デフォルトコンストラクタ
+- (2) : `private`な説明専用コンストラクタ。[`filter_view`](../../filter_view.md)の[`end()`](../end.md)から呼び出される
+
+
 ## 効果
 
 - (1) : `end_`をデフォルト構築する
@@ -35,3 +42,5 @@ constexpr explicit sentinel(filter_view& parent); // (2)
 ## 参照
 - [N4861 24.7.4 Filter view](https://timsong-cpp.github.io/cppwp/n4861/range.filter)
 - [N4950 26.7.8 Filter view](https://timsong-cpp.github.io/cppwp/n4950/range.filter)
+- [P3059R2 Making user-defined constructors of view iterators/sentinels private](https://open-std.org/jtc1/sc22/wg21/docs/papers/2026/p3059r2.html)
+    - C++26で、(2)のユーザー定義コンストラクタを`public`から`private`に移動

iterator -- ranges : iterator/sentinelのユーザー定義コンストラクタをprivateに移動 (close #1633)

2026-05-21T16:00:02+09:00

diff --git a/reference/ranges/iota_view/iterator.md b/reference/ranges/iota_view/iterator.md
index 1bbe963b8..62e1c60f5 100644
--- a/reference/ranges/iota_view/iterator.md
+++ b/reference/ranges/iota_view/iterator.md
@@ -60,6 +60,8 @@ namespace std::ranges {
   struct iota_view<W, Bound>::iterator {
   private:
     W value_ = W();
+    constexpr explicit iterator(W value) : value_(value) {
+    }
   public:
     using iterator_concept = decltype(get_iota_view_iterator_concept());
     using iterator_category = input_iterator_tag;
@@ -67,8 +69,6 @@ namespace std::ranges {
     using difference_type = iota_diff_t<W>;
 
     iterator() = default;
-    constexpr explicit iterator(W value) : value_(value) {
-    }
 
     constexpr W operator*() const noexcept(is_nothrow_copy_constructible_v<W>) {
       return value_;
@@ -205,3 +205,5 @@ namespace std::ranges {
 ## 参照
 - [N4861 24 Ranges library](https://timsong-cpp.github.io/cppwp/n4861/ranges)
 - [C++20 ranges](https://techbookfest.org/product/5134506308665344)
+- [P3059R2 Making user-defined constructors of view iterators/sentinels private](https://open-std.org/jtc1/sc22/wg21/docs/papers/2026/p3059r2.html)
+    - C++26で、ユーザー定義のコンストラクタを`public`から`private`に移動

sentinel -- ranges : iterator/sentinelのユーザー定義コンストラクタをprivateに移動 (close #1633)

2026-05-21T16:00:02+09:00

diff --git a/reference/ranges/iota_view/sentinel.md b/reference/ranges/iota_view/sentinel.md
index 888da36bb..4065d6d53 100644
--- a/reference/ranges/iota_view/sentinel.md
+++ b/reference/ranges/iota_view/sentinel.md
@@ -26,10 +26,10 @@ namespace std::ranges {
   struct iota_view<W, Bound>::sentinel {
   private:
     Bound bound_ = Bound();
-  public:
-    sentinel() = default;
     constexpr explicit sentinel(Bound bound): bound_{bound} {
     }
+  public:
+    sentinel() = default;
 
     friend constexpr bool operator==(const iterator& x, const sentinel& y) {
       return x.value_ == y.bound_;
@@ -65,3 +65,5 @@ namespace std::ranges {
 ## 参照
 - [N4861 24 Ranges library](https://timsong-cpp.github.io/cppwp/n4861/ranges)
 - [C++20 ranges](https://techbookfest.org/product/5134506308665344)
+- [P3059R2 Making user-defined constructors of view iterators/sentinels private](https://open-std.org/jtc1/sc22/wg21/docs/papers/2026/p3059r2.html)
+    - C++26で、ユーザー定義のコンストラクタを`public`から`private`に移動

C++26 -- C++26のreserve_hint関係に対応 (close #1427)

2026-05-21T15:03:06+09:00

C++26

概要

C++26とは、2026年中に改訂される予定の、C++バージョンの通称である。

このバージョンは、策定中のためC++2cと呼ばれることがある。「(2020年代の3つ目のバージョンが) 202c年にリリースされる」という伏せ字として「c」が使われているが、3年周期に次のバージョンが策定されることが決まっているため、伏せ字になっている年数がずれることはない。

言語機能

変数

言語機能	説明
`std::initializer_list`の配列を静的記憶域に配置する	`std::vector v = {1, 2, 3};`のような初期化で初期化子リストを静的記憶域に配置することで無駄なコピーをなくす
宣言のみで使用しない変数の名前として`_`をサポート	変数名`_`は暗黙で`[[maybe_unused]]`が指定される
不完全型へのポインタに対する`delete`を不適格とする	未定義動作を引き起こす操作をコンパイルエラーとする
返却された左辺値から暗黙変換された一時オブジェクトが参照に束縛されることを禁止する	寿命切れの変数によって引き起こされるバグを防止する
要素数不明の配列を集成体初期化する規則を明確化	配列要素の集成体初期化で`{}`が省略された場合の矛盾していた規定を修正
未初期化変数の読み取りをエラー性動作とする	初期化されていない自動変数の読み取りの安全性を規定する
構造化束縛でパックを導入できるようにする	タプルを分解する際に複数の変数をパックとして宣言できるようにする。`auto [a, ...xs] = f();`

文字列

言語機能	説明
文字列リテラルの文字エンコーディング失敗を不適格とする	文字列リテラルのエンコーディング時に文字表現が失われる場合にコンパイルエラーにする
コンパイル時にのみ使用される文字列の扱いを明確化	`static_assert`や`[[deprecated]]`などで使用されるコンパイル時の文字列について、文字コードの指定を禁止し、実行時エンコーディングが行われないことを規定

分岐・ループ

言語機能	説明
条件式での構造化束縛の使用を許可	式全体を`bool`値に変換できる場合に条件式で構造化束縛を使用できることとする
空の無限ループは未定義動作ではないと規定	並行プログラムの進行保証などを考慮して空の無限ループを未定義動作ではないものとする

関数

言語機能	説明
関数宣言を削除する理由を指定できるようにする	`f() = delete("reason");`
契約プログラミングをサポートする	関数の事前条件、事後条件、不変条件を記述できるようにする

クラス

言語機能	説明
共用体の特殊メンバ関数のトリビアル化	非トリビアルな型をメンバにもつ共用体のデフォルトコンストラクタとデストラクタをトリビアルにし、未初期化ストレージとして使用可能にする
共用体の寿命ルールの調整	`union`メンバの活性化や寿命に関する規則を整理して`constexpr`評価などの一貫性を改善する
配置newの解放処理を明確化	配置`new`で確保したメモリの解放処理の取り扱いに関するルールを明確化する

属性

言語機能	説明
属性の無視性を見直し	構文として適格な属性のみを無視できるようにし、そうでない属性の使用を不適格とする
構造化束縛への属性を許可	`auto [a, b [[maybe_unused]], c] = f();`のように構造化束縛の要素に対して属性を付加できるようにする

テンプレート

言語機能	説明
パラメータパックへのインデックスアクセスを許可	可変引数テンプレートのパラメータパックに添字アクセスできるようにする
制約式内での畳み込み式の順序付け	畳み込み式を含む制約の包摂関係を認識できるようにし、オーバーロード解決の曖昧さを解消する
可変引数テンプレートで`friend`宣言をできるようにする	クラステンプレートの可変引数テンプレートでまとめて`friend`宣言できるようにする
コンセプトと変数テンプレートをテンプレート引数として渡せるようにする	テンプレートテンプレートパラメータとして、クラステンプレートやエイリアステンプレートに加え、コンセプトと変数テンプレートも渡せるようにする
可変引数テンプレートの半順序を再検討する	可変引数テンプレートの部分特殊化の半順序ルールを再検討して、より一貫したルールにする
テンプレートテンプレートパラメータに対するクラステンプレートパラメータ引数推論	テンプレートテンプレートパラメータからクラステンプレート引数を推論できるようにクラステンプレートのテンプレート引数推論を拡張する
「immediate context」の定義を明確化	SFINAEにおける「immediate context」の用語を厳密に定義し、置換失敗の範囲を明確にする

定数式

言語機能	説明
静的リフレクション	リフレクション演算子`^^`と`std::meta::info`型によりコンパイル時にさまざまな情報を取得できる
コンパイル時のタプルやリストを展開処理する`template for`文	タプル・構造体・Range・パラメータパックなどの各要素に対してコンパイル時に文を展開する`template for`文を追加
定数式での`void*`からポインタ型へのキャストを許可	型消去のために`void*`からポインタ型へのキャストを許可する
`static_assert`の診断メッセージにユーザーが生成した文字列の指定を許可	`constexpr`な`S.size()`と`S.data()`メンバ関数をもつオブジェクトをコンパイル時文字列として指定できるようにする
`constexpr`配置`new`	定数式の文脈での配置`new`を許可
`constexpr`構造化束縛の許可と、`constexpr`参照の制限緩和	定数式に対する構造化束縛を許可し、関連して`constexpr`参照の制限を緩和して自動変数も参照できるようにする
定数評価での例外送出を許可	定数式の文脈での例外の送出と捕捉を許可
`constexpr`仮想継承を許可	定数式の文脈での仮想継承を許可
定数評価の開始・終了タイミングを明確化	定数評価がどのタイミングで開始・終了するかを明確化し、constexprコンテキストの規則を整える

プリプロセッサ

言語機能	説明
ファイルを読み込む`#embed`命令を追加	バイナリファイルをインクルードするメカニズム。`#include`とちがって読み出しサイズなどの柔軟な指定ができる
プリプロセッサ仕様での「未定義動作」を不適格 (診断不要) に変更	プリプロセッサとレキサーの文脈での「未定義動作」用語を不適格 (診断不要) に変更
`#line`ディレクティブの制約を現実の実装に合わせて緩和する	`#line 0`や`#line 2147483648`のような行番号指定を不適格としていたが、条件付きサポートとして許可する

ソースコード

言語機能	説明
基本文字集合に@、$、`を追加	C言語との互換性のためにこれらの文字を基本文字集合に追加

モジュール

言語機能	説明
モジュール宣言でのモジュール名のマクロ展開を禁止する	`export module MACRO_NAME;`を禁止
`main`関数をグローバルモジュールに含められるようにする	`main`関数に`extern "C++"`を指定できるようにすることで名前付きモジュールに含められるようにする
モジュール宣言より前での`#line`ディレクティブの使用を許可する	モジュール宣言より前での`#line`ディレクティブの使用を禁止していたのは過度な制限だった

機能の非推奨化

言語機能	説明
先行するカンマのない省略記号を非推奨化	`void f(int, ...);`はOK。`void f(int...);`は非推奨

機能の削除

言語機能	説明
非推奨だった組み込み配列の比較を削除	C++20で非推奨となっていた配列比較を削除
非推奨となっていた列挙型の算術変換を削除	C++20から非推奨となっていた列挙値への算術演算で算術型に暗黙変換される仕様を削除

ライブラリ更新の概要

新ライブラリ

文字列エンコーディングを識別するライブラリとして、<text_encoding>を追加
要素のメモリ位置が安定するシーケンスコンテナのライブラリとして<hive>を追加
並行処理におけるデータの参照・更新を行うRCU (Read Copy Update) のライブラリとして、<rcu>を追加
並行処理において参照中のデータが更新されないよう保護するハザードポインタのライブラリとして、<hazard_pointer>を追加
データ並列ライブラリとして、<simd>を追加
デバッグサポートのライブラリとして<debugging>を追加
線形代数ライブラリとして<linalg>を追加
コンパイル時に容量を固定する可変長配列クラスのライブラリとして<inplace_vector>を追加
C23の互換ライブラリとして、ビット操作ライブラリ<stdbit.h>と、検査付き整数演算ライブラリ<stdckdint.h>を追加。<cstd…>形式のライブラリは追加されない

全体

標準ライブラリに付加された、戻り値を無視した際に警告を出力する[[nodiscard]]属性を削除

コンテナ

std::vector<bool>::referenceのプロキシ操作として、const修飾付きの代入とswap()メンバ関数を追加
std::mdspanから部分ビューを取り出すstd::submdspan()を追加
std::mdspanに、インデックスを指定して要素を取り出すat()メンバ関数を追加
std::mdspanに対するstd::dextents指定の冗長さを解決するstd::dimsを追加
std::mdspanのレイアウトとして、std::layout_left_paddedとstd::layout_right_paddedを追加
<mdspan>に、要素アクセスにアライメント保証を与えるstd::aligned_accessorを追加
std::spanに、インデックスアクセスのためのat()メンバ関数を追加
連想コンテナの以下のメンバ関数に、一時オブジェクトが生成されるコストを抑える拡張を追加
- std::map
  - operator[]
  - at()
  - try_emplace()
  - insert_or_assign()
- std::set
  - insert()
- std::unordered_map
  - operator[]
  - at()
  - try_emplace()
  - insert_or_assign()
  - bucket()
- std::unordered_multimap
  - bucket()
- std::unordered_set
  - insert()
  - bucket()
- std::unordered_multiset
  - bucket()
std::spanとstd::mdspanの推論補助を改善
std::views::concatを追加
std::views::cache_latestを追加
std::views::as_inputを追加。これはパフォーマンス向上のために、Rangeを入力Rangeかつ非common_range (イテレータと番兵の型を別する) に変換する
Range関係の、償却定数時間での要素追加を行う機能を追加
- 各viewクラスにreserve_hint()メンバ関数を追加
- std::ranges::reserve_hint()関数を追加
- std::ranges::approximately_sized_rangeコンセプトを追加
インデックス列を生成するstd::views::indicesを追加
連続イテレータのコンセプトcontiguous_iteratorに、ポインタに変換できることを要件として追加
std::initializer_listクラスを以下のように変更
- 独自に定義されていたstd::begin() / std::end()のオーバーロードを削除 (std::cbegin()やstd::rend()のようなオーバーロードがなかったため、ほかとの不整合があった)
- メンバ関数data()を追加
- メンバ関数empty()を追加
std::valarrayクラスを以下のように変更
- 独自に定義されていたstd::begin() / std::end()のオーバーロードを削除 (std::cbegin()やstd::rend()のようなオーバーロードがなかったため、ほかとの不整合があった)
- メンバ型iterator / const_iteratorを追加
- メンバ関数begin() / end()を追加
イテレータインタフェースの非メンバ関数std::begin() / std::end() / std::cbegin() / std::cend() / std::rbegin() / std::rend() / std::crbegin() / std::crend() / std::size() / std::ssize() / std::empty() / std::data()を以下のように変更
- std::initializer_list型に対するオーバーロードを削除 (専用のオーバーロードを用意しなくても汎用オーバーロードが使用できるようになった)
- 条件付きnoexcept指定を追加
Rangeインタフェースの非メンバ関数std::ranges::begin() / std::ranges::end() / std::ranges::cbegin() / std::ranges::cend() / std::ranges::rbegin() / std::ranges::rend() / std::ranges::crbegin() / std::ranges::crend() / std::ranges::size() / std::ranges::ssize() / std::ranges::empty() / std::ranges::data()を以下のように変更
- std::initializer_list型に対するオーバーロードを削除 (専用のオーバーロードを用意しなくても汎用オーバーロードが使用できるようになった)
- 条件付きnoexcept指定を追加
以下のコンテナをconstexprに対応
- std::deque
- std::forward_list
- std::list
- std::map (ただしnode_handle::key()を使用すると未定義動作)
- std::multimap (ただしnode_handle::key()を使用すると未定義動作)
- std::set
- std::multiset
- std::unordered_map (ハッシュ関数のカスタム化が必要) (ただしnode_handle::key()を使用すると未定義動作)
- std::unordered_multimap (ハッシュ関数のカスタム化が必要) (ただしnode_handle::key()を使用すると未定義動作)
- std::unordered_set (ハッシュ関数のカスタム化が必要)
- std::unordered_multiset (ハッシュ関数のカスタム化が必要)
- std::flat_map
- std::flat_multimap
- std::flat_set
- std::flat_multiset
- std::queue
- std::priority_queue
- std::stack

アルゴリズム

<algorithm>と<memory>のアルゴリズムを並列実行に対応
<algorithm>の以下のアルゴリズムをconstexprに対応
<memory>の以下のアルゴリズムをconstexprに対応
Rangeアルゴリズムが完全型を要求しないようにするため、std::projectedの制約を緩和
以下のアルゴリズムに、値を波カッコ初期化で渡せるよう制約を追加
- std::erase()
  - std::basic_string版std::erase()
  - std::deque版std::erase()
  - std::forward_list版std::erase()
  - std::list版std::erase()
  - std::vector版std::erase()
- std::find()とstd::ranges::find()
- std::ranges::find_last()
- std::count()とstd::ranges::count()
- std::search_n()とstd::ranges::search_n()
- std::replace()とstd::ranges::replace()
- std::replace_if()とstd::ranges::replace_if()
- std::ranges::replace_copy()
- std::replace_copy_if()とstd::ranges::replace_copy_if()
- std::fill()とstd::ranges::fill()
- std::fill_n()とstd::ranges::fill_n()
- std::remove()とstd::ranges::remove()
- std::remove_copy()とstd::ranges::remove_copy()
- std::lower_bound()とstd::ranges::lower_bound()
- std::upper_bound()とstd::ranges::upper_bound()
- std::equal_range()とstd::ranges::equal_range()
- std::binary_search()とstd::ranges::binary_search()
- std::ranges::fold_left()
- std::ranges::fold_right()
- std::ranges::contains()
- std::uninitialized_fill()とstd::ranges::uninitialized_fill()
- std::uninitialized_fill_n()とstd::ranges::uninitialized_fill_n()

関数オブジェクト

所有権を保持しないstd::functionとして、<functional>にstd::function_refクラスを追加
std::move_only_functionのコピー可能版として、<functional>にstd::copyable_functionクラスを追加
std::bind_front()とstd::bind_back()に、非型テンプレート引数として関数を指定するオーバーロードを追加
- 関連して、非型テンプレート引数の関数オブジェクトを反転させられるよう、not_fn()に非型テンプレート引数版のオーバーロードを追加
std::reference_wrapperに、比較演算子==と<=>を追加

文字列

<charconv>の変換結果std::to_chars_resultとstd::from_chars_resultに、変換が正しく完了したかを判定するoperator boolを追加
std::to_string()の仕様がstd::sprintf()で説明されていたが、std::format()で定義するよう仕様を変更
std::basic_istringstreamおよびstd::basic_ostringstreamのコンストラクタおよびstr()メンバ関数に、std::basic_string_viewを受け取るオーバーロードを追加
std::format()に、以下の改善を導入
- ポインタ出力のサポートを追加
- 幅と精度を動的に指定した場合でも型の検証がコンパイル時に行われるよう仕様を見直し
- コンパイル時の書式文字列だけでなく、実行時の書式文字列を渡せるよう仕様修正
- 非ロケール版をconstexprに対応
std::to_string()とstd::to_wstring()の整数オーバーロードがconstexprに対応
std::basic_stringクラスとstd::basic_string_viewクラスに、部分文字列をstd::basic_string_viewとして取得するメンバ関数subview()を追加
std::basic_stringとstd::basic_string_viewをstd::basic_stringとして連結させるoperator+を追加

ファイル

ファイルのネイティブハンドルを取得できるよう、std::basic_filebuf、std::basic_ifstream、std::basic_ofstream、std::basic_fstreamクラスに、以下のメンバを追加
- native_handle_type型
- native_handle()
std::filesystem::pathクラスに、文字列フォーマットのサポートを追加
std::filesystem::pathクラスに、出力用の文字列を取得するための、以下のメンバ関数を追加

入出力

std::print()とstd::println()に、ロックを取得せず高速に書き出す最適化を許可
std::println()に、改行のみを出力するオーバーロードを追加
std::print()とstd::println()をより高速にできる最適化が可能か判定するstd::enable_nonlocking_formatter_optimizationを追加
std::basic_istream::ignore()メンバ関数に、区切り文字としてchar型をとるオーバーロードを追加

並行・並列・非同期処理

<execution>に汎用的な非同期実行を管理するフレームワークを追加
std::atomicオブジェクトに対する2つの値の最大値・最小値を取得する関数として、以下を追加
- メンバ関数
  - fetch_max()
  - fetch_min()
  - fetch_fmaximum() (浮動小数点数用)
  - fetch_fminimum() (浮動小数点数用)
  - fetch_fmaximum_num() (浮動小数点数用)
  - fetch_fminimum_num() (浮動小数点数用)
- 非メンバ関数として
std::atomicクラスとstd::atomic_refクラスに、現在の値を読み込まず (fetchせず) に加算などをする高速な縮約用の操作として、以下を追加
- メンバ関数
  - store_add()
  - store_sub()
  - store_and()
  - store_or()
  - store_xor()
  - store_max()
  - store_min()
  - store_fmaximum() (浮動小数点数用)
  - store_fminimum() (浮動小数点数用)
  - store_fmaximum_num() (浮動小数点数用)
  - store_fminimum_num() (浮動小数点数用)
- 非メンバ関数
std::atomic_refクラスに、参照するオブジェクトのアドレスを取得するaddress()メンバ関数を追加
std::atomicクラスのテンプレートパラメータとしてCV修飾された型を禁止
std::atomic_refクラスのテンプレートパラメータとして、CV修飾された型を受け取れるようにした (内部でCV修飾が外される)
<atomic>ライブラリのアトミック操作をconstexpr対応

スマートポインタ・メモリ関連

動的確保したオブジェクトに値の意味論をもたせてディープコピーさせるユーティリティクラスとして、<memory>にstd::indirectクラスとstd::polymorphicクラスを追加
std::weak_ptrを非順序連想コンテナのキーとして使用できるよう、<memory>に所有権ベースのハッシュ値を取得する関数オブジェクトstd::owner_hash、および所有権ベースの等値比較を行う関数オブジェクトstd::owner_equalを追加
- 関連して、std::shared_ptrクラスとstd::weak_ptrクラスのメンバ関数として、owner_hash()とowner_equal()を追加
std::shared_ptrクラスとその関連機能をconstexpr対応

日付・時間

<chrono>の以下のクラスに、ハッシュ値サポートとしてstd::hashの特殊化を追加

数値

<cmath>に、浮動小数点数の最大値・最小値を求める以下の関数を追加
- std::fmaximum() (-0.0と+0.0では+0.0を返し、NaNと数値ではNaNを返す)
- std::fmaximum_num() (-0.0と+0.0では+0.0を返し、NaNと数値では数値を返す)
- std::fminimum() (-0.0と+0.0では-0.0を返し、NaNと数値ではNaNを返す)
- std::fminimum_num() (-0.0と-0.0では+0.0を返し、NaNと数値では数値を返す)
<numeric>に、飽和演算 (Saturation Arithmetic) として、型の表現可能な範囲で演算を行う以下の関数を追加
std::complexを構造化束縛や、将来のパターンマッチで使用できるようタプルインタフェースの特殊化を追加
<random>の範囲[0, 1)の乱数を生成するstd::generate_canonical()を、望ましい統計的性質を保証するようアルゴリズムと制約を変更
<random>に、乱数列を生成するstd::ranges::generate_random()関数を追加
<random>に、乱数生成器は並列シミュレーションに効果的なカウンターベースのPhilox乱数生成器として、std::philox_engineクラス、およびその別名であるstd::philox4x32とstd::philox4x64を追加
<random>の乱数生成器にsigned charとunsigned charのサポートを追加
<cmath>の以下の関数を、constexprに対応 (特殊関数と、グローバルの丸めモードに依存する丸め関数以外の全て)
- std::cos()
- std::sin()
- std::tan()
- std::cosh()
- std::sinh()
- std::tanh()
- std::acos()
- std::asin()
- std::atan()
- std::atan2()
- std::acosh()
- std::asinh()
- std::atanh()
- std::exp()
- std::exp2()
- std::expm1()
- std::log()
- std::log10()
- std::log1p()
- std::log2()
- std::pow()
- std::sqrt()
- std::cbrt()
- std::hypot()
- std::erf()
- std::erfc()
- std::lgamma()
- std::tgamma()
<complex>の以下の関数を、constexprに対応 (すべて)
- std::abs()
- std::arg()
- std::proj()
- std::polar()
- std::cos()
- std::sin()
- std::tan()
- std::cosh()
- std::sinh()
- std::tanh()
- std::acos()
- std::asin()
- std::atan()
- std::acosh()
- std::asinh()
- std::atanh()
- std::exp()
- std::log()
- std::log10()
- std::pow()
- std::sqrt()
- std::norm() (算術型オーバーロード)
- std::conj() (算術型オーバーロード)
- std::imag() (算術型オーバーロード)
- std::real() (算術型オーバーロード)

ユーティリティ

std::variantクラスに、メンバ関数版のvisit()を追加
std::monostateを<variant>から<utility>に移動
std::optionalクラスに、0もしくは1要素のRangeとして扱えるようにするための拡張として、イテレータインタフェースを追加
- iterator型
- const_iterator型
- begin()メンバ関数
- end()メンバ関数
std::optionalに、参照を保持するためのT&の部分特殊化を追加
std::applyの戻り値型推論をやめて、戻り値型用のstd::apply_resultクラスを追加し、関連する以下の機能を追加
- std::is_applicable型特性
- std::is_nothrow_applicable型特性
std::ignoreをファーストクラス・オブジェクトとして型を詳細に定義
std::bitsetに、std::basic_string_viewを受け取るコンストラクタを追加
<ratio>に、新たなSI接頭辞として、以下を追加
- ronna (10²⁷)
- ronto (10⁻²⁷)
- quetta (10³⁰)
- quecto (10⁻³⁰)
定数式での例外送出が許可されることにともない、以下をconstexpr化
- <exception>ヘッダの以下の機能
  - std::exceptionクラスの全メンバ関数
  - std::bad_exceptionクラスのwhat()メンバ関数
  - std::rethrow_exception()関数
  - std::make_exception_ptr()関数
- <new>ヘッダの以下の機能
  - std::bad_allocクラスのwhat()メンバ関数
  - std::bad_array_new_lengthクラスのwhat()メンバ関数
- <typeinfo>ヘッダの以下の機能
  - std::bad_castクラスのwhat()メンバ関数
  - std::bad_typeidクラスのwhat()メンバ関数
- <stdexcept>ヘッダの以下の機能
  - std::domain_error
  - std::invalid_argument
  - std::length_error
  - std::logic_error
  - std::out_of_range
  - std::runtime_error
  - std::range_error
  - std::overflow_error
  - std::underflow_error
- <expected>ヘッダの以下の機能
  - std::bad_expected_access
- <optional>ヘッダの以下の機能
  - std::bad_optional_access
- <variant>ヘッダの以下の機能
  - std::bad_variant_access
- <format>ヘッダの以下の機能
  - std::format_error
<memory>に、ポインタのアライメントを判定するstd::is_sufficiently_aligned()関数を追加。
<utility>に、タイムトラベル最適化を抑止するための観測可能ポイントとしてstd::observable_checkpoint()を追加
std::exception_ptrを指定した例外型にキャストするstd::exception_ptr_cast()関数を追加
<compare>に、型の順序を取得するstd::type_orderクラスを追加

デバッグ

assertマクロの引数としてカンマを含む式を指定できるよう、可変引数化

型特性

<type_traits>に、共用体の指定されたメンバがアクティブかを定数式で判定するための関数としてstd::is_within_lifetime()を追加
<type_traits>に、仮想継承の関係を判定するstd::is_virtual_base_ofを追加
<type_traits>に、std::integral_constantクラスを置き換える定数ラッパーとしてstd::constant_wrapperクラスを追加
std::integer_sequenceクラスを構造化束縛とtemplate for文で使用できるようにするため、タプルインタフェースの特殊化を追加

制約

間接実行に関連する制約から、共通参照の要件を削除

機能の非推奨化

<type_traits>のstd::is_trivialを非推奨化
- これはstd::is_trivially_copyableとstd::is_trivially_default_constructibleの2つが合わさったものであるが、それらは異なる状況で必要になるものであった
std::memory_order::consumeと、それに関連してstd::kill_dependency()を非推奨化し、[[carries_dependency]]属性を削除
std::filesystem::pathクラスの以下のメンバ関数を非推奨化
- string()
- generic_string()

非推奨の取り消し

std::polymorphic_allocator::destroy()の非推奨を取り消し

機能の削除

C++98から非推奨となっていた<strstream>ライブラリを削除
C++17から非推奨となっていたUnicode変換ライブラリ<codecvt>と、std::wstring_convertクラス、std::wbuffer_convertクラスを削除
C++20から非推奨となっていた、std::basic_string::reserve()のパラメータなしのオーバーロードを削除
C++20から非推奨となっていたstd::shared_ptrに対する、以下の古いアトミック操作関数のオーバーロードを削除
C++23から非推奨となっていた、std::allocatorのメンバ型is_always_equalを削除

取り決め

C言語の参照をC17からC23に更新

機能テストマクロ -- C++26のreserve_hint関係に対応 (close #1427)

2026-05-21T15:03:06+09:00

機能テストマクロ(C++26)

このページはC++26に採用された言語機能の変更を解説しています。

のちのC++規格でさらに変更される場合があるため関連項目を参照してください。

概要

言語機能

マクロ名	値	機能
`__cpp_constexpr`	`202406L`	定数式での`void*`からポインタ型へのキャストを許可 `constexpr`配置`new`
`__cpp_constexpr_exceptions`	`202411L`	定数評価での例外送出を許可
`__cpp_constexpr_virtual_inheritance`	`202506L`	`constexpr`仮想継承を許可
`__cpp_contracts`	`202502L`	契約プログラミングをサポートする
`__cpp_deleted_function`	`202403L`	関数宣言を削除する理由を指定できるようにする
`__cpp_expansion_statements`	`202506L`	コンパイル時のタプルやリストを展開処理する`template for`文
`__cpp_impl_reflection`	`202506L`	静的リフレクション
`__cpp_pack_indexing`	`202311L`	パラメータパックへのインデックスアクセスを許可
`__cpp_placeholder_variables`	`202306L`	宣言のみで使用しない変数の名前として`_`をサポート
`__cpp_pp_embed`	`202502L`	ファイルを読み込む`#embed`命令を追加
`__cpp_static_assert`	`202306L`	`static_assert`の診断メッセージにユーザーが生成した文字列の指定を許可
`__cpp_structured_bindings`	`202411L`	構造化束縛への属性を許可構造化束縛でパックを導入できるようにする
`__cpp_template_parameters`	`202502L`	コンセプトと変数テンプレートをテンプレート引数として渡せるようにする
`__cpp_trivial_relocatability`	`202502L`	トリビアルな再配置
`__cpp_trivial_union`	`202502L`	共用体の特殊メンバ関数のトリビアル化
`__cpp_variadic_friend`	`202403L`	可変引数テンプレートで`friend`宣言をできるようにする

ライブラリ

ライブラリの機能テストマクロは全て<version>でも提供される。

マクロ名	値	機能	ヘッダ
`__cpp_lib_algorithm_default_value_type`	`202603L`	一部アルゴリズムに、値を波カッコ初期化で渡せるよう制約を追加 (P3787R2で`uninitialized_fill`/`uninitialized_fill_n`を追加)	`<algorithm>`, `<ranges>`, `<string>`, `<deque>`, `<list>`, `<forward_list>`, `<vector>`, `<memory>`
`__cpp_lib_aligned_accessor`	`202411L`	`<mdspan>`に、要素アクセスにアライメント保証を与える`std::aligned_accessor`を追加	`<mdspan>`
`__cpp_lib_associative_heterogeneous_insertion`	`202306L`	連想コンテナの一部メンバ関数に、一時オブジェクト生成のコストを抑える拡張を追加	`<map>`, `<set>`, `<unordered_map>`, `<unordered_set>`
`__cpp_lib_apply`	`202506L`	`std::apply`の戻り値型推論をやめて、戻り値型用の`std::apply_result`クラスを追加	`<tuple>`, `<type_traits>`
`__cpp_lib_atomic_min_max`	`202506L`	`std::atomic`オブジェクトに対する2つの値の最大値・最小値を取得する関数を追加	`<atomic>`
`__cpp_lib_atomic_reductions`	`202506L`	`std::atomic`と`std::atomic_ref`に高速な縮約用の操作を追加	`<atomic>`
`__cpp_lib_atomic_ref`	`202411L`	`std::atomic_ref`に`address()`メンバ関数を追加	`<atomic>`
`__cpp_lib_bind_back`	`202306L`	`std::bind_back()`に、非型テンプレート引数として関数を指定するオーバーロードを追加	`<functional>`
`__cpp_lib_bind_front`	`202306L`	`std::bind_front()`に、非型テンプレート引数として関数を指定するオーバーロードを追加	`<functional>`
`__cpp_lib_bitset`	`202306L`	`std::bitset`に、`std::basic_string_view`を受け取るコンストラクタを追加	`<bitset>`
`__cpp_lib_chrono`	`202306L`	`<chrono>`のクラスに、ハッシュ値サポートとして`std::hash`の特殊化を追加	`<chrono>`
`__cpp_lib_constant_wrapper`	`202506L`	`<type_traits>`に`std::constant_wrapper`を追加	`<type_traits>`
`__cpp_lib_constexpr_algorithms`	`202306L`	`std::stable_sort()` / `std::ranges::stable_sort()`を`constexpr`対応	`<algorithm>`, `<utility>`
`__cpp_lib_constexpr_atomic`	`202411L`	`<atomic>`ライブラリのアトミック操作を`constexpr`対応	`<atomic>`
`__cpp_lib_constexpr_cmath`	`202306L`	`<cmath>`の関数 (特殊関数と丸めモードに依存する関数以外の全て) を`constexpr`対応	`<cmath>`, `<cstdlib>`
`__cpp_lib_constexpr_complex`	`202306L`	`std::complex`の全関数を`constexpr`対応	`<complex>`
`__cpp_lib_constexpr_deque`	`202502L`	`std::deque`を`constexpr`対応	`<deque>`
`__cpp_lib_constexpr_exceptions`	`202502L`	定数式での例外送出が許可されることにともない、例外クラスの関連機能を`constexpr`対応	`<exception>`, `<stdexcept>`, `<expected>`, `<optional>`, `<variant>`, `<format>`
`__cpp_lib_constexpr_flat_map`	`202502L`	`std::flat_map` / `std::flat_multimap`を`constexpr`対応	`<flat_map>`
`__cpp_lib_constexpr_flat_set`	`202502L`	`std::flat_set` / `std::flat_multiset`を`constexpr`対応	`<flat_set>`
`__cpp_lib_constexpr_forward_list`	`202502L`	`std::forward_list`を`constexpr`対応	`<forward_list>`
`__cpp_lib_constexpr_inplace_vector`	`202603L`	`std::inplace_vector`を`constexpr`対応	`<inplace_vector>`
`__cpp_lib_constexpr_list`	`202502L`	`std::list`を`constexpr`対応	`<list>`
`__cpp_lib_constexpr_map`	`202502L`	`std::map` / `std::multimap`を`constexpr`対応	`<map>`
`__cpp_lib_constexpr_memory`	`202506L`	`std::shared_ptr`クラスとその関連機能を`constexpr`対応	`<memory>`
`__cpp_lib_constexpr_new`	`202406L`	`constexpr`配置`new`	`<new>`
`__cpp_lib_constexpr_queue`	`202502L`	`std::queue` / `std::priority_queue`を`constexpr`対応	`<queue>`
`__cpp_lib_constexpr_set`	`202502L`	`std::set` / `std::multiset`を`constexpr`対応	`<set>`
`__cpp_lib_constexpr_stack`	`202502L`	`std::stack`を`constexpr`対応	`<stack>`
`__cpp_lib_constexpr_unordered_map`	`202502L`	`std::unordered_map` / `std::unordered_multimap`を`constexpr`対応	`<unordered_map>`
`__cpp_lib_constexpr_unordered_set`	`202502L`	`std::unordered_set` / `std::unordered_multiset`を`constexpr`対応	`<unordered_set>`
`__cpp_lib_constrained_equality`	`202411L`	`std::reference_wrapper`に、比較演算子`==`と`<=>`を追加	`<utility>`, `<tuple>`, `<optional>`, `<variant>`, `<expected>`
`__cpp_lib_contracts`	`202502L`	契約プログラミングをサポートする	`<contracts>`
`__cpp_lib_copyable_function`	`202306L`	`<functional>`に`std::copyable_function`を追加	`<functional>`
`__cpp_lib_counting_scope`	`202506L`	`<execution>`に`std::execution::spawn`、`std::execution::scope_token`などを追加	`<execution>`
`__cpp_lib_debugging`	`202403L`	デバッグサポートのライブラリとして`<debugging>`を追加	`<debugging>`
`__cpp_lib_define_static`	`202506L`		`<meta>`
`__cpp_lib_exception_ptr_cast`	`202603L`	`std::exception_ptr`を指定した例外型にキャストする`std::exception_ptr_cast()`関数を追加	`<exception>`
`__cpp_lib_format`	`202603L`	`std::dynamic_format`	`<format>`
`__cpp_lib_format_path`	`202506L`	`std::filesystem::path`クラスに、文字列フォーマットのサポートを追加 `std::filesystem::path`クラスに、出力用の文字列を取得するためのメンバ関数を追加	`<filesystem>`
`__cpp_lib_format_uchar`	`202311L`	`std::format`が`char`を数値出力する際は符号なしとして扱う	`<format>`
`__cpp_lib_freestanding_algorithm`	`202502L`		`<algorithm>`
`__cpp_lib_freestanding_array`	`202311L`		`<array>`
`__cpp_lib_freestanding_char_traits`	`202306L`		`<string>`
`__cpp_lib_freestanding_charconv`	`202306L`		`<charconv>`
`__cpp_lib_freestanding_cstdlib`	`202306L`		`<cstdlib>`, `<cmath>`
`__cpp_lib_freestanding_cstring`	`202311L`		`<cstring>`
`__cpp_lib_freestanding_cwchar`	`202306L`		`<cwchar>`
`__cpp_lib_freestanding_errc`	`202306L`		`<cerrno>`, `<system_error>`
`__cpp_lib_freestanding_execution`	`202502L`		`<execution>`
`__cpp_lib_freestanding_expected`	`202311L`		`<expected>`
`__cpp_lib_freestanding_feature_test_macros`	`202306L`
`__cpp_lib_freestanding_functional`	`202306L`		`<functional>`
`__cpp_lib_freestanding_iterator`	`202306L`		`<iterator>`
`__cpp_lib_freestanding_mdspan`	`202311L`		`<mdspan>`
`__cpp_lib_freestanding_memory`	`202502L`		`<memory>`
`__cpp_lib_freestanding_numeric`	`202502L`		`<numeric>`
`__cpp_lib_freestanding_operator_new`	`202306L` or `0`		`<new>`
`__cpp_lib_freestanding_optional`	`202506L`		`<optional>`
`__cpp_lib_freestanding_random`	`202502L`		`<random>`
`__cpp_lib_freestanding_ranges`	`202306L`		`<ranges>`
`__cpp_lib_freestanding_ratio`	`202306L`		`<ratio>`
`__cpp_lib_freestanding_string_view`	`202311L`		`<string_view>`
`__cpp_lib_freestanding_tuple`	`202306L`		`<tuple>`
`__cpp_lib_freestanding_utility`	`202306L`		`<utility>`
`__cpp_lib_freestanding_variant`	`202311L`		`<variant>`
`__cpp_lib_fstream_native_handle`	`202306L`	`std::basic_fstream`などのメンバに、ファイルのネイティブハンドルを追加	`<fstream>`
`__cpp_lib_function_ref`	`202306L`	`<functional>`に`std::function_ref`を追加	`<functional>`
`__cpp_lib_hazard_pointer`	`202306L`	ハザードポインタのライブラリ`<hazard_pointer>`を追加	`<hazard_pointer>`
`__cpp_lib_hive`	`202502L`	シーケンスコンテナのライブラリ`<hive>`を追加	`<hive>`
`__cpp_lib_indirect`	`202502L`	`<memory>`に`std::indirect`と`std::polymorphic`を追加	`<memory>`
`__cpp_lib_inplace_vector`	`202603L`	容量固定の可変長配列のライブラリ`<inplace_vector>`を追加	`<inplace_vector>`
`__cpp_lib_integer_sequence`	`202511L`	`std::integer_sequence`を構造化束縛と`template for`文で使用できるよう、タプルインタフェースの特殊化を追加	`<utility>`
`__cpp_lib_is_sufficiently_aligned`	`202411L`	`<mdspan>`に、要素アクセスにアライメント保証を与える`std::aligned_accessor`を追加	`<memory>`
`__cpp_lib_is_structural`	`202603L`	`<type_traits>`に`std::is_structural`を追加	`<type_traits>`, `<meta>`
`__cpp_lib_is_virtual_base_of`	`202406L`	`<type_traits>`に`std::is_virtual_base_of`を追加	`<type_traits>`
`__cpp_lib_is_within_lifetime`	`202306L`	`<type_traits>`に`std::is_within_lifetime()`を追加	`<type_traits>`
`__cpp_lib_linalg`	`202412L`	線形代数ライブラリとして`<linalg>`を追加	`<linalg>`
`__cpp_lib_mdspan`	`202406L`	`std::mdspan`に対する`std::dextents`指定の冗長さを解決する`std::dims`を追加	`<mdspan>`
`__cpp_lib_not_fn`	`202306L`	`std::not_fn()`に、非型テンプレート引数として関数を指定するオーバーロードを追加	`<functional>`
`__cpp_lib_observable_checkpoint`	`202506L`	`<utility>`に`std::observable_checkpoint()`を追加	`<utility>`
`__cpp_lib_optional`	`202506L`	`std::optional`に、参照を保持するための`T&`の部分特殊化を追加	`<optional>`
`__cpp_lib_optional_range_support`	`202406L`	`std::optional`にイテレータインタフェースを追加	`<optional>`
`__cpp_lib_out_ptr`	`202311L`		`<memory>`
`__cpp_lib_parallel_algorithm`	`202506L`	`<algorithm>`と`<memory>`のアルゴリズムを並列実行に対応	`<algorithm>`, `<numeric>`, `<memory>`
`__cpp_lib_parallel_scheduler`	`202506L`	`<execution>`に`std::execution::parallel_scheduler`を追加	`<execution>`
`__cpp_lib_philox_engine`	`202406L`	`<random>`に`std::philox_engine`、`std::philox4x32`、`std::philox4x64`を追加	`<random>`
`__cpp_lib_polymorphic`	`202502L`	`<memory>`に`std::indirect`と`std::polymorphic`を追加	`<memory>`
`__cpp_lib_print`	`202406L`	`std::print()`と`std::println()`にロックを取得せず高速に書き出す最適化を許可 `std::enable_nonlocking_formatter_optimization`を追加	`<print>`, `<ostream>`
`__cpp_lib_ranges`	`202406L`	`std::indirectly_unary_invocable`などのコンセプトの共通参照要件を削除	`<algorithm>`, `<functional>`, `<iterator>`, `<memory>`, `<ranges>`
`__cpp_lib_ranges_as_const`	`202311L`	`std::basic_const_iterator`を元の要素へのキャストを可能にする	`<ranges>`
`__cpp_lib_ranges_cache_latest`	`202411L`	`std::views::cache_latest`を追加	`<ranges>`
`__cpp_lib_ranges_concat`	`202403L`	`std::views::concat`を追加	`<ranges>`
`__cpp_lib_ranges_generate_random`	`202403L`	`<random>`に、乱数列を生成する`std::ranges::generate_random()`関数を追加	`<random>`
`__cpp_lib_ranges_indices`	`202506L`	インデックス列を生成する`std::views::indices`を追加	`<ranges>`
`__cpp_lib_ranges_reserve_hint`	`202502L`	各viewクラスに`reserve_hint()`メンバ関数を追加 `std::ranges::reserve_hint()`関数を追加 `std::ranges::approximately_sized_range`コンセプトを追加	`<ranges>`
`__cpp_lib_ranges_as_input`	`202502L`	`std::views::as_input`を追加	`<ranges>`
`__cpp_lib_ratio`	`202306L`	`<ratio>`に、新たなSI接頭辞を追加	`<ratio>`
`__cpp_lib_raw_memory_algorithms`	`202411L`	`std::uninitialized_default_construct()`などの未初期化領域に対する操作を`constexpr`対応	`<memory>`
`__cpp_lib_rcu`	`202306L`	RCU (Read Copy Update) のライブラリとして`<rcu>`を追加	`<rcu>`
`__cpp_lib_reference_wrapper`	`202403L`	`std::reference_wrapper`に、比較演算子`==`と`<=>`を追加	`<functional>`
`__cpp_lib_reflection`	`202506L`	静的リフレクションのライブラリ機能	`<meta>`
`__cpp_lib_saturation_arithmetic`	`202603L`	`<numeric>`に飽和演算 (Saturation Arithmetic) として`std::saturating_add()`などの関数を追加	`<numeric>`
`__cpp_lib_senders`	`202506L`		`<execution>`
`__cpp_lib_simd`	`202506L`	データ並列ライブラリとして、`<simd>`を追加	`<simd>`
`__cpp_lib_simd_complex`	`202502L`	`<simd>`が`std::complex`をサポートする	`<simd>`
`__cpp_lib_simd_permutations`	`202506L`	`<simd>`に`permute()`などを追加する	`<simd>`
`__cpp_lib_smart_ptr_owner_equality`	`202306L`	`<memory>`に`std::owner_hash`と`std::owner_equal`を追加	`<memory>`
`__cpp_lib_span`	`202311L`	`std::mdspan`に`at()`メンバ関数を追加	`<span>`
`__cpp_lib_span_initializer_list`	`202311L`	`std::span`に`std::initializer_list`をとるコンストラクタを追加	`<span>`
`__cpp_lib_sstream_from_string_view`	`202306L`	`std::basic_stringstream`などが`std::basic_string_view`から構築可能に	`<sstream>`
`__cpp_lib_string_subview`	`202506L`	`std::basic_string`と`std::basic_string_view`に`subview()`を追加	`<string>`, `<string_view>`
`__cpp_lib_string_view`	`202403L`	`std::basic_string`と`std::basic_string_view`を連結させる`operator+`を追加	`<string>`, `<string_view>`
`__cpp_lib_submdspan`	`202411L`	`std::mdspan`から部分ビューを取り出す`std::submdspan()`を追加	`<mdspan>`
`__cpp_lib_task`	`202506L`		`<execution>`
`__cpp_lib_text_encoding`	`202306L`	文字列エンコーディングを識別するライブラリ`<text_encoding>`を追加	`<text_encoding>`
`__cpp_lib_to_chars`	`202306L`	`std::to_chars_result`と`std::from_chars_result`に`operator bool`を追加	`<charconv>`
`__cpp_lib_to_string`	`202306L`	`std::to_string`の変換結果を`sprintf()`ベースから`std::format()`ベースに変更	`<string>`
`__cpp_lib_trivially_relocatable`	`202502L`	トリビアルな再配置	`<memory>`, `<type_traits>`
`__cpp_lib_tuple_like`	`202311L`	`std::complex`にタプルインタフェースの特殊化を追加	`<utility>`, `<tuple>`, `<map>`, `<unordered_map>`
`__cpp_lib_type_order`	`202506L`	`std::type_order`を追加	`<compare>`
`__cpp_lib_variant`	`202306L`	`std::variant`クラスに、メンバ関数版の`visit()`を追加	`<variant>`

実装依存のマクロ。

マクロ名	値	ヘッダ
`__cpp_lib_hardened_array`	`202502L`	`<array>`
`__cpp_lib_hardened_basic_stacktrace`	`202506L`	`<stacktrace>`
`__cpp_lib_hardened_basic_string`	`202502L`	`<string>`
`__cpp_lib_hardened_basic_string_view`	`202502L`	`<string_view>`
`__cpp_lib_hardened_bitset`	`202502L`	`<bitset>`
`__cpp_lib_hardened_common_iterator`	`202506L`	`<iterator>`
`__cpp_lib_hardened_counted_iterator`	`202506L`	`<iterator>`
`__cpp_lib_hardened_deque`	`202502L`	`<deque>`
`__cpp_lib_hardened_expected`	`202502L`	`<expected>`
`__cpp_lib_hardened_forward_list`	`202502L`	`<forward_list>`
`__cpp_lib_hardened_inplace_vector`	`202502L`	`<inplace_vector>`
`__cpp_lib_hardened_list`	`202502L`	`<list>`
`__cpp_lib_hardened_mdspan`	`202502L`	`<mdspan>`
`__cpp_lib_hardened_optional`	`202502L`	`<optional>`
`__cpp_lib_hardened_shared_ptr_array`	`202506L`	`<memory>`
`__cpp_lib_hardened_span`	`202502L`	`<span>`
`__cpp_lib_hardened_valarray`	`202502L`	`<valarray>`
`__cpp_lib_hardened_vector`	`202502L`	`<vector>`
`__cpp_lib_hardened_view_interface`	`202506L`	`<ranges>`

参照

SD-FeatureTest: Feature-Test Macros and Policies - isocpp

ranges -- C++26のreserve_hint関係に対応 (close #1427)

2026-05-21T15:03:06+09:00

diff --git a/reference/ranges.md b/reference/ranges.md
index 9a27ee89b..08fe553bf 100644
--- a/reference/ranges.md
+++ b/reference/ranges.md
@@ -55,6 +55,7 @@ C++20では関数によるカスタマイゼーションポイントの問題点
 | [`crend`](ranges/crend.md)     | Rangeの先頭の前を指す読み取り専用逆イテレータもしくは番兵を取得する (customization point object)  | C++20          |
 | [`size`](ranges/size.md)       | Rangeの要素数を取得する (customization point object)                                              | C++20          |
 | [`ssize`](ranges/ssize.md)     | Rangeの要素数を、符号付き整数型で取得する (customization point object)                            | C++20          |
+| [`reserve_hint`](ranges/reserve_hint.md) | Rangeの要素数の近似値を取得する (customization point object)                            | C++26          |
 | [`empty`](ranges/empty.md)     | Rangeが空かどうかを判定する (customization point object)                                          | C++20          |
 | [`data`](ranges/data.md)       | Rangeの要素配列へのポインタを取得する (customization point object)                                | C++20          |
 | [`cdata`](ranges/cdata.md)     | Rangeの要素配列への読み取り専用ポインタを取得する (customization point object)                    | C++20          |
@@ -81,6 +82,7 @@ C++20では関数によるカスタマイゼーションポイントの問題点
 | [`range`](ranges/range.md)                             | Rangeを定義するコンセプト (concept)                         | C++20          |
 | [`borrowed_range`](ranges/borrowed_range.md)           | 所有権を持たないRange (concept)                             | C++20          |
 | [`sized_range`](ranges/sized_range.md)                 | サイズを償却定数時間で求められるRange (concept)             | C++20          |
+| [`approximately_sized_range`](ranges/approximately_sized_range.md) | サイズの近似値を償却定数時間で求められるRange (concept) | C++26 |
 | [`view`](ranges/view.md)                               | ビューであるRange (concept)                                 | C++20          |
 | [`output_range`](ranges/output_range.md)               | イテレータが出力イテレータであるRange (concept)             | C++20          |
 | [`input_range`](ranges/input_range.md)                 | イテレータが入力イテレータであるRange (concept)             | C++20          |

adjacent_transform_view -- C++26のreserve_hint関係に対応 (close #1427)

2026-05-21T15:03:06+09:00

diff --git a/reference/ranges/adjacent_transform_view.md b/reference/ranges/adjacent_transform_view.md
index ab2942409..a0e06c65c 100644
--- a/reference/ranges/adjacent_transform_view.md
+++ b/reference/ranges/adjacent_transform_view.md
@@ -59,6 +59,7 @@ namespace std::ranges {
 | [`begin`](adjacent_transform_view/begin.md)                   | 先頭を指すイテレータを取得する   | C++23          |
 | [`end`](adjacent_transform_view/end.md)                       | 番兵を取得する                   | C++23          |
 | [`size`](adjacent_transform_view/size.md)                     | 要素数を取得する                 | C++23          |
+| [`reserve_hint`](adjacent_transform_view/reserve_hint.md) | 要素数の近似値を取得する  | C++26          |
 
 ## 継承しているメンバ関数

reserve_hint -- C++26のreserve_hint関係に対応 (close #1427)

2026-05-21T15:03:06+09:00

diff --git a/reference/ranges/adjacent_transform_view/reserve_hint.md b/reference/ranges/adjacent_transform_view/reserve_hint.md
new file mode 100644
index 000000000..4795a2098
--- /dev/null
+++ b/reference/ranges/adjacent_transform_view/reserve_hint.md
@@ -0,0 +1,47 @@
+# reserve_hint
+* ranges[meta header]
+* std::ranges[meta namespace]
+* adjacent_transform_view[meta class]
+* function[meta id-type]
+* cpp26[meta cpp]
+
+```cpp
+constexpr auto reserve_hint()
+  requires approximately_sized_range<InnerView>;       // (1) C++26
+
+constexpr auto reserve_hint() const
+  requires approximately_sized_range<const InnerView>; // (2) C++26
+```
+* approximately_sized_range[link /reference/ranges/approximately_sized_range.md]
+
+## 概要
+要素数の近似値を取得する。
+
+`InnerView`は内部で保持する[`adjacent_view`](/reference/ranges/adjacent_view.md)`<V, N>`型の説明専用エイリアスである。`adjacent_view`の`reserve_hint`をそのまま転送する。
+
+
+## テンプレートパラメータ制約
+- (1) : 型`InnerView`が[`approximately_sized_range`](/reference/ranges/approximately_sized_range.md)であること
+- (2) : 型`const InnerView`が[`approximately_sized_range`](/reference/ranges/approximately_sized_range.md)であること
+
+
+## 戻り値
+内部の[`adjacent_view`](/reference/ranges/adjacent_view.md) `inner_`に対して、以下を返す：
+
+```cpp
+return inner_.reserve_hint();
+```
+
+
+## バージョン
+### 言語
+- 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]
+
+
+## 参照
+- [P2846R6 `reserve_hint`: Eagerly reserving memory for not-quite-sized lazy ranges](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p2846r6.pdf)

adjacent_view -- C++26のreserve_hint関係に対応 (close #1427)

2026-05-21T15:03:06+09:00

diff --git a/reference/ranges/adjacent_view.md b/reference/ranges/adjacent_view.md
index 39dff28d6..0a6bc51b4 100644
--- a/reference/ranges/adjacent_view.md
+++ b/reference/ranges/adjacent_view.md
@@ -56,6 +56,7 @@ namespace std::ranges {
 | [`begin`](adjacent_view/begin.md)                   | 先頭を指すイテレータを取得する   | C++23          |
 | [`end`](adjacent_view/end.md)                       | 番兵を取得する                   | C++23          |
 | [`size`](adjacent_view/size.md)                     | 要素数を取得する                 | C++23          |
+| [`reserve_hint`](adjacent_view/reserve_hint.md) | 要素数の近似値を取得する      | C++26          |
 
 ## 継承しているメンバ関数

reserve_hint -- C++26のreserve_hint関係に対応 (close #1427)

2026-05-21T15:03:06+09:00

diff --git a/reference/ranges/adjacent_view/reserve_hint.md b/reference/ranges/adjacent_view/reserve_hint.md
new file mode 100644
index 000000000..ab0d19023
--- /dev/null
+++ b/reference/ranges/adjacent_view/reserve_hint.md
@@ -0,0 +1,54 @@
+# reserve_hint
+* ranges[meta header]
+* std::ranges[meta namespace]
+* adjacent_view[meta class]
+* function[meta id-type]
+* cpp26[meta cpp]
+
+```cpp
+constexpr auto reserve_hint()
+  requires approximately_sized_range<V>;       // (1) C++26
+
+constexpr auto reserve_hint() const
+  requires approximately_sized_range<const V>; // (2) C++26
+```
+* approximately_sized_range[link /reference/ranges/approximately_sized_range.md]
+
+## 概要
+要素数の近似値を取得する。
+
+`adjacent_view`は元のRangeから N 個の連続する要素のタプルを生成するため、要素数の近似値は「元のRangeの`reserve_hint` − N + 1」（負になる場合は 0）となる。
+
+
+## テンプレートパラメータ制約
+- (1) : 型`V`が[`approximately_sized_range`](/reference/ranges/approximately_sized_range.md)であること
+- (2) : 型`const V`が[`approximately_sized_range`](/reference/ranges/approximately_sized_range.md)であること
+
+
+## 効果
+以下と等価：
+
+```cpp
+using DT = range_difference_t<decltype((base_))>;
+using CT = common_type_t<DT, size_t>;
+auto sz = static_cast<CT>(ranges::reserve_hint(base_));
+sz -= std::min<CT>(sz, N - 1);
+return to-unsigned-like(sz);
+```
+* ranges::reserve_hint[link /reference/ranges/reserve_hint.md]
+* range_difference_t[link /reference/ranges/range_difference_t.md]
+* common_type_t[link /reference/type_traits/common_type.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]
+
+
+## 参照
+- [P2846R6 `reserve_hint`: Eagerly reserving memory for not-quite-sized lazy ranges](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p2846r6.pdf)

approximately_sized_range -- C++26のreserve_hint関係に対応 (close #1427)

2026-05-21T15:03:06+09:00

diff --git a/reference/ranges/approximately_sized_range.md b/reference/ranges/approximately_sized_range.md
new file mode 100644
index 000000000..e8257a07a
--- /dev/null
+++ b/reference/ranges/approximately_sized_range.md
@@ -0,0 +1,72 @@
+# approximately_sized_range
+* ranges[meta header]
+* concept[meta id-type]
+* std::ranges[meta namespace]
+* cpp26[meta cpp]
+
+```cpp
+namespace std::ranges {
+  template<class T>
+  concept approximately_sized_range =
+    range<T> && requires(T& t) { ranges::reserve_hint(t); };
+}
+```
+
+## 概要
+`approximately_sized_range`は、要素数の近似値を償却定数時間で求めることができるRangeを表すコンセプトである。
+
+[`sized_range`](sized_range.md)が正確な要素数を要求するのに対し、`approximately_sized_range`は概算値で十分とする。Unicodeのケース変換や正規化など、出力サイズが入力サイズから厳密には計算できないが概算は可能な場面で、出力先コンテナのメモリ事前確保 (`reserve()`) に利用できる。
+
+`approximately_sized_range`なRangeからは[`ranges::reserve_hint`](reserve_hint.md)で要素数の近似値を取得できる。
+
+
+## モデル
+型が[`remove_reference_t`](/reference/type_traits/remove_reference.md)`<T>`であるlvalue`t`について、`T`が`approximately_sized_range`のモデルとなるのは、以下の条件をすべて満たす場合である：
+
+1. [`ranges::reserve_hint`](reserve_hint.md)`(t)`が償却定数時間で実行でき、`t`を変更せず、その値は0以上で[`range_difference_t`](range_difference_t.md)`<T>`で表現可能であること
+2. [`iterator_t`](iterator_t.md)`<T>`が[`forward_iterator`](/reference/iterator/forward_iterator.md)のモデルであれば、[`ranges::reserve_hint`](reserve_hint.md)`(t)`は[`ranges::begin`](begin.md)`(t)`の評価によらず一意に定まること
+
+
+## 備考
+[`sized_range`](sized_range.md)は`approximately_sized_range`を継承するため、`sized_range`であれば`approximately_sized_range`でもある。
+
+
+## 例
+```cpp example
+#include <ranges>
+#include <vector>
+#include <forward_list>
+
+int main()
+{
+  // vectorはsized_rangeなのでapproximately_sized_range
+  static_assert(std::ranges::approximately_sized_range<std::vector<int>>);
+
+  // forward_listはsized_rangeではないがreserve_hintも提供しない
+  static_assert(!std::ranges::approximately_sized_range<std::forward_list<int>>);
+}
+```
+* std::ranges::approximately_sized_range[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]
+
+
+## 関連項目
+- [`std::ranges::sized_range`](sized_range.md)
+- [`std::ranges::reserve_hint`](reserve_hint.md)
+
+
+## 参照
+- [P2846R6 `reserve_hint`: Eagerly reserving memory for not-quite-sized lazy ranges](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p2846r6.pdf)

as_const_view -- C++26のreserve_hint関係に対応 (close #1427)

2026-05-21T15:03:06+09:00

diff --git a/reference/ranges/as_const_view.md b/reference/ranges/as_const_view.md
index 3edb84f60..62e7e393d 100644
--- a/reference/ranges/as_const_view.md
+++ b/reference/ranges/as_const_view.md
@@ -47,6 +47,7 @@ namespace std::ranges {
 | [`begin`](as_const_view/begin.md)                   | 先頭を指すイテレータを取得する   | C++23          |
 | [`end`](as_const_view/end.md)                       | 番兵を取得する                   | C++23          |
 | [`size`](as_const_view/size.md)                     | 要素数を取得する                 | C++23          |
+| [`reserve_hint`](as_const_view/reserve_hint.md) | 要素数の近似値を取得する      | C++26          |
 
 ## 継承しているメンバ関数

reserve_hint -- C++26のreserve_hint関係に対応 (close #1427)

2026-05-21T15:03:06+09:00

diff --git a/reference/ranges/as_const_view/reserve_hint.md b/reference/ranges/as_const_view/reserve_hint.md
new file mode 100644
index 000000000..1cafee9f4
--- /dev/null
+++ b/reference/ranges/as_const_view/reserve_hint.md
@@ -0,0 +1,46 @@
+# reserve_hint
+* ranges[meta header]
+* std::ranges[meta namespace]
+* as_const_view[meta class]
+* function[meta id-type]
+* cpp26[meta cpp]
+
+```cpp
+constexpr auto reserve_hint()
+  requires approximately_sized_range<V>;       // (1) C++26
+
+constexpr auto reserve_hint() const
+  requires approximately_sized_range<const V>; // (2) C++26
+```
+* approximately_sized_range[link /reference/ranges/approximately_sized_range.md]
+
+## 概要
+要素数の近似値を取得する。
+
+
+## テンプレートパラメータ制約
+- (1) : 型`V`が[`approximately_sized_range`](/reference/ranges/approximately_sized_range.md)であること
+- (2) : 型`const V`が[`approximately_sized_range`](/reference/ranges/approximately_sized_range.md)であること
+
+
+## 戻り値
+元のRange`base_`に対して、以下を返す：
+
+```cpp
+return ranges::reserve_hint(base_);
+```
+* ranges::reserve_hint[link /reference/ranges/reserve_hint.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]
+
+
+## 参照
+- [P2846R6 `reserve_hint`: Eagerly reserving memory for not-quite-sized lazy ranges](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p2846r6.pdf)

as_rvalue_view -- C++26のreserve_hint関係に対応 (close #1427)

2026-05-21T15:03:06+09:00

diff --git a/reference/ranges/as_rvalue_view.md b/reference/ranges/as_rvalue_view.md
index 46c94177d..4d23104df 100644
--- a/reference/ranges/as_rvalue_view.md
+++ b/reference/ranges/as_rvalue_view.md
@@ -59,6 +59,7 @@ std::ranges::copy(words | views::as_rvalue, std::back_inserter(new_words));
 | [`begin`](as_rvalue_view/begin.md)                  | 先頭を指すイテレータを取得する | C++23          |
 | [`end`](as_rvalue_view/end.md)                      | 番兵を取得する                 | C++23          |
 | [`size`](as_rvalue_view/size.md)                    | 要素数を取得する               | C++23          |
+| [`reserve_hint`](as_rvalue_view/reserve_hint.md) | 要素数の近似値を取得する   | C++26          |
 
 `r`を参照先のRangeとする。`size`は、[`ranges::size`](size.md)`(r)`が有効な式であるときに定義される。

reserve_hint -- C++26のreserve_hint関係に対応 (close #1427)

2026-05-21T15:03:06+09:00

diff --git a/reference/ranges/as_rvalue_view/reserve_hint.md b/reference/ranges/as_rvalue_view/reserve_hint.md
new file mode 100644
index 000000000..30bcd0447
--- /dev/null
+++ b/reference/ranges/as_rvalue_view/reserve_hint.md
@@ -0,0 +1,46 @@
+# reserve_hint
+* ranges[meta header]
+* std::ranges[meta namespace]
+* as_rvalue_view[meta class]
+* function[meta id-type]
+* cpp26[meta cpp]
+
+```cpp
+constexpr auto reserve_hint()
+  requires approximately_sized_range<V>;       // (1) C++26
+
+constexpr auto reserve_hint() const
+  requires approximately_sized_range<const V>; // (2) C++26
+```
+* approximately_sized_range[link /reference/ranges/approximately_sized_range.md]
+
+## 概要
+要素数の近似値を取得する。
+
+
+## テンプレートパラメータ制約
+- (1) : 型`V`が[`approximately_sized_range`](/reference/ranges/approximately_sized_range.md)であること
+- (2) : 型`const V`が[`approximately_sized_range`](/reference/ranges/approximately_sized_range.md)であること
+
+
+## 戻り値
+元のRange`base_`に対して、以下を返す：
+
+```cpp
+return ranges::reserve_hint(base_);
+```
+* ranges::reserve_hint[link /reference/ranges/reserve_hint.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]
+
+
+## 参照
+- [P2846R6 `reserve_hint`: Eagerly reserving memory for not-quite-sized lazy ranges](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p2846r6.pdf)

chunk_view -- C++26のreserve_hint関係に対応 (close #1427)

2026-05-21T15:03:06+09:00

diff --git a/reference/ranges/chunk_view.md b/reference/ranges/chunk_view.md
index 0a647ab96..13b994123 100644
--- a/reference/ranges/chunk_view.md
+++ b/reference/ranges/chunk_view.md
@@ -60,6 +60,7 @@ namespace std::ranges {
 | [`begin`](chunk_view/begin.md)                   | 先頭を指すイテレータを取得する   | C++23          |
 | [`end`](chunk_view/end.md)                       | 番兵を取得する                   | C++23          |
 | [`size`](chunk_view/size.md)                     | 要素数を取得する                 | C++23          |
+| [`reserve_hint`](chunk_view/reserve_hint.md) | 要素数の近似値を取得する      | C++26          |
 
 ## 継承しているメンバ関数

reserve_hint -- C++26のreserve_hint関係に対応 (close #1427)

2026-05-21T15:03:06+09:00

diff --git a/reference/ranges/chunk_view/reserve_hint.md b/reference/ranges/chunk_view/reserve_hint.md
new file mode 100644
index 000000000..f5febd8e2
--- /dev/null
+++ b/reference/ranges/chunk_view/reserve_hint.md
@@ -0,0 +1,52 @@
+# reserve_hint
+* ranges[meta header]
+* std::ranges[meta namespace]
+* chunk_view[meta class]
+* function[meta id-type]
+* cpp26[meta cpp]
+
+```cpp
+constexpr auto reserve_hint()
+  requires approximately_sized_range<V>;       // (1) C++26
+
+constexpr auto reserve_hint() const
+  requires approximately_sized_range<const V>; // (2) C++26
+```
+* approximately_sized_range[link /reference/ranges/approximately_sized_range.md]
+
+## 概要
+要素数の近似値を取得する。
+
+`chunk_view`は元のRangeを N 個ずつの塊に分けるため、要素数の近似値は「元のRangeの`reserve_hint`の N での切り上げ除算」となる。
+
+
+## テンプレートパラメータ制約
+- (1) : 型`V`が[`approximately_sized_range`](/reference/ranges/approximately_sized_range.md)であること
+- (2) : 型`const V`が[`approximately_sized_range`](/reference/ranges/approximately_sized_range.md)であること
+
+
+## 効果
+以下と等価：
+
+```cpp
+auto s = static_cast<range_difference_t<decltype((base_))>>(ranges::reserve_hint(base_));
+return to-unsigned-like(div-ceil(s, n_));
+```
+* ranges::reserve_hint[link /reference/ranges/reserve_hint.md]
+* range_difference_t[link /reference/ranges/range_difference_t.md]
+
+ここで`div-ceil(a, b)`は`a / 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]
+
+
+## 参照
+- [P2846R6 `reserve_hint`: Eagerly reserving memory for not-quite-sized lazy ranges](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p2846r6.pdf)

common_view -- C++26のreserve_hint関係に対応 (close #1427)

2026-05-21T15:03:06+09:00

diff --git a/reference/ranges/common_view.md b/reference/ranges/common_view.md
index 1dd81ac73..87b803f8a 100644
--- a/reference/ranges/common_view.md
+++ b/reference/ranges/common_view.md
@@ -53,6 +53,7 @@ namespace std::ranges {
 | [`begin`](common_view/begin.md)                   | 先頭を指すイテレータを取得する    | C++20          |
 | [`end`](common_view/end.md)                       | 番兵を取得する                    | C++20          |
 | [`size`](common_view/size.md)                     | 要素数を取得する                  | C++20          |
+| [`reserve_hint`](common_view/reserve_hint.md) | 要素数の近似値を取得する        | C++26          |
 
 `r`を参照先のRangeとする。`size`は、[`ranges::size`](size.md)`(r)`が有効な式であるときに定義される。

reserve_hint -- C++26のreserve_hint関係に対応 (close #1427)

2026-05-21T15:03:06+09:00

diff --git a/reference/ranges/common_view/reserve_hint.md b/reference/ranges/common_view/reserve_hint.md
new file mode 100644
index 000000000..ccb4d3f3f
--- /dev/null
+++ b/reference/ranges/common_view/reserve_hint.md
@@ -0,0 +1,46 @@
+# reserve_hint
+* ranges[meta header]
+* std::ranges[meta namespace]
+* common_view[meta class]
+* function[meta id-type]
+* cpp26[meta cpp]
+
+```cpp
+constexpr auto reserve_hint()
+  requires approximately_sized_range<V>;       // (1) C++26
+
+constexpr auto reserve_hint() const
+  requires approximately_sized_range<const V>; // (2) C++26
+```
+* approximately_sized_range[link /reference/ranges/approximately_sized_range.md]
+
+## 概要
+要素数の近似値を取得する。
+
+
+## テンプレートパラメータ制約
+- (1) : 型`V`が[`approximately_sized_range`](/reference/ranges/approximately_sized_range.md)であること
+- (2) : 型`const V`が[`approximately_sized_range`](/reference/ranges/approximately_sized_range.md)であること
+
+
+## 戻り値
+元のRange`base_`に対して、以下を返す：
+
+```cpp
+return ranges::reserve_hint(base_);
+```
+* ranges::reserve_hint[link /reference/ranges/reserve_hint.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]
+
+
+## 参照
+- [P2846R6 `reserve_hint`: Eagerly reserving memory for not-quite-sized lazy ranges](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p2846r6.pdf)

drop_view -- C++26のreserve_hint関係に対応 (close #1427)

2026-05-21T15:03:06+09:00

diff --git a/reference/ranges/drop_view.md b/reference/ranges/drop_view.md
index 17063aff7..e9f76b6b4 100644
--- a/reference/ranges/drop_view.md
+++ b/reference/ranges/drop_view.md
@@ -56,6 +56,7 @@ namespace std::ranges {
 | [`begin`](drop_view/begin.md)                   | 先頭を指すイテレータを取得する   | C++20          |
 | [`end`](drop_view/end.md)                       | 番兵を取得する                   | C++20          |
 | [`size`](drop_view/size.md)                     | 要素数を取得する                 | C++20          |
+| [`reserve_hint`](drop_view/reserve_hint.md) | 要素数の近似値を取得する      | C++26          |
 
 `r`を元のRangeとする。`size`は[`ranges::size`](size.md)`(r)`が有効な式であるときに定義される。

reserve_hint -- C++26のreserve_hint関係に対応 (close #1427)

2026-05-21T15:03:06+09:00

diff --git a/reference/ranges/drop_view/reserve_hint.md b/reference/ranges/drop_view/reserve_hint.md
new file mode 100644
index 000000000..2e2a9a37e
--- /dev/null
+++ b/reference/ranges/drop_view/reserve_hint.md
@@ -0,0 +1,50 @@
+# reserve_hint
+* ranges[meta header]
+* std::ranges[meta namespace]
+* drop_view[meta class]
+* function[meta id-type]
+* cpp26[meta cpp]
+
+```cpp
+constexpr auto reserve_hint()
+  requires approximately_sized_range<V>;       // (1) C++26
+
+constexpr auto reserve_hint() const
+  requires approximately_sized_range<const V>; // (2) C++26
+```
+* approximately_sized_range[link /reference/ranges/approximately_sized_range.md]
+
+## 概要
+要素数の近似値を取得する。
+
+`drop_view`は元のRangeから先頭 N 個を取り除くため、近似値は「元のRangeの`reserve_hint` − N」（負になる場合は 0）となる。
+
+
+## テンプレートパラメータ制約
+- (1) : 型`V`が[`approximately_sized_range`](/reference/ranges/approximately_sized_range.md)であること
+- (2) : 型`const V`が[`approximately_sized_range`](/reference/ranges/approximately_sized_range.md)であること
+
+
+## 効果
+以下と等価：
+
+```cpp
+const auto s = static_cast<range_difference_t<V>>(ranges::reserve_hint(base_));
+return to-unsigned-like(s < count_ ? 0 : s - count_);
+```
+* ranges::reserve_hint[link /reference/ranges/reserve_hint.md]
+* range_difference_t[link /reference/ranges/range_difference_t.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]
+
+
+## 参照
+- [P2846R6 `reserve_hint`: Eagerly reserving memory for not-quite-sized lazy ranges](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p2846r6.pdf)

elements_view -- C++26のreserve_hint関係に対応 (close #1427)

2026-05-21T15:03:06+09:00

diff --git a/reference/ranges/elements_view.md b/reference/ranges/elements_view.md
index f882c46f2..88fca0350 100644
--- a/reference/ranges/elements_view.md
+++ b/reference/ranges/elements_view.md
@@ -94,6 +94,7 @@ concept has-tuple-element =
 | [`begin`](elements_view/begin.md)                   | 先頭を指すイテレータを取得する   | C++20          |
 | [`end`](elements_view/end.md)                       | 番兵を取得する                   | C++20          |
 | [`size`](elements_view/size.md)                     | 要素数を取得する                 | C++20          |
+| [`reserve_hint`](elements_view/reserve_hint.md) | 要素数の近似値を取得する      | C++26          |
 
 `r`を元のRangeとする。`size`は[`ranges::size`](size.md)`(r)`が有効な式であるときに定義される。

reserve_hint -- C++26のreserve_hint関係に対応 (close #1427)

2026-05-21T15:03:06+09:00

diff --git a/reference/ranges/elements_view/reserve_hint.md b/reference/ranges/elements_view/reserve_hint.md
new file mode 100644
index 000000000..2f8a35be6
--- /dev/null
+++ b/reference/ranges/elements_view/reserve_hint.md
@@ -0,0 +1,46 @@
+# reserve_hint
+* ranges[meta header]
+* std::ranges[meta namespace]
+* elements_view[meta class]
+* function[meta id-type]
+* cpp26[meta cpp]
+
+```cpp
+constexpr auto reserve_hint()
+  requires approximately_sized_range<V>;       // (1) C++26
+
+constexpr auto reserve_hint() const
+  requires approximately_sized_range<const V>; // (2) C++26
+```
+* approximately_sized_range[link /reference/ranges/approximately_sized_range.md]
+
+## 概要
+要素数の近似値を取得する。
+
+
+## テンプレートパラメータ制約
+- (1) : 型`V`が[`approximately_sized_range`](/reference/ranges/approximately_sized_range.md)であること
+- (2) : 型`const V`が[`approximately_sized_range`](/reference/ranges/approximately_sized_range.md)であること
+
+
+## 戻り値
+元のRange`base_`に対して、以下を返す：
+
+```cpp
+return ranges::reserve_hint(base_);
+```
+* ranges::reserve_hint[link /reference/ranges/reserve_hint.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]
+
+
+## 参照
+- [P2846R6 `reserve_hint`: Eagerly reserving memory for not-quite-sized lazy ranges](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p2846r6.pdf)

enumerate_view -- C++26のreserve_hint関係に対応 (close #1427)

2026-05-21T15:03:06+09:00

diff --git a/reference/ranges/enumerate_view.md b/reference/ranges/enumerate_view.md
index 536c9bf83..8554b5dbf 100644
--- a/reference/ranges/enumerate_view.md
+++ b/reference/ranges/enumerate_view.md
@@ -47,6 +47,7 @@ namespace std::ranges {
 | [`begin`](enumerate_view/begin.md)                   | 先頭を指すイテレータを取得する   | C++23          |
 | [`end`](enumerate_view/end.md)                       | 番兵を取得する                   | C++23          |
 | [`size`](enumerate_view/size.md)                     | 要素数を取得する                 | C++23          |
+| [`reserve_hint`](enumerate_view/reserve_hint.md) | 要素数の近似値を取得する     | C++26          |
 
 ## 継承しているメンバ関数

reserve_hint -- C++26のreserve_hint関係に対応 (close #1427)

2026-05-21T15:03:06+09:00

diff --git a/reference/ranges/enumerate_view/reserve_hint.md b/reference/ranges/enumerate_view/reserve_hint.md
new file mode 100644
index 000000000..94a78c9a4
--- /dev/null
+++ b/reference/ranges/enumerate_view/reserve_hint.md
@@ -0,0 +1,46 @@
+# reserve_hint
+* ranges[meta header]
+* std::ranges[meta namespace]
+* enumerate_view[meta class]
+* function[meta id-type]
+* cpp26[meta cpp]
+
+```cpp
+constexpr auto reserve_hint()
+  requires approximately_sized_range<V>;       // (1) C++26
+
+constexpr auto reserve_hint() const
+  requires approximately_sized_range<const V>; // (2) C++26
+```
+* approximately_sized_range[link /reference/ranges/approximately_sized_range.md]
+
+## 概要
+要素数の近似値を取得する。
+
+
+## テンプレートパラメータ制約
+- (1) : 型`V`が[`approximately_sized_range`](/reference/ranges/approximately_sized_range.md)であること
+- (2) : 型`const V`が[`approximately_sized_range`](/reference/ranges/approximately_sized_range.md)であること
+
+
+## 戻り値
+元のRange`base_`に対して、以下を返す：
+
+```cpp
+return ranges::reserve_hint(base_);
+```
+* ranges::reserve_hint[link /reference/ranges/reserve_hint.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]
+
+
+## 参照
+- [P2846R6 `reserve_hint`: Eagerly reserving memory for not-quite-sized lazy ranges](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p2846r6.pdf)

owning_view -- C++26のreserve_hint関係に対応 (close #1427)

2026-05-21T15:03:06+09:00

diff --git a/reference/ranges/owning_view.md b/reference/ranges/owning_view.md
index 74488a13d..c383eff74 100644
--- a/reference/ranges/owning_view.md
+++ b/reference/ranges/owning_view.md
@@ -35,6 +35,7 @@ Rangeの右辺値をムーブして所有する[`view`](view.md)。このクラ
 | [`end`](owning_view/end.md)                       | 番兵を取得する                    | C++20          |
 | [`empty`](owning_view/empty.md)                   | Rangeが空かどうかを判定する       | C++20          |
 | [`size`](owning_view/size.md)                     | 要素数を取得する                  | C++20          |
+| [`reserve_hint`](owning_view/reserve_hint.md) | 要素数の近似値を取得する       | C++26          |
 | [`data`](owning_view/data.md)                     | Rangeの先頭へのポインタを取得する | C++20          |
 
 `r`を参照先のRangeとする。`empty`、`size`、`data`は、それぞれ[`ranges::empty`](empty.md)`(r)`、[`ranges::size`](size.md)`(r)`、[`ranges::data`](data.md)`(r)`が有効な式であるときに定義される。

reserve_hint -- C++26のreserve_hint関係に対応 (close #1427)

2026-05-21T15:03:06+09:00

diff --git a/reference/ranges/owning_view/reserve_hint.md b/reference/ranges/owning_view/reserve_hint.md
new file mode 100644
index 000000000..49cd8abde
--- /dev/null
+++ b/reference/ranges/owning_view/reserve_hint.md
@@ -0,0 +1,46 @@
+# reserve_hint
+* ranges[meta header]
+* std::ranges[meta namespace]
+* owning_view[meta class]
+* function[meta id-type]
+* cpp26[meta cpp]
+
+```cpp
+constexpr auto reserve_hint()
+  requires approximately_sized_range<R>;       // (1) C++26
+
+constexpr auto reserve_hint() const
+  requires approximately_sized_range<const R>; // (2) C++26
+```
+* approximately_sized_range[link /reference/ranges/approximately_sized_range.md]
+
+## 概要
+要素数の近似値を取得する。
+
+
+## テンプレートパラメータ制約
+- (1) : 型`R`が[`approximately_sized_range`](/reference/ranges/approximately_sized_range.md)であること
+- (2) : 型`const R`が[`approximately_sized_range`](/reference/ranges/approximately_sized_range.md)であること
+
+
+## 戻り値
+保持しているRange`r_`に対して、以下を返す：
+
+```cpp
+return ranges::reserve_hint(r_);
+```
+* ranges::reserve_hint[link /reference/ranges/reserve_hint.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]
+
+
+## 参照
+- [P2846R6 `reserve_hint`: Eagerly reserving memory for not-quite-sized lazy ranges](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p2846r6.pdf)

ref_view -- C++26のreserve_hint関係に対応 (close #1427)

2026-05-21T15:03:06+09:00

diff --git a/reference/ranges/ref_view.md b/reference/ranges/ref_view.md
index 557d5bb9f..fb724f8b2 100644
--- a/reference/ranges/ref_view.md
+++ b/reference/ranges/ref_view.md
@@ -34,6 +34,7 @@ Rangeへの参照として振る舞う[`view`](view.md)。このクラスのオ
 | [`end`](ref_view/end.md)                       | 番兵を取得する                    | C++20          |
 | [`empty`](ref_view/empty.md)                   | Rangeが空かどうかを判定する       | C++20          |
 | [`size`](ref_view/size.md)                     | 要素数を取得する                  | C++20          |
+| [`reserve_hint`](ref_view/reserve_hint.md) | 要素数の近似値を取得する        | C++26          |
 | [`data`](ref_view/data.md)                     | Rangeの先頭へのポインタを取得する | C++20          |
 
 `r`を参照先のRangeとする。`empty`、`size`、`data`は、それぞれ[`ranges::empty`](empty.md)`(r)`、[`ranges::size`](size.md)`(r)`、[`ranges::data`](data.md)`(r)`が有効な式であるときに定義される。

reserve_hint -- C++26のreserve_hint関係に対応 (close #1427)

2026-05-21T15:03:06+09:00

diff --git a/reference/ranges/ref_view/reserve_hint.md b/reference/ranges/ref_view/reserve_hint.md
new file mode 100644
index 000000000..d7bd2df24
--- /dev/null
+++ b/reference/ranges/ref_view/reserve_hint.md
@@ -0,0 +1,42 @@
+# reserve_hint
+* ranges[meta header]
+* std::ranges[meta namespace]
+* ref_view[meta class]
+* function[meta id-type]
+* cpp26[meta cpp]
+
+```cpp
+constexpr auto reserve_hint() const
+  requires approximately_sized_range<R>; // (1) C++26
+```
+* approximately_sized_range[link /reference/ranges/approximately_sized_range.md]
+
+## 概要
+要素数の近似値を取得する。
+
+
+## テンプレートパラメータ制約
+- 型`R`が[`approximately_sized_range`](/reference/ranges/approximately_sized_range.md)であること
+
+
+## 戻り値
+メンバ変数`r_`として保持しているRangeへのポインタがあるとして、以下を返す：
+
+```cpp
+return ranges::reserve_hint(*r_);
+```
+* ranges::reserve_hint[link /reference/ranges/reserve_hint.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]
+
+
+## 参照
+- [P2846R6 `reserve_hint`: Eagerly reserving memory for not-quite-sized lazy ranges](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p2846r6.pdf)

reserve_hint -- C++26のreserve_hint関係に対応 (close #1427)

2026-05-21T15:03:06+09:00

diff --git a/reference/ranges/reserve_hint.md b/reference/ranges/reserve_hint.md
new file mode 100644
index 000000000..2ea94be6f
--- /dev/null
+++ b/reference/ranges/reserve_hint.md
@@ -0,0 +1,91 @@
+# reserve_hint
+* ranges[meta header]
+* std::ranges[meta namespace]
+* cpo[meta id-type]
+* cpp26[meta cpp]
+
+```cpp
+namespace std::ranges {
+  inline namespace /*unspecified*/ {
+    inline constexpr /*unspecified*/ reserve_hint = /*unspecified*/;
+  }
+}
+```
+
+## 概要
+Rangeに対し、要素数の近似値 (償却定数時間で求められる) を取得するカスタマイゼーションポイントオブジェクト。
+
+[`ranges::to`](to.md)やコンテナの構築で出力先のメモリを事前確保 (`reserve()`) するために用いる。`uppercase_view`のように要素数が厳密には事前にわからないが概算は可能であるような遅延評価Rangeから、効率的にコンテナを構築できる。
+
+[`ranges::size`](size.md)で正確な要素数が取得できるRangeに対しては、`ranges::reserve_hint`は[`ranges::size`](size.md)と等価。それ以外で、メンバ関数または ADL で発見できる`reserve_hint`関数を提供するRangeに対しては、そちらを呼び出す。
+
+
+## 効果
+型`T`の部分式`E`に対して、`t`を`E`の参照とすると、式`ranges::reserve_hint(E)`の効果は以下の通り：
+
+- [`ranges::size`](size.md)`(E)`が有効な式であれば、[`ranges::size`](size.md)`(E)`と等価
+- そうでなければ、`auto(t.reserve_hint())`が[*integer-like*](/reference/iterator/is_integer_like.md)型の有効な式であれば、`auto(t.reserve_hint())`と等価
+- そうでなければ、`T`がクラス型または列挙体であって、ADLでのみ発見される`reserve_hint(t)`が[*integer-like*](/reference/iterator/is_integer_like.md)型の有効な式であれば、その式と等価
+- そうでなければ、呼び出しは不適格
+
+
+## 戻り値
+Rangeの要素数の近似値。常に0以上で、[`range_difference_t`](range_difference_t.md)`<T>`で表現可能。
+
+
+## カスタマイゼーションポイント
+メンバ関数`reserve_hint`を持たせるか、ADLで発見できる非メンバ関数`reserve_hint`を提供することでカスタマイズできる。
+
+
+## 備考
+- `ranges::reserve_hint(E)`が有効な式であるとき、その型は[*integer-like*](/reference/iterator/is_integer_like.md)
+- 計算量は償却定数時間でなければならない
+
+
+## 標準ライブラリでの使用箇所
+この関数オブジェクトは、Rangeからコンテナを構築・拡張する際に出力先のメモリを事前確保するために、標準ライブラリの内部で使用される：
+
+- [`std::ranges::to`](to.md) : 内部で`reserve_hint()`を呼び出してから要素のコピーを行う
+- [`std::vector`](/reference/vector/vector.md)のRange[コンストラクタ](/reference/vector/vector/op_constructor.md) : `reserve_hint()`を利用して再確保を回避する
+- [`std::vector::insert_range()`](/reference/vector/vector/insert_range.md) / [`append_range()`](/reference/vector/vector/append_range.md) : `reserve_hint()`を利用して再確保を高々1回に抑える
+
+
+## 例
+```cpp example
+#include <ranges>
+#include <vector>
+#include <print>
+
+int main()
+{
+  std::vector v = {1, 2, 3, 4, 5};
+
+  // sized_rangeなので、size()と等価な値を返す
+  std::println("{}", std::ranges::reserve_hint(v));
+}
+```
+* std::ranges::reserve_hint[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]
+
+
+## 関連項目
+- [`std::ranges::size`](size.md)
+- [`std::ranges::approximately_sized_range`](approximately_sized_range.md)
+
+
+## 参照
+- [P2846R6 `reserve_hint`: Eagerly reserving memory for not-quite-sized lazy ranges](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p2846r6.pdf)

reverse_view -- C++26のreserve_hint関係に対応 (close #1427)

2026-05-21T15:03:06+09:00

diff --git a/reference/ranges/reverse_view.md b/reference/ranges/reverse_view.md
index 1245ac080..761b00149 100644
--- a/reference/ranges/reverse_view.md
+++ b/reference/ranges/reverse_view.md
@@ -53,6 +53,7 @@ namespace std::ranges {
 | [`begin`](reverse_view/begin.md)                   | 先頭を指すイテレータを取得する    | C++20          |
 | [`end`](reverse_view/end.md)                       | 番兵を取得する                    | C++20          |
 | [`size`](reverse_view/size.md)                     | 要素数を取得する                  | C++20          |
+| [`reserve_hint`](reverse_view/reserve_hint.md) | 要素数の近似値を取得する       | C++26          |
 
 `r`を参照先のRangeとする。`size`は、[`ranges::size`](size.md)`(r)`が有効な式であるときに定義される。

reserve_hint -- C++26のreserve_hint関係に対応 (close #1427)

2026-05-21T15:03:06+09:00

diff --git a/reference/ranges/reverse_view/reserve_hint.md b/reference/ranges/reverse_view/reserve_hint.md
new file mode 100644
index 000000000..0ad7c93b1
--- /dev/null
+++ b/reference/ranges/reverse_view/reserve_hint.md
@@ -0,0 +1,46 @@
+# reserve_hint
+* ranges[meta header]
+* std::ranges[meta namespace]
+* reverse_view[meta class]
+* function[meta id-type]
+* cpp26[meta cpp]
+
+```cpp
+constexpr auto reserve_hint()
+  requires approximately_sized_range<V>;       // (1) C++26
+
+constexpr auto reserve_hint() const
+  requires approximately_sized_range<const V>; // (2) C++26
+```
+* approximately_sized_range[link /reference/ranges/approximately_sized_range.md]
+
+## 概要
+要素数の近似値を取得する。
+
+
+## テンプレートパラメータ制約
+- (1) : 型`V`が[`approximately_sized_range`](/reference/ranges/approximately_sized_range.md)であること
+- (2) : 型`const V`が[`approximately_sized_range`](/reference/ranges/approximately_sized_range.md)であること
+
+
+## 戻り値
+元のRange`base_`に対して、以下を返す：
+
+```cpp
+return ranges::reserve_hint(base_);
+```
+* ranges::reserve_hint[link /reference/ranges/reserve_hint.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]
+
+
+## 参照
+- [P2846R6 `reserve_hint`: Eagerly reserving memory for not-quite-sized lazy ranges](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p2846r6.pdf)

sized_range -- C++26のreserve_hint関係に対応 (close #1427)

2026-05-21T15:03:06+09:00

diff --git a/reference/ranges/sized_range.md b/reference/ranges/sized_range.md
index a159534d2..a4d3a9380 100644
--- a/reference/ranges/sized_range.md
+++ b/reference/ranges/sized_range.md
@@ -7,9 +7,13 @@
 ```cpp
 namespace std::ranges {
   template<class T>
-  concept sized_range = range<T> && requires(T& t) { ranges::size(t); };
+  concept sized_range = range<T> && requires(T& t) { ranges::size(t); };               // C++20
+
+  template<class T>
+  concept sized_range = approximately_sized_range<T> && requires(T& t) { ranges::size(t); }; // C++26
 }
 ```
+* approximately_sized_range[link approximately_sized_range.md]
 
 ## 概要
 `sized_range`は、大きさを償却定数時間で求めることができるRangeを表すコンセプトである。
@@ -20,6 +24,8 @@ namespace std::ranges {
 [`forward_list`](/reference/forward_list/forward_list.md)のように大きさは決まっているが償却定数時間で求められないもの、
 [`basic_istream_view`](basic_istream_view.md)のように事前に求められないものなどがある。
 
+C++26では、要素数の概算値が求まる[`approximately_sized_range`](approximately_sized_range.md)コンセプトが導入され、`sized_range`はそれを継承するようになった。
+
 ## モデル
 型が[`remove_reference_t`](/reference/type_traits/remove_reference.md)`<T>`であるようなlvalue`t`があるとする。`T`が`sized_range`のモデルとなるのは、以下の条件をすべて満たす場合である。
 
@@ -68,3 +74,5 @@ int main()
 ## 参照
 - [N4861 24 Ranges library](https://timsong-cpp.github.io/cppwp/n4861/ranges)
 - [C++20 ranges](https://techbookfest.org/product/5134506308665344)
+- [P2846R6 `reserve_hint`: Eagerly reserving memory for not-quite-sized lazy ranges](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p2846r6.pdf)
+    - C++26から[`approximately_sized_range`](approximately_sized_range.md)を継承するようになった

slide_view -- C++26のreserve_hint関係に対応 (close #1427)

2026-05-21T15:03:06+09:00

diff --git a/reference/ranges/slide_view.md b/reference/ranges/slide_view.md
index 0eed5231b..67cf50c6b 100644
--- a/reference/ranges/slide_view.md
+++ b/reference/ranges/slide_view.md
@@ -60,6 +60,7 @@ namespace std::ranges {
 | [`begin`](slide_view/begin.md)                   | 先頭を指すイテレータを取得する   | C++23          |
 | [`end`](slide_view/end.md)                       | 番兵を取得する                   | C++23          |
 | [`size`](slide_view/size.md)                     | 要素数を取得する                 | C++23          |
+| [`reserve_hint`](slide_view/reserve_hint.md) | 要素数の近似値を取得する      | C++26          |
 
 ## 継承しているメンバ関数

reserve_hint -- C++26のreserve_hint関係に対応 (close #1427)

2026-05-21T15:03:06+09:00

diff --git a/reference/ranges/slide_view/reserve_hint.md b/reference/ranges/slide_view/reserve_hint.md
new file mode 100644
index 000000000..35cdc5e19
--- /dev/null
+++ b/reference/ranges/slide_view/reserve_hint.md
@@ -0,0 +1,51 @@
+# reserve_hint
+* ranges[meta header]
+* std::ranges[meta namespace]
+* slide_view[meta class]
+* function[meta id-type]
+* cpp26[meta cpp]
+
+```cpp
+constexpr auto reserve_hint()
+  requires approximately_sized_range<V>;       // (1) C++26
+
+constexpr auto reserve_hint() const
+  requires approximately_sized_range<const V>; // (2) C++26
+```
+* approximately_sized_range[link /reference/ranges/approximately_sized_range.md]
+
+## 概要
+要素数の近似値を取得する。
+
+`slide_view`は元のRangeから N 個ずつの連続要素を1要素ずつずらして取り出すため、要素数の近似値は「元のRangeの`reserve_hint` − N + 1」（負になる場合は 0）となる。
+
+
+## テンプレートパラメータ制約
+- (1) : 型`V`が[`approximately_sized_range`](/reference/ranges/approximately_sized_range.md)であること
+- (2) : 型`const V`が[`approximately_sized_range`](/reference/ranges/approximately_sized_range.md)であること
+
+
+## 効果
+以下と等価：
+
+```cpp
+auto sz = static_cast<range_difference_t<decltype((base_))>>(ranges::reserve_hint(base_)) - n_ + 1;
+if (sz < 0) sz = 0;
+return to-unsigned-like(sz);
+```
+* ranges::reserve_hint[link /reference/ranges/reserve_hint.md]
+* range_difference_t[link /reference/ranges/range_difference_t.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]
+
+
+## 参照
+- [P2846R6 `reserve_hint`: Eagerly reserving memory for not-quite-sized lazy ranges](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p2846r6.pdf)

stride_view -- C++26のreserve_hint関係に対応 (close #1427)

2026-05-21T15:03:06+09:00

diff --git a/reference/ranges/stride_view.md b/reference/ranges/stride_view.md
index 8c0d7dbb0..ed245f8c0 100644
--- a/reference/ranges/stride_view.md
+++ b/reference/ranges/stride_view.md
@@ -45,6 +45,7 @@ namespace std::ranges {
 | [`begin`](stride_view/begin.md)                  | 先頭を指すイテレータを取得する   | C++23          |
 | [`end`](stride_view/end.md)                      | 番兵を取得する                   | C++23          |
 | [`size`](stride_view/size.md)                    | 要素数を取得する                 | C++23          |
+| [`reserve_hint`](stride_view/reserve_hint.md) | 要素数の近似値を取得する     | C++26          |
 
 ## 継承しているメンバ関数

reserve_hint -- C++26のreserve_hint関係に対応 (close #1427)

2026-05-21T15:03:06+09:00

diff --git a/reference/ranges/stride_view/reserve_hint.md b/reference/ranges/stride_view/reserve_hint.md
new file mode 100644
index 000000000..3c2f249af
--- /dev/null
+++ b/reference/ranges/stride_view/reserve_hint.md
@@ -0,0 +1,52 @@
+# reserve_hint
+* ranges[meta header]
+* std::ranges[meta namespace]
+* stride_view[meta class]
+* function[meta id-type]
+* cpp26[meta cpp]
+
+```cpp
+constexpr auto reserve_hint()
+  requires approximately_sized_range<V>;       // (1) C++26
+
+constexpr auto reserve_hint() const
+  requires approximately_sized_range<const V>; // (2) C++26
+```
+* approximately_sized_range[link /reference/ranges/approximately_sized_range.md]
+
+## 概要
+要素数の近似値を取得する。
+
+`stride_view`は元のRangeから N 要素おきに取り出すため、要素数の近似値は「元のRangeの`reserve_hint`の N での切り上げ除算」となる。
+
+
+## テンプレートパラメータ制約
+- (1) : 型`V`が[`approximately_sized_range`](/reference/ranges/approximately_sized_range.md)であること
+- (2) : 型`const V`が[`approximately_sized_range`](/reference/ranges/approximately_sized_range.md)であること
+
+
+## 効果
+以下と等価：
+
+```cpp
+auto s = static_cast<range_difference_t<decltype((base_))>>(ranges::reserve_hint(base_));
+return to-unsigned-like(div-ceil(s, stride_));
+```
+* ranges::reserve_hint[link /reference/ranges/reserve_hint.md]
+* range_difference_t[link /reference/ranges/range_difference_t.md]
+
+ここで`div-ceil(a, b)`は`a / 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]
+
+
+## 参照
+- [P2846R6 `reserve_hint`: Eagerly reserving memory for not-quite-sized lazy ranges](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p2846r6.pdf)

take_view -- C++26のreserve_hint関係に対応 (close #1427)

2026-05-21T15:03:06+09:00

diff --git a/reference/ranges/take_view.md b/reference/ranges/take_view.md
index af4097748..53ecc23ad 100644
--- a/reference/ranges/take_view.md
+++ b/reference/ranges/take_view.md
@@ -56,6 +56,7 @@ namespace std::ranges {
 | [`begin`](take_view/begin.md)                   | 先頭を指すイテレータを取得する   | C++20          |
 | [`end`](take_view/end.md)                       | 番兵を取得する                   | C++20          |
 | [`size`](take_view/size.md)                     | 要素数を取得する                 | C++20          |
+| [`reserve_hint`](take_view/reserve_hint.md) | 要素数の近似値を取得する      | C++26          |
 
 `r`を元のRangeとする。`size`は[`ranges::size`](size.md)`(r)`が有効な式であるときに定義される。

reserve_hint -- C++26のreserve_hint関係に対応 (close #1427)

2026-05-21T15:03:06+09:00

diff --git a/reference/ranges/take_view/reserve_hint.md b/reference/ranges/take_view/reserve_hint.md
new file mode 100644
index 000000000..1dc94ad57
--- /dev/null
+++ b/reference/ranges/take_view/reserve_hint.md
@@ -0,0 +1,48 @@
+# reserve_hint
+* ranges[meta header]
+* std::ranges[meta namespace]
+* take_view[meta class]
+* function[meta id-type]
+* cpp26[meta cpp]
+
+```cpp
+constexpr auto reserve_hint();       // (1) C++26
+constexpr auto reserve_hint() const; // (2) C++26
+```
+
+## 概要
+要素数の近似値を取得する。
+
+`take_view`は元のRangeから先頭 N 個を取り出すため、近似値も「元のRangeの`reserve_hint`と N の最小値」となる。元のRangeが[`approximately_sized_range`](/reference/ranges/approximately_sized_range.md)でない場合は N を返す。
+
+`take_view`は`size`と同様、元のRangeが[`approximately_sized_range`](/reference/ranges/approximately_sized_range.md)でなくとも常に`reserve_hint`を提供する。
+
+
+## 効果
+以下と等価：
+
+```cpp
+if constexpr (approximately_sized_range<V>) {
+  auto n = static_cast<range_difference_t<V>>(ranges::reserve_hint(base_));
+  return to-unsigned-like(ranges::min(n, count_));
+}
+return to-unsigned-like(count_);
+```
+* approximately_sized_range[link /reference/ranges/approximately_sized_range.md]
+* ranges::reserve_hint[link /reference/ranges/reserve_hint.md]
+* ranges::min[link /reference/algorithm/ranges_min.md]
+* range_difference_t[link /reference/ranges/range_difference_t.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]
+
+
+## 参照
+- [P2846R6 `reserve_hint`: Eagerly reserving memory for not-quite-sized lazy ranges](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p2846r6.pdf)

to -- C++26のreserve_hint関係に対応 (close #1427)

2026-05-21T15:03:06+09:00

diff --git a/reference/ranges/to.md b/reference/ranges/to.md
index a27db847b..04082a466 100644
--- a/reference/ranges/to.md
+++ b/reference/ranges/to.md
@@ -52,15 +52,27 @@ Rangeの各要素を要素とするコンテナを構築する。
     - `C(`[`ranges::begin(r)`](begin.md)`,` [`ranges::end(r)`](end.md)`,` [`std::forward`](/reference/utility/forward.md)`<Args>(args)...)`
 4. [`constructible_from`](/reference/concepts/constructible_from.md)`<C, Args...>`が`true`で、`container-insertable<C,` [`range_reference_t`](range_reference_t.md)`<R>>`が`true`である場合
     - 以下のコードで初期化する
-
-```cpp
-C c(std::forward<Args>(args)...);
-if constexpr (sized_range<R> && reservable-container<C>) {
-  c.reserve(static_cast<range_size_t<C>>(ranges::size(r)));
-}
-ranges::copy(r, container-inserter<range_reference_t<R>>(c));
-```
-* ranges::copy[link /reference/algorithm/ranges_copy.md]
+        - C++23:
+        ```cpp
+        C c(std::forward<Args>(args)...);
+        if constexpr (sized_range<R> && reservable-container<C>) {
+          c.reserve(static_cast<range_size_t<C>>(ranges::size(r)));
+        }
+        ranges::copy(r, container-inserter<range_reference_t<R>>(c));
+        ```
+        * ranges::copy[link /reference/algorithm/ranges_copy.md]
+
+        - C++26
+        ```cpp
+        C c(std::forward<Args>(args)...);
+        if constexpr (approximately_sized_range<R> && reservable-container<C>) {
+          c.reserve(static_cast<range_size_t<C>>(ranges::reserve_hint(r)));
+        }
+        ranges::copy(r, container-inserter<range_reference_t<R>>(c));
+        ```
+        * ranges::copy[link /reference/algorithm/ranges_copy.md]
+        * approximately_sized_range[link approximately_sized_range.md]
+        * ranges::reserve_hint[link reserve_hint.md]
 
 [`input_range`](input_range.md)`<`[`range_reference_t`](range_reference_t.md)`<R>>`である場合:
 
@@ -215,3 +227,5 @@ int main() {
 ## 参照
 
 - [26.5.7.2 ranges::to](https://timsong-cpp.github.io/cppwp/n4950/range.utility.conv.to)
+- [P2846R6 `reserve_hint`: Eagerly reserving memory for not-quite-sized lazy ranges](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p2846r6.pdf)
+    - C++26で要素数の事前確保に[`ranges::size`](size.md)の代わりに[`ranges::reserve_hint`](reserve_hint.md)を使用するよう変更

transform_view -- C++26のreserve_hint関係に対応 (close #1427)

2026-05-21T15:03:06+09:00

diff --git a/reference/ranges/transform_view.md b/reference/ranges/transform_view.md
index ba6c6e488..c73675423 100644
--- a/reference/ranges/transform_view.md
+++ b/reference/ranges/transform_view.md
@@ -51,6 +51,7 @@ namespace std::ranges {
 | [`begin`](transform_view/begin.md)                  | 先頭を指すイテレータを取得する   | C++20          |
 | [`end`](transform_view/end.md)                      | 番兵を取得する                   | C++20          |
 | [`size`](transform_view/size.md)                    | 要素数を取得する                 | C++20          |
+| [`reserve_hint`](transform_view/reserve_hint.md) | 要素数の近似値を取得する     | C++26          |
 
 `r`を元のRangeとする。`size`は[`ranges::size`](size.md)`(r)`が有効な式であるときに定義される。

reserve_hint -- C++26のreserve_hint関係に対応 (close #1427)

2026-05-21T15:03:06+09:00

diff --git a/reference/ranges/transform_view/reserve_hint.md b/reference/ranges/transform_view/reserve_hint.md
new file mode 100644
index 000000000..191ee7e26
--- /dev/null
+++ b/reference/ranges/transform_view/reserve_hint.md
@@ -0,0 +1,48 @@
+# reserve_hint
+* ranges[meta header]
+* std::ranges[meta namespace]
+* transform_view[meta class]
+* function[meta id-type]
+* cpp26[meta cpp]
+
+```cpp
+constexpr auto reserve_hint()
+  requires approximately_sized_range<V>;       // (1) C++26
+
+constexpr auto reserve_hint() const
+  requires approximately_sized_range<const V>; // (2) C++26
+```
+* approximately_sized_range[link /reference/ranges/approximately_sized_range.md]
+
+## 概要
+要素数の近似値を取得する。
+
+`transform_view`は各要素を関数で変換するだけで要素数は元のRangeと同じであるため、元のRangeの`reserve_hint`を転送する。
+
+
+## テンプレートパラメータ制約
+- (1) : 型`V`が[`approximately_sized_range`](/reference/ranges/approximately_sized_range.md)であること
+- (2) : 型`const V`が[`approximately_sized_range`](/reference/ranges/approximately_sized_range.md)であること
+
+
+## 戻り値
+元のRange`base_`に対して、以下を返す：
+
+```cpp
+return ranges::reserve_hint(base_);
+```
+* ranges::reserve_hint[link /reference/ranges/reserve_hint.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]
+
+
+## 参照
+- [P2846R6 `reserve_hint`: Eagerly reserving memory for not-quite-sized lazy ranges](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p2846r6.pdf)

append_range -- C++26のreserve_hint関係に対応 (close #1427)

2026-05-21T15:03:06+09:00

diff --git a/reference/vector/vector/append_range.md b/reference/vector/vector/append_range.md
index 8e95fa7d2..ba0188551 100644
--- a/reference/vector/vector/append_range.md
+++ b/reference/vector/vector/append_range.md
@@ -29,6 +29,8 @@ Range`rg`の各要素を、末尾に追加する。
 ## 計算量
 要素を追加した後の[`size()`](size.md)が要素を追加する前の[`capacity()`](capacity.md)よりも大きい場合は領域の再確保が生じ、要素を追加した後の[`size()`](size.md)に比例する。領域の再確保が発生しない場合は、[`ranges::distance`](../../iterator/ranges_distance.md)`(rg)`に比例する。
 
+C++26 : `R`が[`ranges::approximately_sized_range`](../../ranges/approximately_sized_range.md)であり、`ranges::distance(rg) <= ranges::reserve_hint(rg)`が`true`の場合、再確保は高々1回しか行われない。`R`が[`ranges::forward_range`](../../ranges/forward_range.md)で、かつ[`ranges::approximately_sized_range`](../../ranges/approximately_sized_range.md)ではない場合も同様である。
+
 
 ## 例
 ```cpp example
@@ -63,3 +65,8 @@ int main()
 |-------------------------------------------|----------------------|
 | [`push_back`](push_back.md)               | 末尾へ要素追加         |
 | [`emplace_back`](emplace_back.md)         | 末尾へ直接構築         |
+
+
+## 参照
+- [P2846R6 `reserve_hint`: Eagerly reserving memory for not-quite-sized lazy ranges](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p2846r6.pdf)
+    - C++26で、[`ranges::approximately_sized_range`](../../ranges/approximately_sized_range.md)の要素数近似値を利用して再確保が高々1回に抑えられるよう計算量保証を追加

insert_range -- C++26のreserve_hint関係に対応 (close #1427)

2026-05-21T15:03:06+09:00

diff --git a/reference/vector/vector/insert_range.md b/reference/vector/vector/insert_range.md
index 3485ba0ef..796303b62 100644
--- a/reference/vector/vector/insert_range.md
+++ b/reference/vector/vector/insert_range.md
@@ -26,6 +26,12 @@ Range`rg`の各要素を、`pos`の直前に挿入する。
 挿入されたRange`rg`の最初の要素を指すイテレータ。`rg`が空の場合は`pos`。
 
 
+## 計算量
+再確保が発生する場合は要素を挿入した後のvectorの要素数に比例し、それ以外の場合は挿入された要素数 + `pos`からvector末尾までの距離に比例する。
+
+C++26 : `R`が[`ranges::approximately_sized_range`](../../ranges/approximately_sized_range.md)であり、`ranges::distance(rg) <= ranges::reserve_hint(rg)`が`true`の場合、再確保は高々1回しか行われない。`R`が[`ranges::forward_range`](../../ranges/forward_range.md)で、かつ[`ranges::approximately_sized_range`](../../ranges/approximately_sized_range.md)ではない場合も同様である。
+
+
 ## 例
 ```cpp example
 #include <iostream>
@@ -60,3 +66,8 @@ int main()
 |-------------------------------------------|----------------------|
 | [`insert`](insert.md)                     | 要素の挿入             |
 | [`emplace`](emplace.md)                   | 要素の直接構築による挿入 |
+
+
+## 参照
+- [P2846R6 `reserve_hint`: Eagerly reserving memory for not-quite-sized lazy ranges](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p2846r6.pdf)
+    - C++26で、[`ranges::approximately_sized_range`](../../ranges/approximately_sized_range.md)の要素数近似値を利用して再確保が高々1回に抑えられるよう計算量保証を追加

コンストラクタ -- C++26のreserve_hint関係に対応 (close #1427)

2026-05-21T15:03:06+09:00

diff --git a/reference/vector/vector/op_constructor.md b/reference/vector/vector/op_constructor.md
index dc82db757..b3716e250 100644
--- a/reference/vector/vector/op_constructor.md
+++ b/reference/vector/vector/op_constructor.md
@@ -102,6 +102,7 @@ constexpr vector(std::from_range_t, R&& rg,
 - (9) : 定数時間。ただし、`a == x.`[`get_allocator`](get_allocator.md)`()` でなければ `x.`[`size`](size.md)`()` に対して線形時間。
 - (10) : `il.`[`size`](/reference/initializer_list/initializer_list/size.md)`()` に対して線形時間
 - (11) : [`ranges::distance`](../../iterator/ranges_distance.md)`(rg)` に対して線形時間。`R` のモデルが [`ranges::forward_range`](../../ranges/forward_range.md) でも [`ranges::sized_range`](../../ranges/sized_range.md) でもなければ、あらかじめ要素数が分からないため、再確保のコストが(対数オーダで)別途発生する。
+    - C++26 : `R`が[`ranges::approximately_sized_range`](../../ranges/approximately_sized_range.md)であり、`ranges::distance(rg) <= ranges::reserve_hint(rg)`が`true`の場合、再確保は行われない
 
 
 ## 備考
@@ -204,3 +205,5 @@ sixth : {1 2 3 }
 - [P1004R2 Making `std::vector` constexpr](https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2019/p1004r2.pdf)
 - [P1518R2 Stop Overconstraining Allocators in Container Deduction Guides](https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2021/p1518r2.html)
     - C++23でのアロケータ引数を`type_identity_t`で包む変更
+- [P2846R6 `reserve_hint`: Eagerly reserving memory for not-quite-sized lazy ranges](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p2846r6.pdf)
+    - C++26で、(11) Range版コンストラクタが[`ranges::approximately_sized_range`](../../ranges/approximately_sized_range.md)の要素数近似値を利用して再確保を回避するよう変更