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

機能テストマクロ -- function_ref : 二重の間接呼び出しを回避する仕様変更に対応 (close #1636)

2026-06-24T11:55: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`	`202606L`	`<utility>`に`std::constant_wrapper`を追加	`<utility>`
`__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`	`202604L`	`<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

function_ref -- function_ref : 二重の間接呼び出しを回避する仕様変更に対応 (close #1636)

2026-06-24T11:55:06+09:00

diff --git a/reference/functional/function_ref.md b/reference/functional/function_ref.md
index 76f7db38d..756c1b93f 100644
--- a/reference/functional/function_ref.md
+++ b/reference/functional/function_ref.md
@@ -119,3 +119,5 @@ int main()
 ## 参照
 - [P0792R14 `function_ref`: a type-erased callable reference](https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2023/p0792r14.html)
 - [P3774R1 Rename `std::nontype`, and make it broadly useful](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3774r1.html)
+- [P3961R1 Less double indirection in `function_ref` (RU-220)](https://open-std.org/jtc1/sc22/wg21/docs/papers/2026/p3961r1.html)
+    - 別の`function_ref`から構築する際の二重の間接呼び出しを回避するよう、コンストラクタと代入演算子の仕様を変更した

operator= -- function_ref : 二重の間接呼び出しを回避する仕様変更に対応 (close #1636)

2026-06-24T11:55:06+09:00

diff --git a/reference/functional/function_ref/op_assign.md b/reference/functional/function_ref/op_assign.md
index 089778da8..57250a84e 100644
--- a/reference/functional/function_ref/op_assign.md
+++ b/reference/functional/function_ref/op_assign.md
@@ -18,6 +18,7 @@ template<class T> function_ref& operator=(T) = delete; // (2)
 ## テンプレートパラメータ制約
 - (2) : 以下の制約をみたすとき、代入演算子はdelete宣言される
     - `T`が`function_ref`と同一型ではなく、かつ
+    - 説明専用の`is-convertible-from-specialization<T>`（[コンストラクタ](op_constructor.md)を参照）が`false`であり、かつ
     - [`is_pointer_v`](/reference/type_traits/is_pointer.md)`<T>`が`false`であり、かつ
     - `T`が[`constant_arg_t`](/reference/utility/constant_arg_t.md)の特殊化でないこと
 
@@ -73,3 +74,5 @@ int main()
 ## 参照
 - [P0792R14 `function_ref`: a type-erased callable reference](https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2023/p0792r14.html)
 - [P3774R1 Rename `std::nontype`, and make it broadly useful](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3774r1.html)
+- [P3961R1 Less double indirection in `function_ref` (RU-220)](https://open-std.org/jtc1/sc22/wg21/docs/papers/2026/p3961r1.html)
+    - delete宣言される代入演算子(2)の制約に、説明専用の`is-convertible-from-specialization`の条件を追加した

コンストラクタ -- function_ref : 二重の間接呼び出しを回避する仕様変更に対応 (close #1636)

2026-06-24T11:55:06+09:00

diff --git a/reference/functional/function_ref/op_constructor.md b/reference/functional/function_ref/op_constructor.md
index 55801d20d..c7ffd3349 100644
--- a/reference/functional/function_ref/op_constructor.md
+++ b/reference/functional/function_ref/op_constructor.md
@@ -32,6 +32,16 @@ constexpr function_ref(const function_ref&) noexcept = default;  // (6)
 
 `function_ref`オブジェクトは、説明専用のメンバ変数`thunk-ptr`と`bound-entity`を保持する。
 
+また、説明専用の変数テンプレート`is-convertible-from-specialization<F>`を次のように定義する。型`F`が、あるCV修飾 *cv2* とnoexcept例外指定 *noex2* に対する`function_ref<R(Args...) /*cv2*/ noexcept(/*noex2*/)>`の特殊化を表す場合、`is-convertible-from-specialization<F>`は次の値と等しい :
+
+```cpp
+is_convertible_v<R(&)(Args...) noexcept(/*noex2*/), R(&)(Args...) noexcept(/*noex*/)> &&
+is_convertible_v<int /*cv*/&, int /*cv2*/&>
+```
+* is_convertible_v[link /reference/type_traits/is_convertible.md]
+
+そうでない場合、`is-convertible-from-specialization<F>`は`false`である。
+
 
 ## テンプレートパラメータ制約
 `function_ref`クラステンプレートパラメータのCV修飾子 *cv* に応じて
@@ -63,8 +73,9 @@ constexpr function_ref(const function_ref&) noexcept = default;  // (6)
 
 - (1) : `bound-entity`を`f`で、`thunk-ptr`を説明専用の関数`thunk`へのアドレスで初期化する。
     - [関数呼び出し`thunk(bound-entity, call-args...)`](op_call.md)は[`invoke_r`](/reference/functional/invoke_r.md)`<R>(f, call-args...)`と等価。
-- (2) : `bound-entity`を[`addressof`](/reference/memory/addressof.md)`(f)`で、`thunk-ptr`を説明専用の関数`thunk`へのアドレスで初期化する。
+- (2) : `is-convertible-from-specialization<`[`remove_cv_t`](/reference/type_traits/remove_cv.md)`<T>>`が`false`の場合、`bound-entity`を[`addressof`](/reference/memory/addressof.md)`(f)`で、`thunk-ptr`を説明専用の関数`thunk`へのアドレスで初期化する。
     - [関数呼び出し`thunk(bound-entity, call-args...)`](op_call.md)は[`invoke_r`](/reference/functional/invoke_r.md)`<R>(static_cast</*cv*/ T&>(f), call-args...)`と等価。
+    - `is-convertible-from-specialization<`[`remove_cv_t`](/reference/type_traits/remove_cv.md)`<T>>`が`true`の場合（`f`が互換するシグニチャ・CV修飾をもつ`function_ref`の特殊化であるとき）、`bound-entity`を`f`の`bound-entity`の値で、`thunk-ptr`を`f`の`thunk-ptr`の値で初期化する。これにより、`function_ref`から別の`function_ref`を構築する際に、本来不要な二重の間接呼び出しが回避される。
 - (3) : `bound-entity`を未規定オブジェクトへのポインタまたはヌルポインタで、`thunk-ptr`を説明専用の関数`thunk`へのアドレスで初期化する。
     - [関数呼び出し`thunk(bound-entity, call-args...)`](op_call.md)は[`invoke_r`](/reference/functional/invoke_r.md)`<R>(f, call-args...)`と等価。
 - (4) : `bound-entity`を[`addressof`](/reference/memory/addressof.md)`(obj)`で、`thunk-ptr`を説明専用の関数`thunk`へのアドレスで初期化する。
@@ -160,3 +171,5 @@ int main()
 ## 参照
 - [P0792R14 `function_ref`: a type-erased callable reference](https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2023/p0792r14.html)
 - [P3774R1 Rename `std::nontype`, and make it broadly useful](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3774r1.html)
+- [P3961R1 Less double indirection in `function_ref` (RU-220)](https://open-std.org/jtc1/sc22/wg21/docs/papers/2026/p3961r1.html)
+    - 別の`function_ref`から構築する際の二重の間接呼び出しを回避するため、説明専用の`is-convertible-from-specialization`を追加し、(2)のコンストラクタの効果を変更した

indirect -- indirect : pImplイディオムへの言及・サンプルコードを追加

2026-06-24T11:35:51+09:00

diff --git a/reference/memory/indirect.md b/reference/memory/indirect.md
index 50bd4fd58..554671804 100644
--- a/reference/memory/indirect.md
+++ b/reference/memory/indirect.md
@@ -31,6 +31,8 @@ namespace std {
 
 これらの性質によって、`std::indirect`クラスのオブジェクトはクラスのメンバとして保持するのに適しており、コンパイラによる特殊メンバ関数の自動生成と協調して動作する。
 
+とくに、pImplイディオム（実装クラスへのポインタをメンバとしてもち、実装詳細をヘッダから隠蔽してソースファイル側で行う手法）の実装に適している。実装クラスを不完全型のまま`std::indirect`型でメンバ変数として保持すると、生のポインタや[`std::unique_ptr`](unique_ptr.md)で実装した場合とは異なり、値のコピー（実装クラスのディープコピー）と`const`の伝播がともに自動的に正しく行われる。
+
 所有オブジェクトを持たない状態を「無効値状態 (valueless state)」と呼ぶ。`std::indirect`オブジェクトが無効値状態になるのは、ムーブ後に空となった場合のみである。無効値状態のオブジェクトに対する`operator*`や`operator->`の呼び出しは未定義動作を引き起こす。無効値状態かどうかは[`valueless_after_move()`](indirect/valueless_after_move.md)メンバ関数で判定できる。
 
 派生型のオブジェクトを多態的に保持したい場合は、[`std::polymorphic`](polymorphic.md)クラスを使用する。
@@ -116,6 +118,7 @@ namespace std {
 
 
 ## 例
+### 基本的な使い方
 ```cpp example
 #include <cassert>
 #include <memory>
@@ -143,6 +146,53 @@ int main()
 ```
 ```
 
+### pImplイディオムでの使用
+実装クラスを不完全型のまま`std::indirect`で保持することで、値の意味論をもつpImplを簡潔に実装できる。コピー・ムーブ・デストラクタはコンパイラが生成し、`const`メンバ関数からは実装クラスにも`const`が伝播する。
+
+```cpp example
+#include <cassert>
+#include <memory>
+
+// ヘッダ相当: 実装クラスImplは前方宣言のみ（不完全型）
+class Widget {
+  class Impl;
+  std::indirect<Impl> impl_;
+public:
+  Widget(int x);
+  int value() const;
+  void set(int x);
+  // コピー・ムーブ・デストラクタはコンパイラが生成する
+};
+
+// 実装相当: ここでImplが完全型になる
+class Widget::Impl {
+public:
+  int v;
+  Impl(int x) : v(x) {}
+};
+
+Widget::Widget(int x) : impl_{std::in_place, x} {}
+int Widget::value() const { return impl_->v; } // constが伝播する
+void Widget::set(int x) { impl_->v = x; }
+
+int main()
+{
+  Widget a{42};
+  assert(a.value() == 42);
+
+  Widget b = a;            // 値のコピー（Implがディープコピーされる）
+  b.set(10);
+  assert(a.value() == 42); // aは影響を受けない
+  assert(b.value() == 10);
+}
+```
+* std::indirect[color ff0000]
+* std::in_place[link /reference/utility/in_place_t.md]
+
+### 出力
+```
+```
+
 
 ## バージョン
 ### 言語

C++26 -- Merge pull request #1661 from cpprefjp/indirect_polymorphic

2026-06-24T10:24:58+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クラスを追加
<utility>に、定数を型として包むことで、関数の引数として渡しても定数式として扱えるようにする定数ラッパーstd::constant_wrapperクラスと、それを簡潔に生成する変数テンプレートstd::cwを追加

デバッグ

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

型特性

<type_traits>に、共用体の指定されたメンバがアクティブかを定数式で判定するための関数としてstd::is_within_lifetime()を追加
<type_traits>に、仮想継承の関係を判定するstd::is_virtual_base_ofを追加
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()
- これらはOS依存のパス名エンコーディングへ変換するため、iostream・std::format()・std::print()を含むほぼすべての標準のテキスト処理・入出力機能と互換性がなく、文字化けやデータ損失の原因になりやすい
- レガシーなシステムAPIにパスを渡す用途では、システム依存エンコーディングへの変換であることを明確にしたsystem_encoded_string()・generic_system_encoded_string()を使用する
- 表示・フォーマットの用途では、display_string()・generic_display_string()、もしくはstd::format()・std::print()を使用する

非推奨の取り消し

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ライブラリ由来のヘッダに以下の変更が入った
- <cstdlib>: free_sized()・free_aligned_sized()・memalignment()・strfromf()・strfromd()・strfroml()を追加。bsearch()にconst版オーバーロードを追加。realloc()にサイズ0を渡した場合がエラー性動作となった
- <ctime>: timespec_getres()・timegm()・gmtime_r()・localtime_r()と、TIME_MONOTONIC・TIME_ACTIVE・TIME_THREAD_ACTIVE・__STDC_VERSION_TIME_H__を追加。asctime()・ctime()を非推奨化
- <cmath>: nextup()・nextdown()を追加
- <cstdio>: _PRINTF_NAN_LEN_MAX・__STDC_VERSION_STDIO_H__を追加
- <cinttypes>: 2進数用の書式指定マクロ (PRIbN・SCNbN等) と__STDC_VERSION_INTTYPES_H__を追加
- <cfloat>: INFINITY・NAN・FLT_SNAN・DBL_SNAN・LDBL_SNAN・__STDC_VERSION_FLOAT_H__を追加。DECIMAL_DIGを非推奨化し、FLT_HAS_SUBNORM・DBL_HAS_SUBNORM・LDBL_HAS_SUBNORMを廃止予定 (obsolescent) とした
- <climits>: 各整数型の幅 (ビット数) を表すBOOL_WIDTH等のマクロを追加
- <cstdint>: 各整数型の幅 (ビット数) を表すINT8_WIDTH等のマクロと、__STDC_VERSION_STDINT_H__を追加
- <cstring>: memccpy()・strdup()・strndup()・memset_explicit()を追加
- <cuchar>: mbrtoc8()・c8rtomb()・__STDC_VERSION_UCHAR_H__を追加
- <cstddef>: unreachableマクロおよび__STDC_VERSION_STDDEF_H__は定義しないことを明記

機能テストマクロ -- Merge pull request #1661 from cpprefjp/indirect_polymorphic

2026-06-24T10:24:58+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`	`202606L`	`<utility>`に`std::constant_wrapper`を追加	`<utility>`
`__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

memory -- Merge pull request #1661 from cpprefjp/indirect_polymorphic

2026-06-24T10:24:58+09:00

memory

<memory>ヘッダでは、メモリアロケータ、未初期化領域に関する関数群、スマートポインタ、アライメントに関するユーティリティ関数といった、メモリを扱うための機能を定義する。

このヘッダでは、以下の標準ヘッダをインクルードする：

<compare> (C++20)

メモリアロケータ

名前	説明	対応バージョン
`allocator`	メモリアロケータの標準実装(class template)
`allocator_traits`	アロケータクラスへの間接的なアクセス(class template)	C++11
`allocation_result`	`allocate_at_least()`関数の戻り値型	C++23
`allocator_arg_t`	アロケータを引数として渡す際の、オーバーロード解決のためのタグ(class)	C++11
`allocator_arg`	アロケータを引数として渡す際の、オーバーロード解決のためのタグ(constant value)	C++11
`uses_allocator`	型`T`がアロケータを使用するか調べる	C++11
`uses_allocator_construction_args`	uses-allocator 構築のためのコンストラクタ引数を `tuple` 型にして返す	C++20
`make_obj_using_allocator`	uses-allocator 構築する	C++20
`uninitialized_construct_using_allocator`	指定された領域に uses-allocator 構築する	C++20

メモリ特化のコンセプト

名前	説明	対応バージョン
`no-throw-input-iterator`	各操作で例外送出をしない説明用の入力イテレータ (concept)	C++20
`no-throw-forward-iterator`	各操作で例外送出をしない説明用の前方向イテレータ (concept)	C++20
`no-throw-sentinel`	各操作で例外送出をしない説明用の番兵 (concept)	C++20
`no-throw-input-range`	各操作で例外送出をしない入力Range (concept)	C++20
`no-throw-forward-range`	各操作で例外送出をしない前方向Range (concept)	C++20

未初期化領域に対する操作

名前	説明	対応バージョン
`uninitialized_default_construct`	未初期化領域の範囲の各要素をデフォルト構築する(function template)	C++17
`uninitialized_default_construct_n`	未初期化領域の範囲のうち、先頭`N`個の要素をデフォルト構築する(function template)	C++17
`uninitialized_value_construct`	未初期化領域の範囲の各要素配置を値構築する(function template)	C++17
`uninitialized_value_construct_n`	未初期化領域の範囲のうち、先頭`N`個の要素を値構築する(function template)	C++17
`uninitialized_copy`	未初期化領域の範囲を配置`new`で初期化してコピー出力する(function template)
`uninitialized_copy_n`	未初期化領域の範囲のうち、先頭`N`個の要素を配置`new`で初期化してコピー出力する(function template)	C++11
`uninitialized_move`	未初期化領域の範囲を配置`new`で初期化してムーブ出力する(function template)
`uninitialized_move_n`	未初期化領域の範囲のうち、先頭`N`個の要素を配置`new`で初期化してムーブ出力する(function template)	C++11
`uninitialized_fill`	未初期化領域の範囲を、指定された値で配置`new`する(function template)
`uninitialized_fill_n`	未初期化領域の範囲のうち、先頭`N`個の要素を指定された値で配置`new`する(function template)
`construct_at`	コンストラクタを呼び出す(function template)	C++20
`destroy_at`	デストラクタを呼び出す(function template)	C++17
`destroy`	範囲の各要素に対してデストラクタを呼び出す(function template)	C++17
`destroy_n`	範囲のうち、先頭`N`個の要素に対してデストラクタを呼び出す(function template)	C++17
`ranges::uninitialized_default_construct`	未初期化領域の範囲の各要素をデフォルト構築する(function template)	C++20
`ranges::uninitialized_default_construct_n`	未初期化領域の範囲のうち、先頭`N`個の要素をデフォルト構築する(function template)	C++20
`ranges::uninitialized_value_construct`	未初期化領域の範囲の各要素配置を値構築する(function template)	C++20
`ranges::uninitialized_value_construct_n`	未初期化領域の範囲のうち、先頭`N`個の要素を値構築する(function template)	C++20
`ranges::uninitialized_copy`	未初期化領域の範囲を配置`new`で初期化してコピー出力する(function template)	C++20
`ranges::uninitialized_copy_n`	未初期化領域の範囲のうち、先頭`N`個の要素を配置`new`で初期化してコピー出力する(function template)	C++20
`ranges::uninitialized_move`	未初期化領域の範囲を配置`new`で初期化してムーブ出力する(function template)	C++20
`ranges::uninitialized_move_n`	未初期化領域の範囲のうち、先頭`N`個の要素を配置`new`で初期化してムーブ出力する(function template)	C++20
`ranges::uninitialized_fill`	未初期化領域の範囲を、指定された値で配置`new`する(function template)	C++20
`ranges::uninitialized_fill_n`	未初期化領域の範囲のうち、先頭`N`個の要素を指定された値で配置`new`する(function template)	C++20
`ranges::construct_at`	コンストラクタを呼び出す(function template)	C++20
`ranges::destroy_at`	デストラクタを呼び出す(function template)	C++20
`ranges::destroy`	範囲の各要素に対してデストラクタを呼び出す(function template)	C++20
`ranges::destroy_n`	範囲のうち、先頭`N`個の要素に対してデストラクタを呼び出す(function template)	C++20
`raw_storage_iterator`	未初期化領域に書き込むための出力イテレータ(class template)	C++17から非推奨 C++20で削除
`get_temporary_buffer`	短期的なメモリ領域を確保する(function template)	C++17から非推奨 C++20で削除
`return_temporary_buffer`	`get_temporary_buffer()`で確保された領域を解放する(function)	C++17から非推奨 C++20で削除

スマートポインタ

名前	説明	対応バージョン
`shared_ptr`	共有方式スマートポインタ(class template)	C++11
`make_shared`	`shared_ptr`を構築するヘルパ関数(function template)	C++11
`make_shared_for_overwrite`	`shared_ptr`を構築するヘルパ関数(function template)	C++20
`allocate_shared`	アロケータを指定して`shared_ptr`を構築するヘルパ関数(function template)	C++11
`allocate_shared_for_overwrite`	アロケータを指定して`shared_ptr`を構築するヘルパ関数(function template)	C++20
`enable_shared_from_this`	`this`を指す`shared_ptr`を可能にする(class template)	C++11
`weak_ptr`	`shared_ptr`のインスタンス監視(class template)	C++11
`bad_weak_ptr`	`weak_ptr`から投げられる例外クラス(class template)	C++11
`owner_less`	所有権ベースの小なり比較(class template)	C++11
`unique_ptr`	専有方式スマートポインタ(class template)	C++11
`make_unique`	`unique_ptr`を構築するヘルパ関数(function template)	C++14
`make_unique_for_overwrite`	`unique_ptr`を構築するヘルパ関数(function template)	C++20
`default_delete`	`unique_ptr`のデフォルトの削除子(class template)	C++11
`auto_ptr`	古い専有方式スマートポインタ(class template)	C++11から非推奨 C++17で削除

スマートポインタアダプタ

名前	説明	対応バージョン
`out_ptr_t`	スマートポインタへの出力サポート(class template)	C++23
`out_ptr`	スマートポインタへの出力サポートヘルパ関数(function template)	C++23
`inout_ptr_t`	スマートポインタへの入出力サポート(class template)	C++23
`inout_ptr`	スマートポインタへの入出力サポートヘルパ関数(function template)	C++23

値の意味論をもつ間接ストレージ

名前	説明	対応バージョン
`indirect`	動的確保したオブジェクトに値の意味論をもたせるクラス(class template)	C++26
`polymorphic`	動的確保したオブジェクトに値の意味論をもたせ、派生型を多態的に保持するクラス(class template)	C++26

スマートポインタのアトミック操作

名前	説明	対応バージョン
`template<class T> struct atomic`	`atomic`クラスの先行宣言 (class template)	C++20
`template<class T> struct atomic<shared_ptr<T>>;`	`atomic`クラスの`shared_ptr`に対する特殊化 (class template)	C++20
`template<class T> struct atomic<weak_ptr<T>>;`	`atomic`クラスの`weak_ptr`に対する特殊化 (class template)	C++20
`atomic_is_lock_free`	`shared_ptr`に対するアトミック操作がロックフリーに振る舞うことができるかを調べる (function template)	C++11 C++20で非推奨
`atomic_load`	`shared_ptr`の値をアトミックに読み込む (function template)	C++11 C++20で非推奨
`atomic_load_explicit`	メモリオーダーを指定して、`shared_ptr`の値をアトミックに読み込む (function template)	C++11 C++20で非推奨
`atomic_store`	`shared_ptr`値をアトミックに書き込む (function template)	C++11 C++20で非推奨
`atomic_store_explicit`	メモリオーダーを指定して、`shared_ptr`の値をアトミックに書き込む (function template)	C++11 C++20で非推奨
`atomic_exchange`	`shared_ptr`の値をアトミックに入れ替える (function template)	C++11 C++20で非推奨
`atomic_exchange_explicit`	メモリオーダーを指定して、`shared_ptr`の値をアトミックに入れ替える (function template)	C++11 C++20で非推奨
`atomic_compare_exchange_weak`	弱い比較で`shared_ptr`の値の入れ替えをアトミックに行う (function template)	C++11 C++20で非推奨
`atomic_compare_exchange_strong`	強い比較で`shared_ptr`の値の入れ替えをアトミックに行う (function template)	C++11 C++20で非推奨
`atomic_compare_exchange_weak_explicit`	弱い比較でメモリオーダーを指定して、`shared_ptr`の値の入れ替えをアトミックに行う (function template)	C++11 C++20で非推奨
`atomic_compare_exchange_strong_explicit`	強い比較でメモリオーダーを指定して、`shared_ptr`の値の入れ替えをアトミックに行う (function template)	C++11 C++20で非推奨

ポインタのユーティリティ

名前	説明	対応バージョン
`pointer_traits`	ポインタの型特性(class template)	C++11
`to_address`	ポインタと見なせるオブジェクトからアドレスを取得する (function template)	C++20
`addressof`	変数のアドレスを必ず取得する(function template)	C++11
`align`	アライメント調整された領域を得る(function)	C++11
`assume_aligned`	コンパイラへアライメントのヒントを与える(function template)	C++20
`is_sufficiently_aligned`	ポインタのアライメントを判定する(function template)	C++26
`start_lifetime_as`	オブジェクトの生存期間を開始することを明示する(function template)	C++23
`start_lifetime_as_array`	配列オブジェクトの生存期間を開始することを明示する(function template)	C++23

ガベージコレクション支援（C++23で削除）

名前	説明	対応バージョン
`pointer_safety`	ポインタ安全性について実装/挙動を示す列挙型(enum class)	C++11 C++23で削除
`get_pointer_safety`	処理系の、ポインタ安全性についての実装/挙動を取得する(function)	C++11 C++23で削除
`declare_reachable`	ポインタが到達可能であることを宣言する(function)	C++11 C++23で削除
`undeclare_reachable`	ポインタが到達可能であるという宣言を削除する(function template)	C++11 C++23で削除
`declare_no_pointers`	指定された範囲のポインタが、追跡可能ではないことを宣言する(function)	C++11 C++23で削除
`undeclare_no_pointers`	`declare_no_pointers`で宣言された範囲を無効化する(function)	C++11 C++23で削除

参照

indirect -- Merge pull request #1661 from cpprefjp/indirect_polymorphic

2026-06-24T10:24:58+09:00

diff --git a/reference/memory/indirect.md b/reference/memory/indirect.md
new file mode 100644
index 000000000..50bd4fd58
--- /dev/null
+++ b/reference/memory/indirect.md
@@ -0,0 +1,165 @@
+# indirect
+* memory[meta header]
+* std[meta namespace]
+* class template[meta id-type]
+* cpp26[meta cpp]
+
+```cpp
+namespace std {
+  template <class T, class Allocator = allocator<T>>
+  class indirect;
+
+  namespace pmr {
+    template <class T>
+    using indirect = std::indirect<T, polymorphic_allocator<T>>;
+  }
+}
+```
+* allocator[link allocator.md]
+* polymorphic_allocator[link /reference/memory_resource/polymorphic_allocator.md]
+
+## 概要
+`std::indirect`クラスは、動的確保したオブジェクトに値の意味論をもたせる型である。
+
+ポインタやスマートポインタは参照の意味論をもつため、クラスのメンバとして使うとコピーや`const`の伝播が正しく行われず、クラスの特殊メンバ関数を正しく生成できないことがある。
+
+`std::indirect`クラスは所有するオブジェクトを動的確保しつつ、以下のように値型として振る舞う：
+
+- ディープコピー: `std::indirect`オブジェクトをコピーすると、所有するオブジェクト`T`がそのコピーコンストラクタによって複製される
+- `const`の伝播: `const`なアクセス経路から所有オブジェクトにアクセスすると、所有オブジェクトにも`const`が伝播する（`operator*`/`operator->`に`const`版と非`const`版がある）
+- 不完全型のサポート: テンプレートパラメータ`T`は不完全型でもよい。これにより、再帰的なデータ構造を表現できる
+
+これらの性質によって、`std::indirect`クラスのオブジェクトはクラスのメンバとして保持するのに適しており、コンパイラによる特殊メンバ関数の自動生成と協調して動作する。
+
+所有オブジェクトを持たない状態を「無効値状態 (valueless state)」と呼ぶ。`std::indirect`オブジェクトが無効値状態になるのは、ムーブ後に空となった場合のみである。無効値状態のオブジェクトに対する`operator*`や`operator->`の呼び出しは未定義動作を引き起こす。無効値状態かどうかは[`valueless_after_move()`](indirect/valueless_after_move.md)メンバ関数で判定できる。
+
+派生型のオブジェクトを多態的に保持したい場合は、[`std::polymorphic`](polymorphic.md)クラスを使用する。
+
+
+## テンプレートパラメータ制約
+- `Allocator`はCpp17Allocator要件を満たすこと
+- [`std::allocator_traits`](/reference/memory/allocator_traits.md)`<Allocator>::value_type`が`T`と同じ型であること
+
+
+## 適格要件
+- 以下のいずれかの場合に、プログラムは不適格となる
+    - `T`がオブジェクト型でない
+    - 配列型である
+    - (CV修飾された) [`std::in_place_t`](/reference/utility/in_place_t.md)である
+    - (CV修飾された) [`std::in_place_type_t`](/reference/utility/in_place_type_t.md)の特殊化である
+- `std::indirect`の明示的特殊化・部分特殊化をユーザーが宣言した場合、動作は未定義である
+
+
+## メンバ関数
+### 構築・破棄
+
+| 名前 | 説明 | 対応バージョン |
+|------|------|----------------|
+| [`(constructor)`](indirect/op_constructor.md) | コンストラクタ | C++26 |
+| [`(destructor)`](indirect/op_destructor.md) | デストラクタ | C++26 |
+| [`operator=`](indirect/op_assign.md) | 代入演算子 | C++26 |
+
+### 値へのアクセス
+
+| 名前 | 説明 | 対応バージョン |
+|------|------|----------------|
+| [`operator*`](indirect/op_deref.md) | 所有するオブジェクトへの参照を取得する | C++26 |
+| [`operator->`](indirect/op_arrow.md) | 所有するオブジェクトのメンバへアクセスする | C++26 |
+| [`valueless_after_move`](indirect/valueless_after_move.md) | 無効値状態かどうかを判定する | C++26 |
+
+### その他
+
+| 名前 | 説明 | 対応バージョン |
+|------|------|----------------|
+| [`get_allocator`](indirect/get_allocator.md) | アロケータを取得する | C++26 |
+| [`swap`](indirect/swap.md) | 他の`indirect`オブジェクトと値を交換する | C++26 |
+
+
+## メンバ型
+
+| 名前 | 定義 | 対応バージョン |
+|------|------|----------------|
+| `value_type` | `T` | C++26 |
+| `allocator_type` | `Allocator` | C++26 |
+| `pointer` | [`allocator_traits`](/reference/memory/allocator_traits.md)`<Allocator>::pointer` | C++26 |
+| `const_pointer` | [`allocator_traits`](/reference/memory/allocator_traits.md)`<Allocator>::const_pointer` | C++26 |
+
+
+## 非メンバ（*Hidden friends*）関数
+
+| 名前 | 説明 | 対応バージョン |
+|------|------|----------------|
+| [`swap`](indirect/swap_free.md) | 2つの`indirect`オブジェクトを交換する | C++26 |
+
+### 比較演算子
+
+| 名前 | 説明 | 対応バージョン |
+|------|------|----------------|
+| [`operator==`](indirect/op_equal.md) | 等値比較を行う | C++26 |
+| [`operator<=>`](indirect/op_compare_3way.md) | 三方比較を行う | C++26 |
+
+`operator==`から`operator!=`が、`operator<=>`から`operator<` / `operator<=` / `operator>` / `operator>=`が導出される。
+
+
+## 推論補助
+
+| 名前 | 説明 | 対応バージョン |
+|------|------|----------------|
+| [`(deduction_guide)`](indirect/op_deduction_guide.md) | クラステンプレートの推論補助 | C++26 |
+
+
+## ハッシュサポート
+
+| 名前 | 説明 | 対応バージョン |
+|------|------|----------------|
+| [`hash`](indirect/hash.md) | `hash`クラスの特殊化 | C++26 |
+
+
+## 例
+```cpp example
+#include <cassert>
+#include <memory>
+
+int main()
+{
+  // 動的確保したintを、値の意味論で保持する
+  std::indirect<int> a{42};
+  assert(*a == 42);
+
+  // コピーは所有オブジェクトのディープコピー
+  std::indirect<int> b = a;
+  *b = 10;
+  assert(*a == 42); // aは影響を受けない
+  assert(*b == 10);
+
+  // 比較は所有オブジェクトの比較に転送される
+  assert(a == std::indirect<int>{42});
+  assert(b < a);
+}
+```
+* std::indirect[color ff0000]
+
+### 出力
+```
+```
+
+
+## バージョン
+### 言語
+- C++26
+
+### 処理系
+- [Clang](/implementation.md#clang): 22 [mark noimpl]
+- [GCC](/implementation.md#gcc): 16.1 [mark verified]
+- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl]
+
+
+## 関連項目
+- [`std::polymorphic`](polymorphic.md) 派生型を多態的に保持する値型
+- [`std::unique_ptr`](unique_ptr.md) 所有権をもつが参照の意味論をもつスマートポインタ
+- [`std::optional`](/reference/optional/optional.md) 動的確保せずに無効値状態を表現する型
+
+
+## 参照
+- [P3019R14 `indirect` and `polymorphic`: Vocabulary Types for Composite Class Design](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3019r14.pdf)
+    - C++26で`indirect`と`polymorphic`が追加された

get_allocator -- Merge pull request #1661 from cpprefjp/indirect_polymorphic

2026-06-24T10:24:58+09:00

diff --git a/reference/memory/indirect/get_allocator.md b/reference/memory/indirect/get_allocator.md
new file mode 100644
index 000000000..f51c173bc
--- /dev/null
+++ b/reference/memory/indirect/get_allocator.md
@@ -0,0 +1,39 @@
+# get_allocator
+* memory[meta header]
+* std[meta namespace]
+* indirect[meta class]
+* function[meta id-type]
+* cpp26[meta cpp]
+
+```cpp
+constexpr allocator_type get_allocator() const noexcept;
+```
+
+## 概要
+このオブジェクトが使用するアロケータを取得する。
+
+
+## 戻り値
+所有するアロケータのコピー。
+
+
+## 例外
+投げない。
+
+
+## バージョン
+### 言語
+- C++26
+
+### 処理系
+- [Clang](/implementation.md#clang): 22 [mark noimpl]
+- [GCC](/implementation.md#gcc): 16.1 [mark verified]
+- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl]
+
+
+## 関連項目
+- [`std::indirect`](../indirect.md)
+
+
+## 参照
+- [P3019R14 `indirect` and `polymorphic`: Vocabulary Types for Composite Class Design](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3019r14.pdf)

hash -- Merge pull request #1661 from cpprefjp/indirect_polymorphic

2026-06-24T10:24:58+09:00

diff --git a/reference/memory/indirect/hash.md b/reference/memory/indirect/hash.md
new file mode 100644
index 000000000..6aa893188
--- /dev/null
+++ b/reference/memory/indirect/hash.md
@@ -0,0 +1,66 @@
+# hash
+* memory[meta header]
+* std[meta namespace]
+* indirect[meta class]
+* class template[meta id-type]
+* cpp26[meta cpp]
+
+```cpp
+namespace std {
+  template <class T, class Allocator>
+  struct hash<indirect<T, Allocator>>;
+}
+```
+* hash[link /reference/functional/hash.md]
+
+## 概要
+[`std::hash`](/reference/functional/hash.md)クラスの、`std::indirect`に対する特殊化。
+
+この特殊化は、`hash<T>`が有効である場合にのみ有効となる。
+
+
+## 効果
+`indirect<T, Allocator>`型のオブジェクト`i`に対して、`hash<indirect<T, Allocator>>()(i)`は、`i`が無効値状態でなければ`hash<T>()(*i)`と同じ値を返し、無効値状態であれば処理系定義の値を返す。
+
+
+## 備考
+メンバ関数が`noexcept`である保証はない。
+
+
+## 例
+```cpp example
+#include <cassert>
+#include <functional>
+#include <memory>
+
+int main()
+{
+  std::indirect<int> a{42};
+  // 所有する値のハッシュ値と一致する
+  assert((std::hash<std::indirect<int>>{}(a) == std::hash<int>{}(42)));
+}
+```
+* std::indirect[color ff0000]
+* std::hash[link /reference/functional/hash.md]
+
+### 出力
+```
+```
+
+
+## バージョン
+### 言語
+- C++26
+
+### 処理系
+- [Clang](/implementation.md#clang): 22 [mark noimpl]
+- [GCC](/implementation.md#gcc): 16.1 [mark verified]
+- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl]
+
+
+## 関連項目
+- [`std::indirect`](../indirect.md)
+
+
+## 参照
+- [P3019R14 `indirect` and `polymorphic`: Vocabulary Types for Composite Class Design](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3019r14.pdf)

operator-> -- Merge pull request #1661 from cpprefjp/indirect_polymorphic

2026-06-24T10:24:58+09:00

diff --git a/reference/memory/indirect/op_arrow.md b/reference/memory/indirect/op_arrow.md
new file mode 100644
index 000000000..a04a30351
--- /dev/null
+++ b/reference/memory/indirect/op_arrow.md
@@ -0,0 +1,65 @@
+# operator->
+* memory[meta header]
+* std[meta namespace]
+* indirect[meta class]
+* function[meta id-type]
+* cpp26[meta cpp]
+
+```cpp
+constexpr const_pointer operator->() const noexcept; // (1)
+constexpr pointer operator->() noexcept;             // (2)
+```
+
+## 概要
+所有するオブジェクトのメンバへアクセスするためのポインタを取得する。
+
+
+## 事前条件
+`*this`が無効値状態でないこと。
+
+
+## 戻り値
+所有するオブジェクトを指すポインタ。
+
+
+## 例外
+投げない。
+
+
+## 例
+```cpp example
+#include <cassert>
+#include <memory>
+#include <string>
+
+int main()
+{
+  std::indirect<std::string> s{std::string{"hello"}};
+  assert(s->size() == 5);  // 所有するstringのメンバにアクセス
+  s->push_back('!');
+  assert(*s == "hello!");
+}
+```
+* std::indirect[color ff0000]
+
+### 出力
+```
+```
+
+
+## バージョン
+### 言語
+- C++26
+
+### 処理系
+- [Clang](/implementation.md#clang): 22 [mark noimpl]
+- [GCC](/implementation.md#gcc): 16.1 [mark verified]
+- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl]
+
+
+## 関連項目
+- [`std::indirect`](../indirect.md)
+
+
+## 参照
+- [P3019R14 `indirect` and `polymorphic`: Vocabulary Types for Composite Class Design](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3019r14.pdf)

代入演算子 -- Merge pull request #1661 from cpprefjp/indirect_polymorphic

2026-06-24T10:24:58+09:00

diff --git a/reference/memory/indirect/op_assign.md b/reference/memory/indirect/op_assign.md
new file mode 100644
index 000000000..7048d1eda
--- /dev/null
+++ b/reference/memory/indirect/op_assign.md
@@ -0,0 +1,97 @@
+# 代入演算子
+* memory[meta header]
+* std[meta namespace]
+* indirect[meta class]
+* function[meta id-type]
+* cpp26[meta cpp]
+
+```cpp
+constexpr indirect& operator=(const indirect& other);              // (1)
+constexpr indirect& operator=(indirect&& other) noexcept(see below); // (2)
+template <class U = T>
+constexpr indirect& operator=(U&& u);                              // (3)
+```
+
+## 概要
+- (1) : コピー代入。`other`が所有するオブジェクトをディープコピーする。
+- (2) : ムーブ代入。`other`から所有権を移す。
+- (3) : 所有するオブジェクトに値`u`を代入する。
+
+
+## テンプレートパラメータ制約
+- (3) : [`remove_cvref_t`](/reference/type_traits/remove_cvref.md)`<U>`が`indirect`でなく、[`is_constructible_v`](/reference/type_traits/is_constructible.md)`<T, U>`と[`is_assignable_v`](/reference/type_traits/is_assignable.md)`<T&, U>`がともに`true`であること。
+
+
+## 適格要件
+- (1) : [`is_copy_assignable_v`](/reference/type_traits/is_copy_assignable.md)`<T>`と[`is_copy_constructible_v`](/reference/type_traits/is_copy_constructible.md)`<T>`がともに`true`であること。
+- (2) : [`is_copy_constructible_v`](/reference/type_traits/is_copy_constructible.md)`<T>`が`true`であること。
+
+
+## 効果
+- (1) : `other`が無効値状態であれば`*this`も無効値状態にする。そうでなければ、アロケータの伝播規則に従い、`other`が所有するオブジェクトのコピーを`*this`がもつようにする。
+- (2) : `other`が無効値状態であれば`*this`も無効値状態にする。そうでなければ、所有権を移すかムーブ構築する。`other`は無効値状態となる。
+- (3) : `*this`が無効値状態であれば`u`から`T`を構築して所有する。そうでなければ`**this = std::forward<U>(u)`と等価。
+
+
+## 戻り値
+`*this`への参照。
+
+
+## 例外
+- (1) : 強い例外安全性を保証する。例外が送出された場合、[`this->valueless_after_move()`](valueless_after_move.md)の結果は変化しない。
+- (2) : 以下と等価な`noexcept`指定を持つ：
+```cpp
+noexcept(allocator_traits<Allocator>::propagate_on_container_move_assignment::value ||
+         allocator_traits<Allocator>::is_always_equal::value)
+```
+* allocator_traits[link /reference/memory/allocator_traits.md]
+
+
+## 例
+```cpp example
+#include <cassert>
+#include <memory>
+
+int main()
+{
+  std::indirect<int> a{1};
+  std::indirect<int> b{2};
+
+  a = b;                  // (1) コピー代入（ディープコピー）
+  assert(*a == 2);
+  *a = 3;
+  assert(*b == 2);        // bは影響を受けない
+
+  a = 10;                 // (3) 値の代入
+  assert(*a == 10);
+
+  a = std::move(b);       // (2) ムーブ代入
+  assert(*a == 2);
+  assert(b.valueless_after_move());
+}
+```
+* std::indirect[color ff0000]
+* std::move[link /reference/utility/move.md]
+* valueless_after_move[link valueless_after_move.md]
+
+### 出力
+```
+```
+
+
+## バージョン
+### 言語
+- C++26
+
+### 処理系
+- [Clang](/implementation.md#clang): 22 [mark noimpl]
+- [GCC](/implementation.md#gcc): 16.1 [mark verified]
+- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl]
+
+
+## 関連項目
+- [`std::indirect`](../indirect.md)
+
+
+## 参照
+- [P3019R14 `indirect` and `polymorphic`: Vocabulary Types for Composite Class Design](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3019r14.pdf)

operator<=> -- Merge pull request #1661 from cpprefjp/indirect_polymorphic

2026-06-24T10:24:58+09:00

diff --git a/reference/memory/indirect/op_compare_3way.md b/reference/memory/indirect/op_compare_3way.md
new file mode 100644
index 000000000..021ff8c0d
--- /dev/null
+++ b/reference/memory/indirect/op_compare_3way.md
@@ -0,0 +1,72 @@
+# operator<=>
+* memory[meta header]
+* std[meta namespace]
+* indirect[meta class]
+* function[meta id-type]
+* cpp26[meta cpp]
+
+```cpp
+template <class U, class AA>
+friend constexpr auto operator<=>(
+  const indirect& lhs, const indirect<U, AA>& rhs)
+    -> synth-three-way-result<T, U>; // (1)
+
+template <class U>
+friend constexpr auto operator<=>(
+  const indirect& lhs, const U& rhs)
+    -> synth-three-way-result<T, U>; // (2)
+```
+
+## 概要
+- (1) : 2つの`indirect`オブジェクトが所有する値を三方比較する。
+- (2) : `indirect`オブジェクトが所有する値と、別の値`rhs`を三方比較する。
+
+いずれも*Hidden friends*として定義される。
+
+
+## 戻り値
+- (1) : `lhs`と`rhs`のいずれかが無効値状態であれば`!lhs.valueless_after_move() <=> !rhs.valueless_after_move()`、そうでなければ`synth-three-way(*lhs, *rhs)`。
+- (2) : `lhs`が無効値状態であれば[`std::strong_ordering::less`](/reference/compare/strong_ordering.md)、そうでなければ`synth-three-way(*lhs, rhs)`。
+
+
+## 備考
+この演算子により、`operator<` / `operator<=` / `operator>` / `operator>=`が使用可能になる。
+
+
+## 例
+```cpp example
+#include <cassert>
+#include <memory>
+
+int main()
+{
+  std::indirect<int> a{1};
+  std::indirect<int> b{2};
+  assert(a < b);          // (1) indirect同士の比較
+  assert((a <=> b) < 0);
+  assert(a < 2);          // (2) 値との比較
+}
+```
+* std::indirect[color ff0000]
+
+### 出力
+```
+```
+
+
+## バージョン
+### 言語
+- C++26
+
+### 処理系
+- [Clang](/implementation.md#clang): 22 [mark noimpl]
+- [GCC](/implementation.md#gcc): 16.1 [mark verified]
+- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl]
+
+
+## 関連項目
+- [`std::indirect`](../indirect.md)
+
+
+## 参照
+- [P3019R14 `indirect` and `polymorphic`: Vocabulary Types for Composite Class Design](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3019r14.pdf)

コンストラクタ -- Merge pull request #1661 from cpprefjp/indirect_polymorphic

2026-06-24T10:24:58+09:00

diff --git a/reference/memory/indirect/op_constructor.md b/reference/memory/indirect/op_constructor.md
new file mode 100644
index 000000000..756c50dc8
--- /dev/null
+++ b/reference/memory/indirect/op_constructor.md
@@ -0,0 +1,156 @@
+# コンストラクタ
+* memory[meta header]
+* std[meta namespace]
+* indirect[meta class]
+* function[meta id-type]
+* cpp26[meta cpp]
+
+```cpp
+explicit constexpr
+  indirect();                          // (1)
+
+explicit constexpr
+  indirect(allocator_arg_t,
+           const Allocator& a);        // (2)
+
+constexpr
+  indirect(const indirect& other);     // (3)
+
+constexpr
+  indirect(allocator_arg_t,
+           const Allocator& a,
+           const indirect& other);     // (4)
+
+constexpr
+  indirect(indirect&& other) noexcept; // (5)
+
+constexpr
+  indirect(allocator_arg_t,
+           const Allocator& a,
+           indirect&& other) noexcept(see below); // (6)
+
+template <class U = T>
+explicit constexpr
+  indirect(U&& u);                     // (7)
+
+template <class U = T>
+explicit constexpr
+  indirect(allocator_arg_t,
+           const Allocator& a, U&& u); // (8)
+
+template <class... Us>
+explicit constexpr
+  indirect(in_place_t,
+           Us&&... us);                // (9)
+
+template <class... Us>
+explicit constexpr
+  indirect(allocator_arg_t,
+           const Allocator& a,
+           in_place_t,
+           Us&&... us);                // (10)
+
+template <class I, class... Us>
+explicit constexpr
+  indirect(in_place_t,
+           initializer_list<I> ilist,
+           Us&&... us);                // (11)
+
+template <class I, class... Us>
+explicit constexpr
+  indirect(allocator_arg_t,
+           const Allocator& a,
+           in_place_t,
+           initializer_list<I> ilist,
+           Us&&... us);                // (12)
+```
+* allocator_arg_t[link /reference/memory/allocator_arg_t.md]
+* in_place_t[link /reference/utility/in_place_t.md]
+* initializer_list[link /reference/initializer_list/initializer_list.md]
+
+## 概要
+`indirect`オブジェクトを構築する。`allocator_arg_t`を第1引数に取るオーバーロードは、使用するアロケータ`a`を明示的に指定する。
+
+- (1), (2) : デフォルトコンストラクタ。`T`をデフォルト構築して所有する。
+- (3), (4) : コピーコンストラクタ。`other`が所有するオブジェクトをディープコピーして所有する。`other`が無効値状態の場合、構築されるオブジェクトも無効値状態となる。
+- (5), (6) : ムーブコンストラクタ。`other`が所有するオブジェクトの所有権を移す。ムーブ後の`other`は無効値状態となる。
+- (7), (8) : 単一の引数`u`から`T`を構築して所有する。
+- (9), (10) : `in_place_t`をマーカーとして、引数`us...`から`T`を直接構築して所有する。
+- (11), (12) : `in_place_t`をマーカーとして、初期化子リストと引数`us...`から`T`を直接構築して所有する。
+
+
+## テンプレートパラメータ制約
+- (7), (8) : [`remove_cvref_t`](/reference/type_traits/remove_cvref.md)`<U>`が`indirect`でも`in_place_t`でもなく、かつ[`is_constructible_v`](/reference/type_traits/is_constructible.md)`<T, U>`が`true`であること。(7)はさらに[`is_default_constructible_v`](/reference/type_traits/is_default_constructible.md)`<Allocator>`が`true`であること。
+- (9), (10) : [`is_constructible_v`](/reference/type_traits/is_constructible.md)`<T, Us...>`が`true`であること。(9)はさらに[`is_default_constructible_v`](/reference/type_traits/is_default_constructible.md)`<Allocator>`が`true`であること。
+- (11), (12) : [`is_constructible_v`](/reference/type_traits/is_constructible.md)`<T, initializer_list<I>&, Us...>`が`true`であること。(11)はさらに[`is_default_constructible_v`](/reference/type_traits/is_default_constructible.md)`<Allocator>`が`true`であること。
+
+
+## 適格要件
+- (1), (2) : [`is_default_constructible_v`](/reference/type_traits/is_default_constructible.md)`<T>`が`true`であること。
+- (3), (4) : [`is_copy_constructible_v`](/reference/type_traits/is_copy_constructible.md)`<T>`が`true`であること。
+- (6) : [`allocator_traits`](/reference/memory/allocator_traits.md)`<Allocator>::is_always_equal::value`が`false`の場合、`T`が完全型であること。
+
+
+## 例外
+- すべてのオーバーロード : [`allocator_traits`](/reference/memory/allocator_traits.md)`<Allocator>::allocate()`または[`allocator_traits`](/reference/memory/allocator_traits.md)`<Allocator>::construct()`が例外を送出した場合を除いて、例外を送出しない。
+- (6) : 以下と等価な`noexcept`指定を持つ：
+```cpp
+noexcept(allocator_traits<Allocator>::is_always_equal::value)
+```
+* allocator_traits[link /reference/memory/allocator_traits.md]
+
+
+## 事後条件
+- (5), (6) : `other`は無効値状態となる。
+
+
+## 例
+```cpp example
+#include <cassert>
+#include <memory>
+#include <string>
+#include <utility>
+
+int main()
+{
+  std::indirect<int> a;                          // (1) デフォルト構築
+  assert(*a == 0);
+
+  std::indirect<int> b{42};                       // (7) 単一の引数から構築
+  assert(*b == 42);
+
+  std::indirect<std::string> c{std::in_place, 3, 'x'}; // (9) in_placeで直接構築
+  assert(*c == "xxx");
+
+  std::indirect<int> d = b;                       // (3) コピー構築（ディープコピー）
+  assert(*d == 42);
+
+  std::indirect<int> e = std::move(d);            // (5) ムーブ構築
+  assert(*e == 42);
+  assert(d.valueless_after_move());               // ムーブ後は無効値状態
+}
+```
+* std::indirect[color ff0000]
+* std::in_place[link /reference/utility/in_place_t.md]
+
+### 出力
+```
+```
+
+
+## バージョン
+### 言語
+- C++26
+
+### 処理系
+- [Clang](/implementation.md#clang): 22 [mark noimpl]
+- [GCC](/implementation.md#gcc): 16.1 [mark verified]
+- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl]
+
+
+## 関連項目
+- [`std::indirect`](../indirect.md)
+
+
+## 参照
+- [P3019R14 `indirect` and `polymorphic`: Vocabulary Types for Composite Class Design](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3019r14.pdf)

推論補助 -- Merge pull request #1661 from cpprefjp/indirect_polymorphic

2026-06-24T10:24:58+09:00

diff --git a/reference/memory/indirect/op_deduction_guide.md b/reference/memory/indirect/op_deduction_guide.md
new file mode 100644
index 000000000..e1544a47b
--- /dev/null
+++ b/reference/memory/indirect/op_deduction_guide.md
@@ -0,0 +1,59 @@
+# 推論補助
+* memory[meta header]
+* std[meta namespace]
+* indirect[meta class]
+* function[meta id-type]
+* cpp26[meta cpp]
+
+```cpp
+template <class Value>
+indirect(Value) -> indirect<Value>; // (1)
+
+template <class Allocator, class Value>
+indirect(allocator_arg_t, Allocator, Value)
+  -> indirect<Value,
+       typename allocator_traits<Allocator>::template rebind_alloc<Value>>; // (2)
+```
+* allocator_arg_t[link /reference/memory/allocator_arg_t.md]
+
+## 概要
+`std::indirect`クラステンプレートの型推論を補助する。
+
+- (1) : 単一の値から`indirect`を構築する場合、その値の型を`T`として推論する。
+- (2) : アロケータと値から構築する場合、値の型を`T`とし、アロケータを`Value`向けに`rebind`した型を`Allocator`として推論する。
+
+
+## 例
+```cpp example
+#include <memory>
+#include <type_traits>
+
+int main()
+{
+  std::indirect a{42};
+  static_assert(std::is_same_v<decltype(a), std::indirect<int>>);
+}
+```
+* std::indirect[color ff0000]
+
+### 出力
+```
+```
+
+
+## バージョン
+### 言語
+- C++26
+
+### 処理系
+- [Clang](/implementation.md#clang): 22 [mark noimpl]
+- [GCC](/implementation.md#gcc): 16.1 [mark verified]
+- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl]
+
+
+## 関連項目
+- [`std::indirect`](../indirect.md)
+
+
+## 参照
+- [P3019R14 `indirect` and `polymorphic`: Vocabulary Types for Composite Class Design](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3019r14.pdf)

operator* -- Merge pull request #1661 from cpprefjp/indirect_polymorphic

2026-06-24T10:24:58+09:00

diff --git a/reference/memory/indirect/op_deref.md b/reference/memory/indirect/op_deref.md
new file mode 100644
index 000000000..ef08fcf8a
--- /dev/null
+++ b/reference/memory/indirect/op_deref.md
@@ -0,0 +1,72 @@
+# operator*
+* memory[meta header]
+* std[meta namespace]
+* indirect[meta class]
+* function[meta id-type]
+* cpp26[meta cpp]
+
+```cpp
+constexpr const T& operator*() const & noexcept;   // (1)
+constexpr T& operator*() & noexcept;               // (2)
+constexpr const T&& operator*() const && noexcept; // (3)
+constexpr T&& operator*() && noexcept;             // (4)
+```
+
+## 概要
+所有するオブジェクトへの参照を取得する。`const`なアクセス経路では`const`が所有オブジェクトに伝播する。
+
+
+## 事前条件
+`*this`が無効値状態でないこと。
+
+
+## 戻り値
+- (1), (2) : 所有するオブジェクトへの参照。
+- (3), (4) : 所有するオブジェクトへの右辺値参照（`std::move(*p)`）。
+
+
+## 例外
+投げない。
+
+
+## 例
+```cpp example
+#include <cassert>
+#include <memory>
+#include <type_traits>
+
+int main()
+{
+  std::indirect<int> a{42};
+  assert(*a == 42);       // 参照の取得
+  *a = 10;                // 非const版で書き換え
+  assert(*a == 10);
+
+  // constなアクセス経路ではconstが伝播する
+  const std::indirect<int> b{5};
+  static_assert(std::is_same_v<decltype(*b), const int&>);
+}
+```
+* std::indirect[color ff0000]
+
+### 出力
+```
+```
+
+
+## バージョン
+### 言語
+- C++26
+
+### 処理系
+- [Clang](/implementation.md#clang): 22 [mark noimpl]
+- [GCC](/implementation.md#gcc): 16.1 [mark verified]
+- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl]
+
+
+## 関連項目
+- [`std::indirect`](../indirect.md)
+
+
+## 参照
+- [P3019R14 `indirect` and `polymorphic`: Vocabulary Types for Composite Class Design](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3019r14.pdf)

デストラクタ -- Merge pull request #1661 from cpprefjp/indirect_polymorphic

2026-06-24T10:24:58+09:00

diff --git a/reference/memory/indirect/op_destructor.md b/reference/memory/indirect/op_destructor.md
new file mode 100644
index 000000000..4769f7624
--- /dev/null
+++ b/reference/memory/indirect/op_destructor.md
@@ -0,0 +1,39 @@
+# デストラクタ
+* memory[meta header]
+* std[meta namespace]
+* indirect[meta class]
+* function[meta id-type]
+* cpp26[meta cpp]
+
+```cpp
+constexpr ~indirect();
+```
+
+## 概要
+`indirect`オブジェクトを破棄する。
+
+
+## 適格要件
+`T`は完全型であること。
+
+
+## 効果
+`*this`が無効値状態でなければ、所有するオブジェクトを[`allocator_traits`](/reference/memory/allocator_traits.md)`<Allocator>::destroy`で破棄し、ストレージを解放する。
+
+
+## バージョン
+### 言語
+- C++26
+
+### 処理系
+- [Clang](/implementation.md#clang): 22 [mark noimpl]
+- [GCC](/implementation.md#gcc): 16.1 [mark verified]
+- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl]
+
+
+## 関連項目
+- [`std::indirect`](../indirect.md)
+
+
+## 参照
+- [P3019R14 `indirect` and `polymorphic`: Vocabulary Types for Composite Class Design](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3019r14.pdf)

operator== -- Merge pull request #1661 from cpprefjp/indirect_polymorphic

2026-06-24T10:24:58+09:00

diff --git a/reference/memory/indirect/op_equal.md b/reference/memory/indirect/op_equal.md
new file mode 100644
index 000000000..91417707f
--- /dev/null
+++ b/reference/memory/indirect/op_equal.md
@@ -0,0 +1,75 @@
+# operator==
+* memory[meta header]
+* std[meta namespace]
+* indirect[meta class]
+* function[meta id-type]
+* cpp26[meta cpp]
+
+```cpp
+template <class U, class AA>
+friend constexpr bool operator==(
+  const indirect& lhs, const indirect<U, AA>& rhs) noexcept(see below); // (1)
+
+template <class U>
+friend constexpr bool operator==(
+  const indirect& lhs, const U& rhs) noexcept(see below);               // (2)
+```
+
+## 概要
+- (1) : 2つの`indirect`オブジェクトが所有する値を等値比較する。
+- (2) : `indirect`オブジェクトが所有する値と、別の値`rhs`を等値比較する。
+
+いずれも*Hidden friends*として定義される。
+
+
+## 適格要件
+- (1) : 式`*lhs == *rhs`が適格であり、その結果が`bool`に変換可能であること。
+- (2) : 式`*lhs == rhs`が適格であり、その結果が`bool`に変換可能であること。
+
+
+## 戻り値
+- (1) : `lhs`と`rhs`のいずれかが無効値状態であれば`lhs.valueless_after_move() == rhs.valueless_after_move()`、そうでなければ`*lhs == *rhs`。
+- (2) : `lhs`が無効値状態であれば`false`、そうでなければ`*lhs == rhs`。
+
+
+## 備考
+この演算子により、`operator!=`が使用可能になる。
+
+
+## 例
+```cpp example
+#include <cassert>
+#include <memory>
+
+int main()
+{
+  std::indirect<int> a{42};
+  std::indirect<int> b{42};
+  assert(a == b);    // (1) indirect同士の比較
+  assert(a == 42);   // (2) 値との比較
+  assert(a != 0);
+}
+```
+* std::indirect[color ff0000]
+
+### 出力
+```
+```
+
+
+## バージョン
+### 言語
+- C++26
+
+### 処理系
+- [Clang](/implementation.md#clang): 22 [mark noimpl]
+- [GCC](/implementation.md#gcc): 16.1 [mark verified]
+- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl]
+
+
+## 関連項目
+- [`std::indirect`](../indirect.md)
+
+
+## 参照
+- [P3019R14 `indirect` and `polymorphic`: Vocabulary Types for Composite Class Design](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3019r14.pdf)

swap -- Merge pull request #1661 from cpprefjp/indirect_polymorphic

2026-06-24T10:24:58+09:00

diff --git a/reference/memory/indirect/swap.md b/reference/memory/indirect/swap.md
new file mode 100644
index 000000000..f48250199
--- /dev/null
+++ b/reference/memory/indirect/swap.md
@@ -0,0 +1,69 @@
+# swap
+* memory[meta header]
+* std[meta namespace]
+* indirect[meta class]
+* function[meta id-type]
+* cpp26[meta cpp]
+
+```cpp
+constexpr void swap(indirect& other) noexcept(see below);
+```
+
+## 概要
+`*this`と`other`の状態を交換する。所有オブジェクトまたは無効値状態を交換する。
+
+
+## 事前条件
+[`allocator_traits`](/reference/memory/allocator_traits.md)`<Allocator>::propagate_on_container_swap::value`が`true`の場合、`Allocator`はCpp17Swappable要件を満たすこと。そうでない場合、`get_allocator() == other.get_allocator()`が`true`であること。
+
+
+## 効果
+`*this`と`other`の状態（所有オブジェクトまたは無効値状態）を交換する。`propagate_on_container_swap::value`が`true`の場合はアロケータも交換する。所有オブジェクトに対して直接`swap`を呼ぶわけではない。
+
+
+## 例外
+以下と等価な`noexcept`指定を持つ：
+
+```cpp
+noexcept(allocator_traits<Allocator>::propagate_on_container_swap::value ||
+         allocator_traits<Allocator>::is_always_equal::value)
+```
+* allocator_traits[link /reference/memory/allocator_traits.md]
+
+
+## 例
+```cpp example
+#include <cassert>
+#include <memory>
+
+int main()
+{
+  std::indirect<int> a{1};
+  std::indirect<int> b{2};
+  a.swap(b);
+  assert(*a == 2 && *b == 1);
+}
+```
+* std::indirect[color ff0000]
+
+### 出力
+```
+```
+
+
+## バージョン
+### 言語
+- C++26
+
+### 処理系
+- [Clang](/implementation.md#clang): 22 [mark noimpl]
+- [GCC](/implementation.md#gcc): 16.1 [mark verified]
+- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl]
+
+
+## 関連項目
+- [`std::indirect`](../indirect.md)
+
+
+## 参照
+- [P3019R14 `indirect` and `polymorphic`: Vocabulary Types for Composite Class Design](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3019r14.pdf)

swap -- Merge pull request #1661 from cpprefjp/indirect_polymorphic

2026-06-24T10:24:58+09:00

diff --git a/reference/memory/indirect/swap_free.md b/reference/memory/indirect/swap_free.md
new file mode 100644
index 000000000..b85df0bd7
--- /dev/null
+++ b/reference/memory/indirect/swap_free.md
@@ -0,0 +1,63 @@
+# swap
+* memory[meta header]
+* std[meta namespace]
+* indirect[meta class]
+* function[meta id-type]
+* cpp26[meta cpp]
+
+```cpp
+friend constexpr void swap(indirect& lhs, indirect& rhs) noexcept(see below);
+```
+
+## 概要
+2つの`indirect`オブジェクトを交換する。*Hidden friends*として定義される。
+
+
+## 効果
+`lhs.swap(rhs)`と等価。
+
+
+## 例外
+以下と等価な`noexcept`指定を持つ：
+
+```cpp
+noexcept(noexcept(lhs.swap(rhs)))
+```
+
+
+## 例
+```cpp example
+#include <cassert>
+#include <memory>
+
+int main()
+{
+  std::indirect<int> a{1};
+  std::indirect<int> b{2};
+  swap(a, b);   // ADLにより非メンバswapが呼ばれる
+  assert(*a == 2 && *b == 1);
+}
+```
+* std::indirect[color ff0000]
+
+### 出力
+```
+```
+
+
+## バージョン
+### 言語
+- C++26
+
+### 処理系
+- [Clang](/implementation.md#clang): 22 [mark noimpl]
+- [GCC](/implementation.md#gcc): 16.1 [mark verified]
+- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl]
+
+
+## 関連項目
+- [`std::indirect`](../indirect.md)
+
+
+## 参照
+- [P3019R14 `indirect` and `polymorphic`: Vocabulary Types for Composite Class Design](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3019r14.pdf)

valueless_after_move -- Merge pull request #1661 from cpprefjp/indirect_polymorphic

2026-06-24T10:24:58+09:00

diff --git a/reference/memory/indirect/valueless_after_move.md b/reference/memory/indirect/valueless_after_move.md
new file mode 100644
index 000000000..f866a5a8e
--- /dev/null
+++ b/reference/memory/indirect/valueless_after_move.md
@@ -0,0 +1,61 @@
+# valueless_after_move
+* memory[meta header]
+* std[meta namespace]
+* indirect[meta class]
+* function[meta id-type]
+* cpp26[meta cpp]
+
+```cpp
+constexpr bool valueless_after_move() const noexcept;
+```
+
+## 概要
+`*this`が無効値状態かどうかを判定する。`indirect`はムーブされたあとにのみ無効値状態となりうる。
+
+
+## 戻り値
+`*this`が無効値状態であれば`true`、そうでなければ`false`。
+
+
+## 例外
+投げない。
+
+
+## 例
+```cpp example
+#include <cassert>
+#include <memory>
+
+int main()
+{
+  std::indirect<int> a{42};
+  assert(!a.valueless_after_move());
+
+  std::indirect<int> b = std::move(a);
+  assert(a.valueless_after_move());  // ムーブ後は無効値状態
+  assert(!b.valueless_after_move());
+}
+```
+* std::indirect[color ff0000]
+
+### 出力
+```
+```
+
+
+## バージョン
+### 言語
+- C++26
+
+### 処理系
+- [Clang](/implementation.md#clang): 22 [mark noimpl]
+- [GCC](/implementation.md#gcc): 16.1 [mark verified]
+- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl]
+
+
+## 関連項目
+- [`std::indirect`](../indirect.md)
+
+
+## 参照
+- [P3019R14 `indirect` and `polymorphic`: Vocabulary Types for Composite Class Design](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3019r14.pdf)

polymorphic -- Merge pull request #1661 from cpprefjp/indirect_polymorphic

2026-06-24T10:24:58+09:00

diff --git a/reference/memory/polymorphic.md b/reference/memory/polymorphic.md
new file mode 100644
index 000000000..ad7a74aed
--- /dev/null
+++ b/reference/memory/polymorphic.md
@@ -0,0 +1,147 @@
+# polymorphic
+* memory[meta header]
+* std[meta namespace]
+* class template[meta id-type]
+* cpp26[meta cpp]
+
+```cpp
+namespace std {
+  template <class T, class Allocator = allocator<T>>
+  class polymorphic;
+
+  namespace pmr {
+    template <class T>
+    using polymorphic = std::polymorphic<T, polymorphic_allocator<T>>;
+  }
+}
+```
+* allocator[link allocator.md]
+* polymorphic_allocator[link /reference/memory_resource/polymorphic_allocator.md]
+
+## 概要
+`std::polymorphic`クラスは、動的確保したオブジェクトに値の意味論をもたせつつ、`T`から派生した任意の型のオブジェクトを多態的に保持できる型である。
+
+[`std::indirect`](indirect.md)クラスが単一の型`T`のオブジェクトを保持するのに対し、`std::polymorphic<T>`クラスは`T`を基底とする派生型のオブジェクトを保持できる。値型としての性質は`std::indirect`クラスと共通している：
+
+- ディープコピー: `std::polymorphic<T>`クラスのオブジェクトをコピーすると、実際に保持している派生型のオブジェクトが、その派生型のコピーコンストラクタによって複製される（型消去をとおした仮想ディスパッチが用いられる）
+- `const`の伝播: `const`なアクセス経路から所有オブジェクトにアクセスすると、所有オブジェクトにも`const`が伝播する
+- 不完全型のサポート: テンプレートパラメータ`T`は不完全型でもよい
+
+これらの性質によって、`std::polymorphic`クラスは多態的な性質をもつクラスのメンバ変数として適しており、コンパイラによる特殊メンバ関数の自動生成と協調して動作する。
+
+所有オブジェクトを持たない状態を「無効値状態 (valueless state)」と呼ぶ。`std::polymorphic`クラスが無効値状態になるのは、ムーブ後に空となった場合のみである。無効値状態のオブジェクトに対する`operator*`や`operator->`の呼び出しは未定義動作を引き起こす。無効値状態かどうかは[`valueless_after_move()`](polymorphic/valueless_after_move.md)で判定できる。
+
+保持する型の集合が既知である場合は、[`std::variant`](/reference/variant/variant.md)や`indirect<std::variant<...>>`の使用を検討するとよい。
+
+
+## テンプレートパラメータ制約
+- `Allocator`はCpp17Allocator要件を満たすこと。
+- [`allocator_traits`](/reference/memory/allocator_traits.md)`<Allocator>::value_type`が`T`と同じ型であること
+
+
+## 適格要件
+- 以下のいずれかの場合に、プログラムは不適格となる
+    - `T`がオブジェクト型でない
+    - 配列型である
+    - (CV修飾された) [`std::in_place_t`](/reference/utility/in_place_t.md)である
+    - (CV修飾された) [`std::in_place_type_t`](/reference/utility/in_place_type_t.md)の特殊化である
+    - CV修飾された型である
+- `std::polymorphic`の明示的特殊化・部分特殊化をユーザーが宣言した場合、動作は未定義である
+
+
+## メンバ関数
+### 構築・破棄
+
+| 名前 | 説明 | 対応バージョン |
+|------|------|----------------|
+| [`(constructor)`](polymorphic/op_constructor.md) | コンストラクタ | C++26 |
+| [`(destructor)`](polymorphic/op_destructor.md) | デストラクタ | C++26 |
+| [`operator=`](polymorphic/op_assign.md) | 代入演算子 | C++26 |
+
+### 値へのアクセス
+
+| 名前 | 説明 | 対応バージョン |
+|------|------|----------------|
+| [`operator*`](polymorphic/op_deref.md) | 所有するオブジェクトへの参照を取得する | C++26 |
+| [`operator->`](polymorphic/op_arrow.md) | 所有するオブジェクトのメンバへアクセスする | C++26 |
+| [`valueless_after_move`](polymorphic/valueless_after_move.md) | 無効値状態かどうかを判定する | C++26 |
+
+### その他
+
+| 名前 | 説明 | 対応バージョン |
+|------|------|----------------|
+| [`get_allocator`](polymorphic/get_allocator.md) | アロケータを取得する | C++26 |
+| [`swap`](polymorphic/swap.md) | 他の`polymorphic`オブジェクトと値を交換する | C++26 |
+
+
+## メンバ型
+
+| 名前 | 定義 | 対応バージョン |
+|------|------|----------------|
+| `value_type` | `T` | C++26 |
+| `allocator_type` | `Allocator` | C++26 |
+| `pointer` | [`allocator_traits`](/reference/memory/allocator_traits.md)`<Allocator>::pointer` | C++26 |
+| `const_pointer` | [`allocator_traits`](/reference/memory/allocator_traits.md)`<Allocator>::const_pointer` | C++26 |
+
+
+## 非メンバ（*Hidden friends*）関数
+
+| 名前 | 説明 | 対応バージョン |
+|------|------|----------------|
+| [`swap`](polymorphic/swap_free.md) | 2つの`polymorphic`オブジェクトを交換する | C++26 |
+
+
+## 例
+```cpp example
+#include <cassert>
+#include <memory>
+
+struct Shape {
+  virtual ~Shape() = default;
+  virtual int area() const = 0;
+};
+
+struct Square : Shape {
+  int side;
+  Square(int s) : side(s) {}
+  int area() const override { return side * side; }
+};
+
+int main()
+{
+  // Shapeから派生したSquareを、値の意味論で多態的に保持する
+  std::polymorphic<Shape> a{std::in_place_type<Square>, 3};
+  assert(a->area() == 9);
+
+  // コピーは派生型(Square)のディープコピー
+  std::polymorphic<Shape> b = a;
+  assert(b->area() == 9);
+}
+```
+* std::polymorphic[color ff0000]
+* std::in_place_type[link /reference/utility/in_place_type_t.md]
+
+### 出力
+```
+```
+
+
+## バージョン
+### 言語
+- C++26
+
+### 処理系
+- [Clang](/implementation.md#clang): 22 [mark noimpl]
+- [GCC](/implementation.md#gcc): 16.1 [mark verified]
+- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl]
+
+
+## 関連項目
+- [`std::indirect`](indirect.md) 単一の型を保持する値型
+- [`std::variant`](/reference/variant/variant.md) 既知の型集合から1つを保持する型
+- [`std::unique_ptr`](unique_ptr.md) 多態的な所有権をもつが参照の意味論をもつスマートポインタ
+
+
+## 参照
+- [P3019R14 `indirect` and `polymorphic`: Vocabulary Types for Composite Class Design](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3019r14.pdf)
+    - C++26で`indirect`と`polymorphic`が追加された

get_allocator -- Merge pull request #1661 from cpprefjp/indirect_polymorphic

2026-06-24T10:24:58+09:00

diff --git a/reference/memory/polymorphic/get_allocator.md b/reference/memory/polymorphic/get_allocator.md
new file mode 100644
index 000000000..c7981d7a0
--- /dev/null
+++ b/reference/memory/polymorphic/get_allocator.md
@@ -0,0 +1,39 @@
+# get_allocator
+* memory[meta header]
+* std[meta namespace]
+* polymorphic[meta class]
+* function[meta id-type]
+* cpp26[meta cpp]
+
+```cpp
+constexpr allocator_type get_allocator() const noexcept;
+```
+
+## 概要
+このオブジェクトが使用するアロケータを取得する。
+
+
+## 戻り値
+所有するアロケータのコピー。
+
+
+## 例外
+投げない。
+
+
+## バージョン
+### 言語
+- C++26
+
+### 処理系
+- [Clang](/implementation.md#clang): 22 [mark noimpl]
+- [GCC](/implementation.md#gcc): 16.1 [mark verified]
+- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl]
+
+
+## 関連項目
+- [`std::polymorphic`](../polymorphic.md)
+
+
+## 参照
+- [P3019R14 `indirect` and `polymorphic`: Vocabulary Types for Composite Class Design](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3019r14.pdf)

operator-> -- Merge pull request #1661 from cpprefjp/indirect_polymorphic

2026-06-24T10:24:58+09:00

diff --git a/reference/memory/polymorphic/op_arrow.md b/reference/memory/polymorphic/op_arrow.md
new file mode 100644
index 000000000..fad8e5e62
--- /dev/null
+++ b/reference/memory/polymorphic/op_arrow.md
@@ -0,0 +1,74 @@
+# operator->
+* memory[meta header]
+* std[meta namespace]
+* polymorphic[meta class]
+* function[meta id-type]
+* cpp26[meta cpp]
+
+```cpp
+constexpr const_pointer operator->() const noexcept; // (1)
+constexpr pointer operator->() noexcept;             // (2)
+```
+
+## 概要
+所有するオブジェクトのメンバへ、基底型`T`としてアクセスするためのポインタを取得する。
+
+
+## 事前条件
+`*this`が無効値状態でないこと。
+
+
+## 戻り値
+所有するオブジェクトを指すポインタ。
+
+
+## 例外
+投げない。
+
+
+## 例
+```cpp example
+#include <cassert>
+#include <memory>
+
+struct Base {
+  virtual ~Base() = default;
+  virtual int f() const { return 0; }
+};
+struct Derived : Base {
+  int x = 42;
+  Derived() = default;
+  Derived(int x) : x(x) {}
+  int f() const override { return x; }
+};
+
+int main()
+{
+  std::polymorphic<Base> a{std::in_place_type<Derived>};
+  assert(a->f() == 42);  // 基底型Baseのメンバへアクセス（仮想ディスパッチ）
+}
+```
+* std::polymorphic[color ff0000]
+* std::in_place_type[link /reference/utility/in_place_type_t.md]
+
+### 出力
+```
+```
+
+
+## バージョン
+### 言語
+- C++26
+
+### 処理系
+- [Clang](/implementation.md#clang): 22 [mark noimpl]
+- [GCC](/implementation.md#gcc): 16.1 [mark verified]
+- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl]
+
+
+## 関連項目
+- [`std::polymorphic`](../polymorphic.md)
+
+
+## 参照
+- [P3019R14 `indirect` and `polymorphic`: Vocabulary Types for Composite Class Design](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3019r14.pdf)

代入演算子 -- Merge pull request #1661 from cpprefjp/indirect_polymorphic

2026-06-24T10:24:58+09:00

diff --git a/reference/memory/polymorphic/op_assign.md b/reference/memory/polymorphic/op_assign.md
new file mode 100644
index 000000000..0e472b166
--- /dev/null
+++ b/reference/memory/polymorphic/op_assign.md
@@ -0,0 +1,93 @@
+# 代入演算子
+* memory[meta header]
+* std[meta namespace]
+* polymorphic[meta class]
+* function[meta id-type]
+* cpp26[meta cpp]
+
+```cpp
+constexpr polymorphic& operator=(const polymorphic& other);                // (1)
+constexpr polymorphic& operator=(polymorphic&& other) noexcept(see below); // (2)
+```
+
+## 概要
+- (1) : コピー代入。`other`が保持する派生型のオブジェクトをディープコピーする。
+- (2) : ムーブ代入。`other`から所有権を移す。
+
+
+## 適格要件
+- (1) : `T`は完全型であること。
+
+
+## 効果
+- (1) : `addressof(other) == this`であれば何もしない。そうでなければ、アロケータの伝播規則に従い、`other`が保持するオブジェクトのコピーを`*this`がもつようにする。`other`が無効値状態であれば`*this`も無効値状態にする。
+- (2) : `addressof(other) == this`であれば何もしない。そうでなければ、アロケータの伝播規則に従い、`other`から所有権を移すか、ムーブ構築する。
+
+
+## 戻り値
+`*this`への参照。
+
+
+## 例外
+- (1) : 強い例外安全性を保証する。例外が送出された場合、`*this`や`other`に影響はない。
+- (2) : 以下と等価な`noexcept`指定を持つ：
+
+```cpp
+noexcept(allocator_traits<Allocator>::propagate_on_container_move_assignment::value ||
+         allocator_traits<Allocator>::is_always_equal::value)
+```
+* allocator_traits[link /reference/memory/allocator_traits.md]
+
+
+## 例
+```cpp example
+#include <cassert>
+#include <memory>
+
+struct Base {
+  virtual ~Base() = default;
+  virtual int f() const { return 0; }
+};
+struct Derived : Base {
+  int x = 42;
+  Derived() = default;
+  Derived(int x) : x(x) {}
+  int f() const override { return x; }
+};
+
+int main()
+{
+  std::polymorphic<Base> a{std::in_place_type<Derived>, 1};
+  std::polymorphic<Base> b{std::in_place_type<Derived>, 2};
+
+  a = b;             // (1) コピー代入（派生型のディープコピー）
+  assert(a->f() == 2);
+
+  a = std::move(b);  // (2) ムーブ代入
+  assert(a->f() == 2);
+}
+```
+* std::polymorphic[color ff0000]
+* std::in_place_type[link /reference/utility/in_place_type_t.md]
+
+### 出力
+```
+```
+
+
+## バージョン
+### 言語
+- C++26
+
+### 処理系
+- [Clang](/implementation.md#clang): 22 [mark noimpl]
+- [GCC](/implementation.md#gcc): 16.1 [mark verified]
+- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl]
+
+
+## 関連項目
+- [`std::polymorphic`](../polymorphic.md)
+
+
+## 参照
+- [P3019R14 `indirect` and `polymorphic`: Vocabulary Types for Composite Class Design](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3019r14.pdf)

コンストラクタ -- Merge pull request #1661 from cpprefjp/indirect_polymorphic

2026-06-24T10:24:58+09:00

diff --git a/reference/memory/polymorphic/op_constructor.md b/reference/memory/polymorphic/op_constructor.md
new file mode 100644
index 000000000..4a0e01af7
--- /dev/null
+++ b/reference/memory/polymorphic/op_constructor.md
@@ -0,0 +1,158 @@
+# コンストラクタ
+* memory[meta header]
+* std[meta namespace]
+* polymorphic[meta class]
+* function[meta id-type]
+* cpp26[meta cpp]
+
+```cpp
+explicit constexpr 
+  polymorphic();                             // (1)
+
+explicit constexpr
+  polymorphic(allocator_arg_t,
+              const Allocator& a);           // (2)
+
+constexpr
+  polymorphic(const polymorphic& other);     // (3)
+
+constexpr
+  polymorphic(allocator_arg_t,
+              const Allocator& a,
+              const polymorphic& other);     // (4)
+
+constexpr
+  polymorphic(polymorphic&& other) noexcept; // (5)
+
+constexpr
+  polymorphic(allocator_arg_t,
+              const Allocator& a,
+              polymorphic&& other) noexcept(see below); // (6)
+
+template <class U = T>
+explicit constexpr
+  polymorphic(U&& u);                          // (7)
+
+template <class U = T>
+explicit constexpr
+  polymorphic(allocator_arg_t,
+              const Allocator& a,
+              U&& u);                          // (8)
+
+template <class U, class... Ts>
+explicit constexpr
+  polymorphic(in_place_type_t<U>,
+              Ts&&... ts);                     // (9)
+
+template <class U, class... Ts>
+explicit constexpr
+  polymorphic(allocator_arg_t,
+              const Allocator& a,
+              in_place_type_t<U>, Ts&&... ts); // (10)
+
+template <class U, class I, class... Us>
+explicit constexpr
+  polymorphic(in_place_type_t<U>,
+              initializer_list<I> ilist,
+              Us&&... us);                    // (11)
+
+template <class U, class I, class... Us>
+explicit constexpr
+  polymorphic(allocator_arg_t, const Allocator& a,
+              in_place_type_t<U>,
+              initializer_list<I> ilist, Us&&... us); // (12)
+```
+* allocator_arg_t[link /reference/memory/allocator_arg_t.md]
+* in_place_type_t[link /reference/utility/in_place_type_t.md]
+* initializer_list[link /reference/initializer_list/initializer_list.md]
+
+## 概要
+`polymorphic`オブジェクトを構築する。`allocator_arg_t`を第1引数に取るオーバーロードは、使用するアロケータ`a`を明示的に指定する。
+
+- (1), (2) : デフォルトコンストラクタ。`T`をデフォルト構築して所有する。
+- (3), (4) : コピーコンストラクタ。`other`が保持する派生型のオブジェクトをディープコピーして所有する。`other`が無効値状態の場合、構築されるオブジェクトも無効値状態となる。
+- (5), (6) : ムーブコンストラクタ。`other`が保持するオブジェクトの所有権を移す。
+- (7), (8) : 単一の引数`u`から、その型`U`（`T`から派生していてもよい）のオブジェクトを構築して所有する。
+- (9), (10) : `in_place_type_t<U>`をマーカーとして、型`U`のオブジェクトを引数`ts...`から直接構築して所有する。
+- (11), (12) : `in_place_type_t<U>`をマーカーとして、型`U`のオブジェクトを初期化子リストと引数`us...`から直接構築して所有する。
+
+
+## テンプレートパラメータ制約
+- (7), (8) : [`remove_cvref_t`](/reference/type_traits/remove_cvref.md)`<U>`を`UU`とするとき、`UU`が`polymorphic`でも`in_place_type_t`の特殊化でもなく、[`derived_from`](/reference/concepts/derived_from.md)`<UU, T>`、[`is_constructible_v`](/reference/type_traits/is_constructible.md)`<UU, U>`、[`is_copy_constructible_v`](/reference/type_traits/is_copy_constructible.md)`<UU>`がいずれも`true`であること。(7)はさらに[`is_default_constructible_v`](/reference/type_traits/is_default_constructible.md)`<Allocator>`が`true`であること。
+- (9), (10) : [`is_same_v`](/reference/type_traits/is_same.md)`<`[`remove_cvref_t`](/reference/type_traits/remove_cvref.md)`<U>, U>`、[`derived_from`](/reference/concepts/derived_from.md)`<U, T>`、[`is_constructible_v`](/reference/type_traits/is_constructible.md)`<U, Ts...>`、[`is_copy_constructible_v`](/reference/type_traits/is_copy_constructible.md)`<U>`がいずれも`true`であること。(9)はさらに[`is_default_constructible_v`](/reference/type_traits/is_default_constructible.md)`<Allocator>`が`true`であること。
+- (11), (12) : [`is_same_v`](/reference/type_traits/is_same.md)`<`[`remove_cvref_t`](/reference/type_traits/remove_cvref.md)`<U>, U>`、[`derived_from`](/reference/concepts/derived_from.md)`<U, T>`、[`is_constructible_v`](/reference/type_traits/is_constructible.md)`<U, initializer_list<I>&, Us...>`、[`is_copy_constructible_v`](/reference/type_traits/is_copy_constructible.md)`<U>`がいずれも`true`であること。(11)はさらに[`is_default_constructible_v`](/reference/type_traits/is_default_constructible.md)`<Allocator>`が`true`であること。
+
+
+## 適格要件
+- (1), (2) : [`is_default_constructible_v`](/reference/type_traits/is_default_constructible.md)`<T>`と[`is_copy_constructible_v`](/reference/type_traits/is_copy_constructible.md)`<T>`がともに`true`であること。
+
+
+## 効果
+所有するオブジェクトを、指定された型・引数とアロケータ`alloc`を用いて構築する。`allocator_arg_t`版は`alloc`を`a`で初期化する。
+
+
+## 例外
+- すべてのオーバーロード : [`allocator_traits`](/reference/memory/allocator_traits.md)`<Allocator>::allocate`または[`allocator_traits`](/reference/memory/allocator_traits.md)`<Allocator>::construct`が例外を送出した場合を除いて、例外を送出しない。
+- (6) : 以下と等価な`noexcept`指定を持つ：
+
+```cpp
+noexcept(allocator_traits<Allocator>::is_always_equal::value)
+```
+* allocator_traits[link /reference/memory/allocator_traits.md]
+
+
+## 例
+```cpp example
+#include <cassert>
+#include <memory>
+
+struct Base {
+  virtual ~Base() = default;
+  virtual int f() const { return 0; }
+};
+struct Derived : Base {
+  int x = 42;
+  Derived() = default;
+  Derived(int x) : x(x) {}
+  int f() const override { return x; }
+};
+
+int main()
+{
+  // (9) in_place_typeで派生型Derivedを直接構築
+  std::polymorphic<Base> a{std::in_place_type<Derived>};
+  assert(a->f() == 42);
+
+  // (7) 派生型の値から構築
+  std::polymorphic<Base> b{Derived{10}};
+  assert(b->f() == 10);
+
+  // (3) コピー構築（派生型Derivedのディープコピー）
+  std::polymorphic<Base> c = a;
+  assert(c->f() == 42);
+}
+```
+* std::polymorphic[color ff0000]
+* std::in_place_type[link /reference/utility/in_place_type_t.md]
+
+### 出力
+```
+```
+
+
+## バージョン
+### 言語
+- C++26
+
+### 処理系
+- [Clang](/implementation.md#clang): 22 [mark noimpl]
+- [GCC](/implementation.md#gcc): 16.1 [mark verified]
+- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl]
+
+
+## 関連項目
+- [`std::polymorphic`](../polymorphic.md)
+
+
+## 参照
+- [P3019R14 `indirect` and `polymorphic`: Vocabulary Types for Composite Class Design](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3019r14.pdf)

operator* -- Merge pull request #1661 from cpprefjp/indirect_polymorphic

2026-06-24T10:24:58+09:00

diff --git a/reference/memory/polymorphic/op_deref.md b/reference/memory/polymorphic/op_deref.md
new file mode 100644
index 000000000..bfc03fe52
--- /dev/null
+++ b/reference/memory/polymorphic/op_deref.md
@@ -0,0 +1,75 @@
+# operator*
+* memory[meta header]
+* std[meta namespace]
+* polymorphic[meta class]
+* function[meta id-type]
+* cpp26[meta cpp]
+
+```cpp
+constexpr const T& operator*() const noexcept; // (1)
+constexpr T& operator*() noexcept;             // (2)
+```
+
+## 概要
+所有するオブジェクトへの、基底型`T`としての参照を取得する。`const`なアクセス経路では`const`が所有オブジェクトに伝播する。
+
+
+## 事前条件
+`*this`が無効値状態でないこと。
+
+
+## 戻り値
+所有するオブジェクトへの`T`型としての参照。
+
+
+## 例外
+投げない。
+
+
+## 例
+```cpp example
+#include <cassert>
+#include <memory>
+
+struct Base {
+  virtual ~Base() = default;
+  virtual int f() const { return 0; }
+};
+struct Derived : Base {
+  int x = 42;
+  Derived() = default;
+  Derived(int x) : x(x) {}
+  int f() const override { return x; }
+};
+
+int main()
+{
+  std::polymorphic<Base> a{std::in_place_type<Derived>};
+  Base& r = *a;          // 基底型Baseとしての参照を取得
+  assert(r.f() == 42);   // 仮想関数で派生型Derivedの実装が呼ばれる
+}
+```
+* std::polymorphic[color ff0000]
+* std::in_place_type[link /reference/utility/in_place_type_t.md]
+
+### 出力
+```
+```
+
+
+## バージョン
+### 言語
+- C++26
+
+### 処理系
+- [Clang](/implementation.md#clang): 22 [mark noimpl]
+- [GCC](/implementation.md#gcc): 16.1 [mark verified]
+- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl]
+
+
+## 関連項目
+- [`std::polymorphic`](../polymorphic.md)
+
+
+## 参照
+- [P3019R14 `indirect` and `polymorphic`: Vocabulary Types for Composite Class Design](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3019r14.pdf)

デストラクタ -- Merge pull request #1661 from cpprefjp/indirect_polymorphic

2026-06-24T10:24:58+09:00

diff --git a/reference/memory/polymorphic/op_destructor.md b/reference/memory/polymorphic/op_destructor.md
new file mode 100644
index 000000000..94fba4547
--- /dev/null
+++ b/reference/memory/polymorphic/op_destructor.md
@@ -0,0 +1,39 @@
+# デストラクタ
+* memory[meta header]
+* std[meta namespace]
+* polymorphic[meta class]
+* function[meta id-type]
+* cpp26[meta cpp]
+
+```cpp
+constexpr ~polymorphic();
+```
+
+## 概要
+`polymorphic`オブジェクトを破棄する。
+
+
+## 適格要件
+`T`は完全型であること。
+
+
+## 効果
+`*this`が無効値状態でなければ、所有するオブジェクトを[`allocator_traits`](/reference/memory/allocator_traits.md)`<Allocator>::destroy`で破棄し、ストレージを解放する。
+
+
+## バージョン
+### 言語
+- C++26
+
+### 処理系
+- [Clang](/implementation.md#clang): 22 [mark noimpl]
+- [GCC](/implementation.md#gcc): 16.1 [mark verified]
+- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl]
+
+
+## 関連項目
+- [`std::polymorphic`](../polymorphic.md)
+
+
+## 参照
+- [P3019R14 `indirect` and `polymorphic`: Vocabulary Types for Composite Class Design](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3019r14.pdf)

swap -- Merge pull request #1661 from cpprefjp/indirect_polymorphic

2026-06-24T10:24:58+09:00

diff --git a/reference/memory/polymorphic/swap.md b/reference/memory/polymorphic/swap.md
new file mode 100644
index 000000000..695d15cce
--- /dev/null
+++ b/reference/memory/polymorphic/swap.md
@@ -0,0 +1,74 @@
+# swap
+* memory[meta header]
+* std[meta namespace]
+* polymorphic[meta class]
+* function[meta id-type]
+* cpp26[meta cpp]
+
+```cpp
+constexpr void swap(polymorphic& other) noexcept(see below);
+```
+
+## 概要
+`*this`と`other`の状態を交換する。所有オブジェクトまたは無効値状態を交換する。
+
+
+## 事前条件
+[`allocator_traits`](/reference/memory/allocator_traits.md)`<Allocator>::propagate_on_container_swap::value`が`true`の場合、`Allocator`は*Cpp17Swappable*要件を満たすこと。そうでない場合、`get_allocator() == other.get_allocator()`が`true`であること。
+
+
+## 効果
+`*this`と`other`の状態を交換する。`propagate_on_container_swap::value`が`true`の場合はアロケータも交換する。
+
+
+## 例外
+以下と等価な`noexcept`指定を持つ：
+
+```cpp
+noexcept(allocator_traits<Allocator>::propagate_on_container_swap::value ||
+         allocator_traits<Allocator>::is_always_equal::value)
+```
+* allocator_traits[link /reference/memory/allocator_traits.md]
+
+
+## 例
+```cpp example
+#include <cassert>
+#include <memory>
+
+struct Base { virtual ~Base() = default; virtual int f() const = 0; };
+struct D1 : Base { int f() const override { return 1; } };
+struct D2 : Base { int f() const override { return 2; } };
+
+int main()
+{
+  std::polymorphic<Base> a{std::in_place_type<D1>};
+  std::polymorphic<Base> b{std::in_place_type<D2>};
+  a.swap(b);
+  assert(a->f() == 2 && b->f() == 1);
+}
+```
+* std::polymorphic[color ff0000]
+* std::in_place_type[link /reference/utility/in_place_type_t.md]
+
+### 出力
+```
+```
+
+
+## バージョン
+### 言語
+- C++26
+
+### 処理系
+- [Clang](/implementation.md#clang): 22 [mark noimpl]
+- [GCC](/implementation.md#gcc): 16.1 [mark verified]
+- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl]
+
+
+## 関連項目
+- [`std::polymorphic`](../polymorphic.md)
+
+
+## 参照
+- [P3019R14 `indirect` and `polymorphic`: Vocabulary Types for Composite Class Design](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3019r14.pdf)

swap -- Merge pull request #1661 from cpprefjp/indirect_polymorphic

2026-06-24T10:24:58+09:00

diff --git a/reference/memory/polymorphic/swap_free.md b/reference/memory/polymorphic/swap_free.md
new file mode 100644
index 000000000..f680893d8
--- /dev/null
+++ b/reference/memory/polymorphic/swap_free.md
@@ -0,0 +1,68 @@
+# swap
+* memory[meta header]
+* std[meta namespace]
+* polymorphic[meta class]
+* function[meta id-type]
+* cpp26[meta cpp]
+
+```cpp
+friend constexpr void swap(polymorphic& lhs, polymorphic& rhs) noexcept(see below);
+```
+
+## 概要
+2つの`polymorphic`オブジェクトを交換する。*Hidden friends*として定義される。
+
+
+## 効果
+`lhs.swap(rhs)`と等価。
+
+
+## 例外
+以下と等価な`noexcept`指定を持つ：
+
+```cpp
+noexcept(noexcept(lhs.swap(rhs)))
+```
+
+
+## 例
+```cpp example
+#include <cassert>
+#include <memory>
+
+struct Base { virtual ~Base() = default; virtual int f() const = 0; };
+struct D1 : Base { int f() const override { return 1; } };
+struct D2 : Base { int f() const override { return 2; } };
+
+int main()
+{
+  std::polymorphic<Base> a{std::in_place_type<D1>};
+  std::polymorphic<Base> b{std::in_place_type<D2>};
+  swap(a, b);   // ADLにより非メンバswapが呼ばれる
+  assert(a->f() == 2 && b->f() == 1);
+}
+```
+* std::polymorphic[color ff0000]
+* std::in_place_type[link /reference/utility/in_place_type_t.md]
+
+### 出力
+```
+```
+
+
+## バージョン
+### 言語
+- C++26
+
+### 処理系
+- [Clang](/implementation.md#clang): 22 [mark noimpl]
+- [GCC](/implementation.md#gcc): 16.1 [mark verified]
+- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl]
+
+
+## 関連項目
+- [`std::polymorphic`](../polymorphic.md)
+
+
+## 参照
+- [P3019R14 `indirect` and `polymorphic`: Vocabulary Types for Composite Class Design](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3019r14.pdf)

valueless_after_move -- Merge pull request #1661 from cpprefjp/indirect_polymorphic

2026-06-24T10:24:58+09:00

diff --git a/reference/memory/polymorphic/valueless_after_move.md b/reference/memory/polymorphic/valueless_after_move.md
new file mode 100644
index 000000000..687f983f7
--- /dev/null
+++ b/reference/memory/polymorphic/valueless_after_move.md
@@ -0,0 +1,72 @@
+# valueless_after_move
+* memory[meta header]
+* std[meta namespace]
+* polymorphic[meta class]
+* function[meta id-type]
+* cpp26[meta cpp]
+
+```cpp
+constexpr bool valueless_after_move() const noexcept;
+```
+
+## 概要
+`*this`が無効値状態かどうかを判定する。`polymorphic`はムーブされたあとにのみ無効値状態となりうる。
+
+
+## 戻り値
+`*this`が無効値状態であれば`true`、そうでなければ`false`。
+
+
+## 例外
+投げない。
+
+
+## 例
+```cpp example
+#include <cassert>
+#include <memory>
+
+struct Base {
+  virtual ~Base() = default;
+  virtual int f() const { return 0; }
+};
+struct Derived : Base {
+  int x = 42;
+  Derived() = default;
+  Derived(int x) : x(x) {}
+  int f() const override { return x; }
+};
+
+int main()
+{
+  std::polymorphic<Base> a{std::in_place_type<Derived>};
+  assert(!a.valueless_after_move());
+
+  std::polymorphic<Base> b = std::move(a);
+  assert(a.valueless_after_move());  // ムーブ後は無効値状態
+}
+```
+* std::polymorphic[color ff0000]
+* std::in_place_type[link /reference/utility/in_place_type_t.md]
+
+### 出力
+```
+```
+
+
+## バージョン
+### 言語
+- C++26
+
+### 処理系
+- [Clang](/implementation.md#clang): 22 [mark noimpl]
+- [GCC](/implementation.md#gcc): 16.1 [mark verified]
+- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl]
+
+
+## 関連項目
+- [`std::polymorphic`](../polymorphic.md)
+
+
+## 参照
+- [P3019R14 `indirect` and `polymorphic`: Vocabulary Types for Composite Class Design](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3019r14.pdf)

C++26 -- C++26対応としてindirectとpolymorphicのリファレンスを作成 #1430

2026-06-22T16:01:50+09:00

C++26

概要

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

言語機能

変数

言語機能	説明
`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クラスを追加
<utility>に、定数を型として包むことで、関数の引数として渡しても定数式として扱えるようにする定数ラッパーstd::constant_wrapperクラスと、それを簡潔に生成する変数テンプレートstd::cwを追加

デバッグ

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

型特性

<type_traits>に、共用体の指定されたメンバがアクティブかを定数式で判定するための関数としてstd::is_within_lifetime()を追加
<type_traits>に、仮想継承の関係を判定するstd::is_virtual_base_ofを追加
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()
- これらはOS依存のパス名エンコーディングへ変換するため、iostream・std::format()・std::print()を含むほぼすべての標準のテキスト処理・入出力機能と互換性がなく、文字化けやデータ損失の原因になりやすい
- レガシーなシステムAPIにパスを渡す用途では、システム依存エンコーディングへの変換であることを明確にしたsystem_encoded_string()・generic_system_encoded_string()を使用する
- 表示・フォーマットの用途では、display_string()・generic_display_string()、もしくはstd::format()・std::print()を使用する

非推奨の取り消し

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ライブラリ由来のヘッダに以下の変更が入った
- <cstdlib>: free_sized()・free_aligned_sized()・memalignment()・strfromf()・strfromd()・strfroml()を追加。bsearch()にconst版オーバーロードを追加。realloc()にサイズ0を渡した場合がエラー性動作となった
- <ctime>: timespec_getres()・timegm()・gmtime_r()・localtime_r()と、TIME_MONOTONIC・TIME_ACTIVE・TIME_THREAD_ACTIVE・__STDC_VERSION_TIME_H__を追加。asctime()・ctime()を非推奨化
- <cmath>: nextup()・nextdown()を追加
- <cstdio>: _PRINTF_NAN_LEN_MAX・__STDC_VERSION_STDIO_H__を追加
- <cinttypes>: 2進数用の書式指定マクロ (PRIbN・SCNbN等) と__STDC_VERSION_INTTYPES_H__を追加
- <cfloat>: INFINITY・NAN・FLT_SNAN・DBL_SNAN・LDBL_SNAN・__STDC_VERSION_FLOAT_H__を追加。DECIMAL_DIGを非推奨化し、FLT_HAS_SUBNORM・DBL_HAS_SUBNORM・LDBL_HAS_SUBNORMを廃止予定 (obsolescent) とした
- <climits>: 各整数型の幅 (ビット数) を表すBOOL_WIDTH等のマクロを追加
- <cstdint>: 各整数型の幅 (ビット数) を表すINT8_WIDTH等のマクロと、__STDC_VERSION_STDINT_H__を追加
- <cstring>: memccpy()・strdup()・strndup()・memset_explicit()を追加
- <cuchar>: mbrtoc8()・c8rtomb()・__STDC_VERSION_UCHAR_H__を追加
- <cstddef>: unreachableマクロおよび__STDC_VERSION_STDDEF_H__は定義しないことを明記

機能テストマクロ -- C++26対応としてindirectとpolymorphicのリファレンスを作成 #1430

2026-06-22T16:01:50+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`	`202606L`	`<utility>`に`std::constant_wrapper`を追加	`<utility>`
`__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

memory -- C++26対応としてindirectとpolymorphicのリファレンスを作成 #1430

2026-06-22T16:01:50+09:00

memory

このヘッダでは、以下の標準ヘッダをインクルードする：

<compare> (C++20)

メモリアロケータ

名前	説明	対応バージョン
`allocator`	メモリアロケータの標準実装(class template)
`allocator_traits`	アロケータクラスへの間接的なアクセス(class template)	C++11
`allocation_result`	`allocate_at_least()`関数の戻り値型	C++23
`allocator_arg_t`	アロケータを引数として渡す際の、オーバーロード解決のためのタグ(class)	C++11
`allocator_arg`	アロケータを引数として渡す際の、オーバーロード解決のためのタグ(constant value)	C++11
`uses_allocator`	型`T`がアロケータを使用するか調べる	C++11
`uses_allocator_construction_args`	uses-allocator 構築のためのコンストラクタ引数を `tuple` 型にして返す	C++20
`make_obj_using_allocator`	uses-allocator 構築する	C++20
`uninitialized_construct_using_allocator`	指定された領域に uses-allocator 構築する	C++20

メモリ特化のコンセプト

名前	説明	対応バージョン
`no-throw-input-iterator`	各操作で例外送出をしない説明用の入力イテレータ (concept)	C++20
`no-throw-forward-iterator`	各操作で例外送出をしない説明用の前方向イテレータ (concept)	C++20
`no-throw-sentinel`	各操作で例外送出をしない説明用の番兵 (concept)	C++20
`no-throw-input-range`	各操作で例外送出をしない入力Range (concept)	C++20
`no-throw-forward-range`	各操作で例外送出をしない前方向Range (concept)	C++20

未初期化領域に対する操作

名前	説明	対応バージョン
`uninitialized_default_construct`	未初期化領域の範囲の各要素をデフォルト構築する(function template)	C++17
`uninitialized_default_construct_n`	未初期化領域の範囲のうち、先頭`N`個の要素をデフォルト構築する(function template)	C++17
`uninitialized_value_construct`	未初期化領域の範囲の各要素配置を値構築する(function template)	C++17
`uninitialized_value_construct_n`	未初期化領域の範囲のうち、先頭`N`個の要素を値構築する(function template)	C++17
`uninitialized_copy`	未初期化領域の範囲を配置`new`で初期化してコピー出力する(function template)
`uninitialized_copy_n`	未初期化領域の範囲のうち、先頭`N`個の要素を配置`new`で初期化してコピー出力する(function template)	C++11
`uninitialized_move`	未初期化領域の範囲を配置`new`で初期化してムーブ出力する(function template)
`uninitialized_move_n`	未初期化領域の範囲のうち、先頭`N`個の要素を配置`new`で初期化してムーブ出力する(function template)	C++11
`uninitialized_fill`	未初期化領域の範囲を、指定された値で配置`new`する(function template)
`uninitialized_fill_n`	未初期化領域の範囲のうち、先頭`N`個の要素を指定された値で配置`new`する(function template)
`construct_at`	コンストラクタを呼び出す(function template)	C++20
`destroy_at`	デストラクタを呼び出す(function template)	C++17
`destroy`	範囲の各要素に対してデストラクタを呼び出す(function template)	C++17
`destroy_n`	範囲のうち、先頭`N`個の要素に対してデストラクタを呼び出す(function template)	C++17
`ranges::uninitialized_default_construct`	未初期化領域の範囲の各要素をデフォルト構築する(function template)	C++20
`ranges::uninitialized_default_construct_n`	未初期化領域の範囲のうち、先頭`N`個の要素をデフォルト構築する(function template)	C++20
`ranges::uninitialized_value_construct`	未初期化領域の範囲の各要素配置を値構築する(function template)	C++20
`ranges::uninitialized_value_construct_n`	未初期化領域の範囲のうち、先頭`N`個の要素を値構築する(function template)	C++20
`ranges::uninitialized_copy`	未初期化領域の範囲を配置`new`で初期化してコピー出力する(function template)	C++20
`ranges::uninitialized_copy_n`	未初期化領域の範囲のうち、先頭`N`個の要素を配置`new`で初期化してコピー出力する(function template)	C++20
`ranges::uninitialized_move`	未初期化領域の範囲を配置`new`で初期化してムーブ出力する(function template)	C++20
`ranges::uninitialized_move_n`	未初期化領域の範囲のうち、先頭`N`個の要素を配置`new`で初期化してムーブ出力する(function template)	C++20
`ranges::uninitialized_fill`	未初期化領域の範囲を、指定された値で配置`new`する(function template)	C++20
`ranges::uninitialized_fill_n`	未初期化領域の範囲のうち、先頭`N`個の要素を指定された値で配置`new`する(function template)	C++20
`ranges::construct_at`	コンストラクタを呼び出す(function template)	C++20
`ranges::destroy_at`	デストラクタを呼び出す(function template)	C++20
`ranges::destroy`	範囲の各要素に対してデストラクタを呼び出す(function template)	C++20
`ranges::destroy_n`	範囲のうち、先頭`N`個の要素に対してデストラクタを呼び出す(function template)	C++20
`raw_storage_iterator`	未初期化領域に書き込むための出力イテレータ(class template)	C++17から非推奨 C++20で削除
`get_temporary_buffer`	短期的なメモリ領域を確保する(function template)	C++17から非推奨 C++20で削除
`return_temporary_buffer`	`get_temporary_buffer()`で確保された領域を解放する(function)	C++17から非推奨 C++20で削除

スマートポインタ

名前	説明	対応バージョン
`shared_ptr`	共有方式スマートポインタ(class template)	C++11
`make_shared`	`shared_ptr`を構築するヘルパ関数(function template)	C++11
`make_shared_for_overwrite`	`shared_ptr`を構築するヘルパ関数(function template)	C++20
`allocate_shared`	アロケータを指定して`shared_ptr`を構築するヘルパ関数(function template)	C++11
`allocate_shared_for_overwrite`	アロケータを指定して`shared_ptr`を構築するヘルパ関数(function template)	C++20
`enable_shared_from_this`	`this`を指す`shared_ptr`を可能にする(class template)	C++11
`weak_ptr`	`shared_ptr`のインスタンス監視(class template)	C++11
`bad_weak_ptr`	`weak_ptr`から投げられる例外クラス(class template)	C++11
`owner_less`	所有権ベースの小なり比較(class template)	C++11
`unique_ptr`	専有方式スマートポインタ(class template)	C++11
`make_unique`	`unique_ptr`を構築するヘルパ関数(function template)	C++14
`make_unique_for_overwrite`	`unique_ptr`を構築するヘルパ関数(function template)	C++20
`default_delete`	`unique_ptr`のデフォルトの削除子(class template)	C++11
`auto_ptr`	古い専有方式スマートポインタ(class template)	C++11から非推奨 C++17で削除

スマートポインタアダプタ

名前	説明	対応バージョン
`out_ptr_t`	スマートポインタへの出力サポート(class template)	C++23
`out_ptr`	スマートポインタへの出力サポートヘルパ関数(function template)	C++23
`inout_ptr_t`	スマートポインタへの入出力サポート(class template)	C++23
`inout_ptr`	スマートポインタへの入出力サポートヘルパ関数(function template)	C++23

値の意味論をもつ間接ストレージ

名前	説明	対応バージョン
`indirect`	動的確保したオブジェクトに値の意味論をもたせるクラス(class template)	C++26
`polymorphic`	動的確保したオブジェクトに値の意味論をもたせ、派生型を多態的に保持するクラス(class template)	C++26

スマートポインタのアトミック操作

名前	説明	対応バージョン
`template<class T> struct atomic`	`atomic`クラスの先行宣言 (class template)	C++20
`template<class T> struct atomic<shared_ptr<T>>;`	`atomic`クラスの`shared_ptr`に対する特殊化 (class template)	C++20
`template<class T> struct atomic<weak_ptr<T>>;`	`atomic`クラスの`weak_ptr`に対する特殊化 (class template)	C++20
`atomic_is_lock_free`	`shared_ptr`に対するアトミック操作がロックフリーに振る舞うことができるかを調べる (function template)	C++11 C++20で非推奨
`atomic_load`	`shared_ptr`の値をアトミックに読み込む (function template)	C++11 C++20で非推奨
`atomic_load_explicit`	メモリオーダーを指定して、`shared_ptr`の値をアトミックに読み込む (function template)	C++11 C++20で非推奨
`atomic_store`	`shared_ptr`値をアトミックに書き込む (function template)	C++11 C++20で非推奨
`atomic_store_explicit`	メモリオーダーを指定して、`shared_ptr`の値をアトミックに書き込む (function template)	C++11 C++20で非推奨
`atomic_exchange`	`shared_ptr`の値をアトミックに入れ替える (function template)	C++11 C++20で非推奨
`atomic_exchange_explicit`	メモリオーダーを指定して、`shared_ptr`の値をアトミックに入れ替える (function template)	C++11 C++20で非推奨
`atomic_compare_exchange_weak`	弱い比較で`shared_ptr`の値の入れ替えをアトミックに行う (function template)	C++11 C++20で非推奨
`atomic_compare_exchange_strong`	強い比較で`shared_ptr`の値の入れ替えをアトミックに行う (function template)	C++11 C++20で非推奨
`atomic_compare_exchange_weak_explicit`	弱い比較でメモリオーダーを指定して、`shared_ptr`の値の入れ替えをアトミックに行う (function template)	C++11 C++20で非推奨
`atomic_compare_exchange_strong_explicit`	強い比較でメモリオーダーを指定して、`shared_ptr`の値の入れ替えをアトミックに行う (function template)	C++11 C++20で非推奨

ポインタのユーティリティ

名前	説明	対応バージョン
`pointer_traits`	ポインタの型特性(class template)	C++11
`to_address`	ポインタと見なせるオブジェクトからアドレスを取得する (function template)	C++20
`addressof`	変数のアドレスを必ず取得する(function template)	C++11
`align`	アライメント調整された領域を得る(function)	C++11
`assume_aligned`	コンパイラへアライメントのヒントを与える(function template)	C++20
`is_sufficiently_aligned`	ポインタのアライメントを判定する(function template)	C++26
`start_lifetime_as`	オブジェクトの生存期間を開始することを明示する(function template)	C++23
`start_lifetime_as_array`	配列オブジェクトの生存期間を開始することを明示する(function template)	C++23

ガベージコレクション支援（C++23で削除）

名前	説明	対応バージョン
`pointer_safety`	ポインタ安全性について実装/挙動を示す列挙型(enum class)	C++11 C++23で削除
`get_pointer_safety`	処理系の、ポインタ安全性についての実装/挙動を取得する(function)	C++11 C++23で削除
`declare_reachable`	ポインタが到達可能であることを宣言する(function)	C++11 C++23で削除
`undeclare_reachable`	ポインタが到達可能であるという宣言を削除する(function template)	C++11 C++23で削除
`declare_no_pointers`	指定された範囲のポインタが、追跡可能ではないことを宣言する(function)	C++11 C++23で削除
`undeclare_no_pointers`	`declare_no_pointers`で宣言された範囲を無効化する(function)	C++11 C++23で削除

参照

indirect -- C++26対応としてindirectとpolymorphicのリファレンスを作成 #1430

2026-06-22T16:01:50+09:00

diff --git a/reference/memory/indirect.md b/reference/memory/indirect.md
new file mode 100644
index 000000000..50bd4fd58
--- /dev/null
+++ b/reference/memory/indirect.md
@@ -0,0 +1,165 @@
+# indirect
+* memory[meta header]
+* std[meta namespace]
+* class template[meta id-type]
+* cpp26[meta cpp]
+
+```cpp
+namespace std {
+  template <class T, class Allocator = allocator<T>>
+  class indirect;
+
+  namespace pmr {
+    template <class T>
+    using indirect = std::indirect<T, polymorphic_allocator<T>>;
+  }
+}
+```
+* allocator[link allocator.md]
+* polymorphic_allocator[link /reference/memory_resource/polymorphic_allocator.md]
+
+## 概要
+`std::indirect`クラスは、動的確保したオブジェクトに値の意味論をもたせる型である。
+
+ポインタやスマートポインタは参照の意味論をもつため、クラスのメンバとして使うとコピーや`const`の伝播が正しく行われず、クラスの特殊メンバ関数を正しく生成できないことがある。
+
+`std::indirect`クラスは所有するオブジェクトを動的確保しつつ、以下のように値型として振る舞う：
+
+- ディープコピー: `std::indirect`オブジェクトをコピーすると、所有するオブジェクト`T`がそのコピーコンストラクタによって複製される
+- `const`の伝播: `const`なアクセス経路から所有オブジェクトにアクセスすると、所有オブジェクトにも`const`が伝播する（`operator*`/`operator->`に`const`版と非`const`版がある）
+- 不完全型のサポート: テンプレートパラメータ`T`は不完全型でもよい。これにより、再帰的なデータ構造を表現できる
+
+これらの性質によって、`std::indirect`クラスのオブジェクトはクラスのメンバとして保持するのに適しており、コンパイラによる特殊メンバ関数の自動生成と協調して動作する。
+
+所有オブジェクトを持たない状態を「無効値状態 (valueless state)」と呼ぶ。`std::indirect`オブジェクトが無効値状態になるのは、ムーブ後に空となった場合のみである。無効値状態のオブジェクトに対する`operator*`や`operator->`の呼び出しは未定義動作を引き起こす。無効値状態かどうかは[`valueless_after_move()`](indirect/valueless_after_move.md)メンバ関数で判定できる。
+
+派生型のオブジェクトを多態的に保持したい場合は、[`std::polymorphic`](polymorphic.md)クラスを使用する。
+
+
+## テンプレートパラメータ制約
+- `Allocator`はCpp17Allocator要件を満たすこと
+- [`std::allocator_traits`](/reference/memory/allocator_traits.md)`<Allocator>::value_type`が`T`と同じ型であること
+
+
+## 適格要件
+- 以下のいずれかの場合に、プログラムは不適格となる
+    - `T`がオブジェクト型でない
+    - 配列型である
+    - (CV修飾された) [`std::in_place_t`](/reference/utility/in_place_t.md)である
+    - (CV修飾された) [`std::in_place_type_t`](/reference/utility/in_place_type_t.md)の特殊化である
+- `std::indirect`の明示的特殊化・部分特殊化をユーザーが宣言した場合、動作は未定義である
+
+
+## メンバ関数
+### 構築・破棄
+
+| 名前 | 説明 | 対応バージョン |
+|------|------|----------------|
+| [`(constructor)`](indirect/op_constructor.md) | コンストラクタ | C++26 |
+| [`(destructor)`](indirect/op_destructor.md) | デストラクタ | C++26 |
+| [`operator=`](indirect/op_assign.md) | 代入演算子 | C++26 |
+
+### 値へのアクセス
+
+| 名前 | 説明 | 対応バージョン |
+|------|------|----------------|
+| [`operator*`](indirect/op_deref.md) | 所有するオブジェクトへの参照を取得する | C++26 |
+| [`operator->`](indirect/op_arrow.md) | 所有するオブジェクトのメンバへアクセスする | C++26 |
+| [`valueless_after_move`](indirect/valueless_after_move.md) | 無効値状態かどうかを判定する | C++26 |
+
+### その他
+
+| 名前 | 説明 | 対応バージョン |
+|------|------|----------------|
+| [`get_allocator`](indirect/get_allocator.md) | アロケータを取得する | C++26 |
+| [`swap`](indirect/swap.md) | 他の`indirect`オブジェクトと値を交換する | C++26 |
+
+
+## メンバ型
+
+| 名前 | 定義 | 対応バージョン |
+|------|------|----------------|
+| `value_type` | `T` | C++26 |
+| `allocator_type` | `Allocator` | C++26 |
+| `pointer` | [`allocator_traits`](/reference/memory/allocator_traits.md)`<Allocator>::pointer` | C++26 |
+| `const_pointer` | [`allocator_traits`](/reference/memory/allocator_traits.md)`<Allocator>::const_pointer` | C++26 |
+
+
+## 非メンバ（*Hidden friends*）関数
+
+| 名前 | 説明 | 対応バージョン |
+|------|------|----------------|
+| [`swap`](indirect/swap_free.md) | 2つの`indirect`オブジェクトを交換する | C++26 |
+
+### 比較演算子
+
+| 名前 | 説明 | 対応バージョン |
+|------|------|----------------|
+| [`operator==`](indirect/op_equal.md) | 等値比較を行う | C++26 |
+| [`operator<=>`](indirect/op_compare_3way.md) | 三方比較を行う | C++26 |
+
+`operator==`から`operator!=`が、`operator<=>`から`operator<` / `operator<=` / `operator>` / `operator>=`が導出される。
+
+
+## 推論補助
+
+| 名前 | 説明 | 対応バージョン |
+|------|------|----------------|
+| [`(deduction_guide)`](indirect/op_deduction_guide.md) | クラステンプレートの推論補助 | C++26 |
+
+
+## ハッシュサポート
+
+| 名前 | 説明 | 対応バージョン |
+|------|------|----------------|
+| [`hash`](indirect/hash.md) | `hash`クラスの特殊化 | C++26 |
+
+
+## 例
+```cpp example
+#include <cassert>
+#include <memory>
+
+int main()
+{
+  // 動的確保したintを、値の意味論で保持する
+  std::indirect<int> a{42};
+  assert(*a == 42);
+
+  // コピーは所有オブジェクトのディープコピー
+  std::indirect<int> b = a;
+  *b = 10;
+  assert(*a == 42); // aは影響を受けない
+  assert(*b == 10);
+
+  // 比較は所有オブジェクトの比較に転送される
+  assert(a == std::indirect<int>{42});
+  assert(b < a);
+}
+```
+* std::indirect[color ff0000]
+
+### 出力
+```
+```
+
+
+## バージョン
+### 言語
+- C++26
+
+### 処理系
+- [Clang](/implementation.md#clang): 22 [mark noimpl]
+- [GCC](/implementation.md#gcc): 16.1 [mark verified]
+- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl]
+
+
+## 関連項目
+- [`std::polymorphic`](polymorphic.md) 派生型を多態的に保持する値型
+- [`std::unique_ptr`](unique_ptr.md) 所有権をもつが参照の意味論をもつスマートポインタ
+- [`std::optional`](/reference/optional/optional.md) 動的確保せずに無効値状態を表現する型
+
+
+## 参照
+- [P3019R14 `indirect` and `polymorphic`: Vocabulary Types for Composite Class Design](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3019r14.pdf)
+    - C++26で`indirect`と`polymorphic`が追加された

get_allocator -- C++26対応としてindirectとpolymorphicのリファレンスを作成 #1430

2026-06-22T16:01:50+09:00

diff --git a/reference/memory/indirect/get_allocator.md b/reference/memory/indirect/get_allocator.md
new file mode 100644
index 000000000..f51c173bc
--- /dev/null
+++ b/reference/memory/indirect/get_allocator.md
@@ -0,0 +1,39 @@
+# get_allocator
+* memory[meta header]
+* std[meta namespace]
+* indirect[meta class]
+* function[meta id-type]
+* cpp26[meta cpp]
+
+```cpp
+constexpr allocator_type get_allocator() const noexcept;
+```
+
+## 概要
+このオブジェクトが使用するアロケータを取得する。
+
+
+## 戻り値
+所有するアロケータのコピー。
+
+
+## 例外
+投げない。
+
+
+## バージョン
+### 言語
+- C++26
+
+### 処理系
+- [Clang](/implementation.md#clang): 22 [mark noimpl]
+- [GCC](/implementation.md#gcc): 16.1 [mark verified]
+- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl]
+
+
+## 関連項目
+- [`std::indirect`](../indirect.md)
+
+
+## 参照
+- [P3019R14 `indirect` and `polymorphic`: Vocabulary Types for Composite Class Design](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3019r14.pdf)

hash -- C++26対応としてindirectとpolymorphicのリファレンスを作成 #1430

2026-06-22T16:01:50+09:00

diff --git a/reference/memory/indirect/hash.md b/reference/memory/indirect/hash.md
new file mode 100644
index 000000000..6aa893188
--- /dev/null
+++ b/reference/memory/indirect/hash.md
@@ -0,0 +1,66 @@
+# hash
+* memory[meta header]
+* std[meta namespace]
+* indirect[meta class]
+* class template[meta id-type]
+* cpp26[meta cpp]
+
+```cpp
+namespace std {
+  template <class T, class Allocator>
+  struct hash<indirect<T, Allocator>>;
+}
+```
+* hash[link /reference/functional/hash.md]
+
+## 概要
+[`std::hash`](/reference/functional/hash.md)クラスの、`std::indirect`に対する特殊化。
+
+この特殊化は、`hash<T>`が有効である場合にのみ有効となる。
+
+
+## 効果
+`indirect<T, Allocator>`型のオブジェクト`i`に対して、`hash<indirect<T, Allocator>>()(i)`は、`i`が無効値状態でなければ`hash<T>()(*i)`と同じ値を返し、無効値状態であれば処理系定義の値を返す。
+
+
+## 備考
+メンバ関数が`noexcept`である保証はない。
+
+
+## 例
+```cpp example
+#include <cassert>
+#include <functional>
+#include <memory>
+
+int main()
+{
+  std::indirect<int> a{42};
+  // 所有する値のハッシュ値と一致する
+  assert((std::hash<std::indirect<int>>{}(a) == std::hash<int>{}(42)));
+}
+```
+* std::indirect[color ff0000]
+* std::hash[link /reference/functional/hash.md]
+
+### 出力
+```
+```
+
+
+## バージョン
+### 言語
+- C++26
+
+### 処理系
+- [Clang](/implementation.md#clang): 22 [mark noimpl]
+- [GCC](/implementation.md#gcc): 16.1 [mark verified]
+- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl]
+
+
+## 関連項目
+- [`std::indirect`](../indirect.md)
+
+
+## 参照
+- [P3019R14 `indirect` and `polymorphic`: Vocabulary Types for Composite Class Design](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3019r14.pdf)

operator-> -- C++26対応としてindirectとpolymorphicのリファレンスを作成 #1430

2026-06-22T16:01:50+09:00

diff --git a/reference/memory/indirect/op_arrow.md b/reference/memory/indirect/op_arrow.md
new file mode 100644
index 000000000..a04a30351
--- /dev/null
+++ b/reference/memory/indirect/op_arrow.md
@@ -0,0 +1,65 @@
+# operator->
+* memory[meta header]
+* std[meta namespace]
+* indirect[meta class]
+* function[meta id-type]
+* cpp26[meta cpp]
+
+```cpp
+constexpr const_pointer operator->() const noexcept; // (1)
+constexpr pointer operator->() noexcept;             // (2)
+```
+
+## 概要
+所有するオブジェクトのメンバへアクセスするためのポインタを取得する。
+
+
+## 事前条件
+`*this`が無効値状態でないこと。
+
+
+## 戻り値
+所有するオブジェクトを指すポインタ。
+
+
+## 例外
+投げない。
+
+
+## 例
+```cpp example
+#include <cassert>
+#include <memory>
+#include <string>
+
+int main()
+{
+  std::indirect<std::string> s{std::string{"hello"}};
+  assert(s->size() == 5);  // 所有するstringのメンバにアクセス
+  s->push_back('!');
+  assert(*s == "hello!");
+}
+```
+* std::indirect[color ff0000]
+
+### 出力
+```
+```
+
+
+## バージョン
+### 言語
+- C++26
+
+### 処理系
+- [Clang](/implementation.md#clang): 22 [mark noimpl]
+- [GCC](/implementation.md#gcc): 16.1 [mark verified]
+- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl]
+
+
+## 関連項目
+- [`std::indirect`](../indirect.md)
+
+
+## 参照
+- [P3019R14 `indirect` and `polymorphic`: Vocabulary Types for Composite Class Design](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3019r14.pdf)

代入演算子 -- C++26対応としてindirectとpolymorphicのリファレンスを作成 #1430

2026-06-22T16:01:50+09:00

diff --git a/reference/memory/indirect/op_assign.md b/reference/memory/indirect/op_assign.md
new file mode 100644
index 000000000..7048d1eda
--- /dev/null
+++ b/reference/memory/indirect/op_assign.md
@@ -0,0 +1,97 @@
+# 代入演算子
+* memory[meta header]
+* std[meta namespace]
+* indirect[meta class]
+* function[meta id-type]
+* cpp26[meta cpp]
+
+```cpp
+constexpr indirect& operator=(const indirect& other);              // (1)
+constexpr indirect& operator=(indirect&& other) noexcept(see below); // (2)
+template <class U = T>
+constexpr indirect& operator=(U&& u);                              // (3)
+```
+
+## 概要
+- (1) : コピー代入。`other`が所有するオブジェクトをディープコピーする。
+- (2) : ムーブ代入。`other`から所有権を移す。
+- (3) : 所有するオブジェクトに値`u`を代入する。
+
+
+## テンプレートパラメータ制約
+- (3) : [`remove_cvref_t`](/reference/type_traits/remove_cvref.md)`<U>`が`indirect`でなく、[`is_constructible_v`](/reference/type_traits/is_constructible.md)`<T, U>`と[`is_assignable_v`](/reference/type_traits/is_assignable.md)`<T&, U>`がともに`true`であること。
+
+
+## 適格要件
+- (1) : [`is_copy_assignable_v`](/reference/type_traits/is_copy_assignable.md)`<T>`と[`is_copy_constructible_v`](/reference/type_traits/is_copy_constructible.md)`<T>`がともに`true`であること。
+- (2) : [`is_copy_constructible_v`](/reference/type_traits/is_copy_constructible.md)`<T>`が`true`であること。
+
+
+## 効果
+- (1) : `other`が無効値状態であれば`*this`も無効値状態にする。そうでなければ、アロケータの伝播規則に従い、`other`が所有するオブジェクトのコピーを`*this`がもつようにする。
+- (2) : `other`が無効値状態であれば`*this`も無効値状態にする。そうでなければ、所有権を移すかムーブ構築する。`other`は無効値状態となる。
+- (3) : `*this`が無効値状態であれば`u`から`T`を構築して所有する。そうでなければ`**this = std::forward<U>(u)`と等価。
+
+
+## 戻り値
+`*this`への参照。
+
+
+## 例外
+- (1) : 強い例外安全性を保証する。例外が送出された場合、[`this->valueless_after_move()`](valueless_after_move.md)の結果は変化しない。
+- (2) : 以下と等価な`noexcept`指定を持つ：
+```cpp
+noexcept(allocator_traits<Allocator>::propagate_on_container_move_assignment::value ||
+         allocator_traits<Allocator>::is_always_equal::value)
+```
+* allocator_traits[link /reference/memory/allocator_traits.md]
+
+
+## 例
+```cpp example
+#include <cassert>
+#include <memory>
+
+int main()
+{
+  std::indirect<int> a{1};
+  std::indirect<int> b{2};
+
+  a = b;                  // (1) コピー代入（ディープコピー）
+  assert(*a == 2);
+  *a = 3;
+  assert(*b == 2);        // bは影響を受けない
+
+  a = 10;                 // (3) 値の代入
+  assert(*a == 10);
+
+  a = std::move(b);       // (2) ムーブ代入
+  assert(*a == 2);
+  assert(b.valueless_after_move());
+}
+```
+* std::indirect[color ff0000]
+* std::move[link /reference/utility/move.md]
+* valueless_after_move[link valueless_after_move.md]
+
+### 出力
+```
+```
+
+
+## バージョン
+### 言語
+- C++26
+
+### 処理系
+- [Clang](/implementation.md#clang): 22 [mark noimpl]
+- [GCC](/implementation.md#gcc): 16.1 [mark verified]
+- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl]
+
+
+## 関連項目
+- [`std::indirect`](../indirect.md)
+
+
+## 参照
+- [P3019R14 `indirect` and `polymorphic`: Vocabulary Types for Composite Class Design](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3019r14.pdf)

operator<=> -- C++26対応としてindirectとpolymorphicのリファレンスを作成 #1430

2026-06-22T16:01:50+09:00

diff --git a/reference/memory/indirect/op_compare_3way.md b/reference/memory/indirect/op_compare_3way.md
new file mode 100644
index 000000000..021ff8c0d
--- /dev/null
+++ b/reference/memory/indirect/op_compare_3way.md
@@ -0,0 +1,72 @@
+# operator<=>
+* memory[meta header]
+* std[meta namespace]
+* indirect[meta class]
+* function[meta id-type]
+* cpp26[meta cpp]
+
+```cpp
+template <class U, class AA>
+friend constexpr auto operator<=>(
+  const indirect& lhs, const indirect<U, AA>& rhs)
+    -> synth-three-way-result<T, U>; // (1)
+
+template <class U>
+friend constexpr auto operator<=>(
+  const indirect& lhs, const U& rhs)
+    -> synth-three-way-result<T, U>; // (2)
+```
+
+## 概要
+- (1) : 2つの`indirect`オブジェクトが所有する値を三方比較する。
+- (2) : `indirect`オブジェクトが所有する値と、別の値`rhs`を三方比較する。
+
+いずれも*Hidden friends*として定義される。
+
+
+## 戻り値
+- (1) : `lhs`と`rhs`のいずれかが無効値状態であれば`!lhs.valueless_after_move() <=> !rhs.valueless_after_move()`、そうでなければ`synth-three-way(*lhs, *rhs)`。
+- (2) : `lhs`が無効値状態であれば[`std::strong_ordering::less`](/reference/compare/strong_ordering.md)、そうでなければ`synth-three-way(*lhs, rhs)`。
+
+
+## 備考
+この演算子により、`operator<` / `operator<=` / `operator>` / `operator>=`が使用可能になる。
+
+
+## 例
+```cpp example
+#include <cassert>
+#include <memory>
+
+int main()
+{
+  std::indirect<int> a{1};
+  std::indirect<int> b{2};
+  assert(a < b);          // (1) indirect同士の比較
+  assert((a <=> b) < 0);
+  assert(a < 2);          // (2) 値との比較
+}
+```
+* std::indirect[color ff0000]
+
+### 出力
+```
+```
+
+
+## バージョン
+### 言語
+- C++26
+
+### 処理系
+- [Clang](/implementation.md#clang): 22 [mark noimpl]
+- [GCC](/implementation.md#gcc): 16.1 [mark verified]
+- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl]
+
+
+## 関連項目
+- [`std::indirect`](../indirect.md)
+
+
+## 参照
+- [P3019R14 `indirect` and `polymorphic`: Vocabulary Types for Composite Class Design](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3019r14.pdf)

コンストラクタ -- C++26対応としてindirectとpolymorphicのリファレンスを作成 #1430

2026-06-22T16:01:50+09:00

diff --git a/reference/memory/indirect/op_constructor.md b/reference/memory/indirect/op_constructor.md
new file mode 100644
index 000000000..756c50dc8
--- /dev/null
+++ b/reference/memory/indirect/op_constructor.md
@@ -0,0 +1,156 @@
+# コンストラクタ
+* memory[meta header]
+* std[meta namespace]
+* indirect[meta class]
+* function[meta id-type]
+* cpp26[meta cpp]
+
+```cpp
+explicit constexpr
+  indirect();                          // (1)
+
+explicit constexpr
+  indirect(allocator_arg_t,
+           const Allocator& a);        // (2)
+
+constexpr
+  indirect(const indirect& other);     // (3)
+
+constexpr
+  indirect(allocator_arg_t,
+           const Allocator& a,
+           const indirect& other);     // (4)
+
+constexpr
+  indirect(indirect&& other) noexcept; // (5)
+
+constexpr
+  indirect(allocator_arg_t,
+           const Allocator& a,
+           indirect&& other) noexcept(see below); // (6)
+
+template <class U = T>
+explicit constexpr
+  indirect(U&& u);                     // (7)
+
+template <class U = T>
+explicit constexpr
+  indirect(allocator_arg_t,
+           const Allocator& a, U&& u); // (8)
+
+template <class... Us>
+explicit constexpr
+  indirect(in_place_t,
+           Us&&... us);                // (9)
+
+template <class... Us>
+explicit constexpr
+  indirect(allocator_arg_t,
+           const Allocator& a,
+           in_place_t,
+           Us&&... us);                // (10)
+
+template <class I, class... Us>
+explicit constexpr
+  indirect(in_place_t,
+           initializer_list<I> ilist,
+           Us&&... us);                // (11)
+
+template <class I, class... Us>
+explicit constexpr
+  indirect(allocator_arg_t,
+           const Allocator& a,
+           in_place_t,
+           initializer_list<I> ilist,
+           Us&&... us);                // (12)
+```
+* allocator_arg_t[link /reference/memory/allocator_arg_t.md]
+* in_place_t[link /reference/utility/in_place_t.md]
+* initializer_list[link /reference/initializer_list/initializer_list.md]
+
+## 概要
+`indirect`オブジェクトを構築する。`allocator_arg_t`を第1引数に取るオーバーロードは、使用するアロケータ`a`を明示的に指定する。
+
+- (1), (2) : デフォルトコンストラクタ。`T`をデフォルト構築して所有する。
+- (3), (4) : コピーコンストラクタ。`other`が所有するオブジェクトをディープコピーして所有する。`other`が無効値状態の場合、構築されるオブジェクトも無効値状態となる。
+- (5), (6) : ムーブコンストラクタ。`other`が所有するオブジェクトの所有権を移す。ムーブ後の`other`は無効値状態となる。
+- (7), (8) : 単一の引数`u`から`T`を構築して所有する。
+- (9), (10) : `in_place_t`をマーカーとして、引数`us...`から`T`を直接構築して所有する。
+- (11), (12) : `in_place_t`をマーカーとして、初期化子リストと引数`us...`から`T`を直接構築して所有する。
+
+
+## テンプレートパラメータ制約
+- (7), (8) : [`remove_cvref_t`](/reference/type_traits/remove_cvref.md)`<U>`が`indirect`でも`in_place_t`でもなく、かつ[`is_constructible_v`](/reference/type_traits/is_constructible.md)`<T, U>`が`true`であること。(7)はさらに[`is_default_constructible_v`](/reference/type_traits/is_default_constructible.md)`<Allocator>`が`true`であること。
+- (9), (10) : [`is_constructible_v`](/reference/type_traits/is_constructible.md)`<T, Us...>`が`true`であること。(9)はさらに[`is_default_constructible_v`](/reference/type_traits/is_default_constructible.md)`<Allocator>`が`true`であること。
+- (11), (12) : [`is_constructible_v`](/reference/type_traits/is_constructible.md)`<T, initializer_list<I>&, Us...>`が`true`であること。(11)はさらに[`is_default_constructible_v`](/reference/type_traits/is_default_constructible.md)`<Allocator>`が`true`であること。
+
+
+## 適格要件
+- (1), (2) : [`is_default_constructible_v`](/reference/type_traits/is_default_constructible.md)`<T>`が`true`であること。
+- (3), (4) : [`is_copy_constructible_v`](/reference/type_traits/is_copy_constructible.md)`<T>`が`true`であること。
+- (6) : [`allocator_traits`](/reference/memory/allocator_traits.md)`<Allocator>::is_always_equal::value`が`false`の場合、`T`が完全型であること。
+
+
+## 例外
+- すべてのオーバーロード : [`allocator_traits`](/reference/memory/allocator_traits.md)`<Allocator>::allocate()`または[`allocator_traits`](/reference/memory/allocator_traits.md)`<Allocator>::construct()`が例外を送出した場合を除いて、例外を送出しない。
+- (6) : 以下と等価な`noexcept`指定を持つ：
+```cpp
+noexcept(allocator_traits<Allocator>::is_always_equal::value)
+```
+* allocator_traits[link /reference/memory/allocator_traits.md]
+
+
+## 事後条件
+- (5), (6) : `other`は無効値状態となる。
+
+
+## 例
+```cpp example
+#include <cassert>
+#include <memory>
+#include <string>
+#include <utility>
+
+int main()
+{
+  std::indirect<int> a;                          // (1) デフォルト構築
+  assert(*a == 0);
+
+  std::indirect<int> b{42};                       // (7) 単一の引数から構築
+  assert(*b == 42);
+
+  std::indirect<std::string> c{std::in_place, 3, 'x'}; // (9) in_placeで直接構築
+  assert(*c == "xxx");
+
+  std::indirect<int> d = b;                       // (3) コピー構築（ディープコピー）
+  assert(*d == 42);
+
+  std::indirect<int> e = std::move(d);            // (5) ムーブ構築
+  assert(*e == 42);
+  assert(d.valueless_after_move());               // ムーブ後は無効値状態
+}
+```
+* std::indirect[color ff0000]
+* std::in_place[link /reference/utility/in_place_t.md]
+
+### 出力
+```
+```
+
+
+## バージョン
+### 言語
+- C++26
+
+### 処理系
+- [Clang](/implementation.md#clang): 22 [mark noimpl]
+- [GCC](/implementation.md#gcc): 16.1 [mark verified]
+- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl]
+
+
+## 関連項目
+- [`std::indirect`](../indirect.md)
+
+
+## 参照
+- [P3019R14 `indirect` and `polymorphic`: Vocabulary Types for Composite Class Design](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3019r14.pdf)

推論補助 -- C++26対応としてindirectとpolymorphicのリファレンスを作成 #1430

2026-06-22T16:01:50+09:00

diff --git a/reference/memory/indirect/op_deduction_guide.md b/reference/memory/indirect/op_deduction_guide.md
new file mode 100644
index 000000000..e1544a47b
--- /dev/null
+++ b/reference/memory/indirect/op_deduction_guide.md
@@ -0,0 +1,59 @@
+# 推論補助
+* memory[meta header]
+* std[meta namespace]
+* indirect[meta class]
+* function[meta id-type]
+* cpp26[meta cpp]
+
+```cpp
+template <class Value>
+indirect(Value) -> indirect<Value>; // (1)
+
+template <class Allocator, class Value>
+indirect(allocator_arg_t, Allocator, Value)
+  -> indirect<Value,
+       typename allocator_traits<Allocator>::template rebind_alloc<Value>>; // (2)
+```
+* allocator_arg_t[link /reference/memory/allocator_arg_t.md]
+
+## 概要
+`std::indirect`クラステンプレートの型推論を補助する。
+
+- (1) : 単一の値から`indirect`を構築する場合、その値の型を`T`として推論する。
+- (2) : アロケータと値から構築する場合、値の型を`T`とし、アロケータを`Value`向けに`rebind`した型を`Allocator`として推論する。
+
+
+## 例
+```cpp example
+#include <memory>
+#include <type_traits>
+
+int main()
+{
+  std::indirect a{42};
+  static_assert(std::is_same_v<decltype(a), std::indirect<int>>);
+}
+```
+* std::indirect[color ff0000]
+
+### 出力
+```
+```
+
+
+## バージョン
+### 言語
+- C++26
+
+### 処理系
+- [Clang](/implementation.md#clang): 22 [mark noimpl]
+- [GCC](/implementation.md#gcc): 16.1 [mark verified]
+- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl]
+
+
+## 関連項目
+- [`std::indirect`](../indirect.md)
+
+
+## 参照
+- [P3019R14 `indirect` and `polymorphic`: Vocabulary Types for Composite Class Design](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3019r14.pdf)

operator* -- C++26対応としてindirectとpolymorphicのリファレンスを作成 #1430

2026-06-22T16:01:50+09:00

diff --git a/reference/memory/indirect/op_deref.md b/reference/memory/indirect/op_deref.md
new file mode 100644
index 000000000..ef08fcf8a
--- /dev/null
+++ b/reference/memory/indirect/op_deref.md
@@ -0,0 +1,72 @@
+# operator*
+* memory[meta header]
+* std[meta namespace]
+* indirect[meta class]
+* function[meta id-type]
+* cpp26[meta cpp]
+
+```cpp
+constexpr const T& operator*() const & noexcept;   // (1)
+constexpr T& operator*() & noexcept;               // (2)
+constexpr const T&& operator*() const && noexcept; // (3)
+constexpr T&& operator*() && noexcept;             // (4)
+```
+
+## 概要
+所有するオブジェクトへの参照を取得する。`const`なアクセス経路では`const`が所有オブジェクトに伝播する。
+
+
+## 事前条件
+`*this`が無効値状態でないこと。
+
+
+## 戻り値
+- (1), (2) : 所有するオブジェクトへの参照。
+- (3), (4) : 所有するオブジェクトへの右辺値参照（`std::move(*p)`）。
+
+
+## 例外
+投げない。
+
+
+## 例
+```cpp example
+#include <cassert>
+#include <memory>
+#include <type_traits>
+
+int main()
+{
+  std::indirect<int> a{42};
+  assert(*a == 42);       // 参照の取得
+  *a = 10;                // 非const版で書き換え
+  assert(*a == 10);
+
+  // constなアクセス経路ではconstが伝播する
+  const std::indirect<int> b{5};
+  static_assert(std::is_same_v<decltype(*b), const int&>);
+}
+```
+* std::indirect[color ff0000]
+
+### 出力
+```
+```
+
+
+## バージョン
+### 言語
+- C++26
+
+### 処理系
+- [Clang](/implementation.md#clang): 22 [mark noimpl]
+- [GCC](/implementation.md#gcc): 16.1 [mark verified]
+- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl]
+
+
+## 関連項目
+- [`std::indirect`](../indirect.md)
+
+
+## 参照
+- [P3019R14 `indirect` and `polymorphic`: Vocabulary Types for Composite Class Design](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3019r14.pdf)

デストラクタ -- C++26対応としてindirectとpolymorphicのリファレンスを作成 #1430

2026-06-22T16:01:50+09:00

diff --git a/reference/memory/indirect/op_destructor.md b/reference/memory/indirect/op_destructor.md
new file mode 100644
index 000000000..4769f7624
--- /dev/null
+++ b/reference/memory/indirect/op_destructor.md
@@ -0,0 +1,39 @@
+# デストラクタ
+* memory[meta header]
+* std[meta namespace]
+* indirect[meta class]
+* function[meta id-type]
+* cpp26[meta cpp]
+
+```cpp
+constexpr ~indirect();
+```
+
+## 概要
+`indirect`オブジェクトを破棄する。
+
+
+## 適格要件
+`T`は完全型であること。
+
+
+## 効果
+`*this`が無効値状態でなければ、所有するオブジェクトを[`allocator_traits`](/reference/memory/allocator_traits.md)`<Allocator>::destroy`で破棄し、ストレージを解放する。
+
+
+## バージョン
+### 言語
+- C++26
+
+### 処理系
+- [Clang](/implementation.md#clang): 22 [mark noimpl]
+- [GCC](/implementation.md#gcc): 16.1 [mark verified]
+- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl]
+
+
+## 関連項目
+- [`std::indirect`](../indirect.md)
+
+
+## 参照
+- [P3019R14 `indirect` and `polymorphic`: Vocabulary Types for Composite Class Design](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3019r14.pdf)

operator== -- C++26対応としてindirectとpolymorphicのリファレンスを作成 #1430

2026-06-22T16:01:50+09:00

diff --git a/reference/memory/indirect/op_equal.md b/reference/memory/indirect/op_equal.md
new file mode 100644
index 000000000..91417707f
--- /dev/null
+++ b/reference/memory/indirect/op_equal.md
@@ -0,0 +1,75 @@
+# operator==
+* memory[meta header]
+* std[meta namespace]
+* indirect[meta class]
+* function[meta id-type]
+* cpp26[meta cpp]
+
+```cpp
+template <class U, class AA>
+friend constexpr bool operator==(
+  const indirect& lhs, const indirect<U, AA>& rhs) noexcept(see below); // (1)
+
+template <class U>
+friend constexpr bool operator==(
+  const indirect& lhs, const U& rhs) noexcept(see below);               // (2)
+```
+
+## 概要
+- (1) : 2つの`indirect`オブジェクトが所有する値を等値比較する。
+- (2) : `indirect`オブジェクトが所有する値と、別の値`rhs`を等値比較する。
+
+いずれも*Hidden friends*として定義される。
+
+
+## 適格要件
+- (1) : 式`*lhs == *rhs`が適格であり、その結果が`bool`に変換可能であること。
+- (2) : 式`*lhs == rhs`が適格であり、その結果が`bool`に変換可能であること。
+
+
+## 戻り値
+- (1) : `lhs`と`rhs`のいずれかが無効値状態であれば`lhs.valueless_after_move() == rhs.valueless_after_move()`、そうでなければ`*lhs == *rhs`。
+- (2) : `lhs`が無効値状態であれば`false`、そうでなければ`*lhs == rhs`。
+
+
+## 備考
+この演算子により、`operator!=`が使用可能になる。
+
+
+## 例
+```cpp example
+#include <cassert>
+#include <memory>
+
+int main()
+{
+  std::indirect<int> a{42};
+  std::indirect<int> b{42};
+  assert(a == b);    // (1) indirect同士の比較
+  assert(a == 42);   // (2) 値との比較
+  assert(a != 0);
+}
+```
+* std::indirect[color ff0000]
+
+### 出力
+```
+```
+
+
+## バージョン
+### 言語
+- C++26
+
+### 処理系
+- [Clang](/implementation.md#clang): 22 [mark noimpl]
+- [GCC](/implementation.md#gcc): 16.1 [mark verified]
+- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl]
+
+
+## 関連項目
+- [`std::indirect`](../indirect.md)
+
+
+## 参照
+- [P3019R14 `indirect` and `polymorphic`: Vocabulary Types for Composite Class Design](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3019r14.pdf)

swap -- C++26対応としてindirectとpolymorphicのリファレンスを作成 #1430

2026-06-22T16:01:50+09:00

diff --git a/reference/memory/indirect/swap.md b/reference/memory/indirect/swap.md
new file mode 100644
index 000000000..f48250199
--- /dev/null
+++ b/reference/memory/indirect/swap.md
@@ -0,0 +1,69 @@
+# swap
+* memory[meta header]
+* std[meta namespace]
+* indirect[meta class]
+* function[meta id-type]
+* cpp26[meta cpp]
+
+```cpp
+constexpr void swap(indirect& other) noexcept(see below);
+```
+
+## 概要
+`*this`と`other`の状態を交換する。所有オブジェクトまたは無効値状態を交換する。
+
+
+## 事前条件
+[`allocator_traits`](/reference/memory/allocator_traits.md)`<Allocator>::propagate_on_container_swap::value`が`true`の場合、`Allocator`はCpp17Swappable要件を満たすこと。そうでない場合、`get_allocator() == other.get_allocator()`が`true`であること。
+
+
+## 効果
+`*this`と`other`の状態（所有オブジェクトまたは無効値状態）を交換する。`propagate_on_container_swap::value`が`true`の場合はアロケータも交換する。所有オブジェクトに対して直接`swap`を呼ぶわけではない。
+
+
+## 例外
+以下と等価な`noexcept`指定を持つ：
+
+```cpp
+noexcept(allocator_traits<Allocator>::propagate_on_container_swap::value ||
+         allocator_traits<Allocator>::is_always_equal::value)
+```
+* allocator_traits[link /reference/memory/allocator_traits.md]
+
+
+## 例
+```cpp example
+#include <cassert>
+#include <memory>
+
+int main()
+{
+  std::indirect<int> a{1};
+  std::indirect<int> b{2};
+  a.swap(b);
+  assert(*a == 2 && *b == 1);
+}
+```
+* std::indirect[color ff0000]
+
+### 出力
+```
+```
+
+
+## バージョン
+### 言語
+- C++26
+
+### 処理系
+- [Clang](/implementation.md#clang): 22 [mark noimpl]
+- [GCC](/implementation.md#gcc): 16.1 [mark verified]
+- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl]
+
+
+## 関連項目
+- [`std::indirect`](../indirect.md)
+
+
+## 参照
+- [P3019R14 `indirect` and `polymorphic`: Vocabulary Types for Composite Class Design](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3019r14.pdf)

swap -- C++26対応としてindirectとpolymorphicのリファレンスを作成 #1430

2026-06-22T16:01:50+09:00

diff --git a/reference/memory/indirect/swap_free.md b/reference/memory/indirect/swap_free.md
new file mode 100644
index 000000000..b85df0bd7
--- /dev/null
+++ b/reference/memory/indirect/swap_free.md
@@ -0,0 +1,63 @@
+# swap
+* memory[meta header]
+* std[meta namespace]
+* indirect[meta class]
+* function[meta id-type]
+* cpp26[meta cpp]
+
+```cpp
+friend constexpr void swap(indirect& lhs, indirect& rhs) noexcept(see below);
+```
+
+## 概要
+2つの`indirect`オブジェクトを交換する。*Hidden friends*として定義される。
+
+
+## 効果
+`lhs.swap(rhs)`と等価。
+
+
+## 例外
+以下と等価な`noexcept`指定を持つ：
+
+```cpp
+noexcept(noexcept(lhs.swap(rhs)))
+```
+
+
+## 例
+```cpp example
+#include <cassert>
+#include <memory>
+
+int main()
+{
+  std::indirect<int> a{1};
+  std::indirect<int> b{2};
+  swap(a, b);   // ADLにより非メンバswapが呼ばれる
+  assert(*a == 2 && *b == 1);
+}
+```
+* std::indirect[color ff0000]
+
+### 出力
+```
+```
+
+
+## バージョン
+### 言語
+- C++26
+
+### 処理系
+- [Clang](/implementation.md#clang): 22 [mark noimpl]
+- [GCC](/implementation.md#gcc): 16.1 [mark verified]
+- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl]
+
+
+## 関連項目
+- [`std::indirect`](../indirect.md)
+
+
+## 参照
+- [P3019R14 `indirect` and `polymorphic`: Vocabulary Types for Composite Class Design](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3019r14.pdf)

valueless_after_move -- C++26対応としてindirectとpolymorphicのリファレンスを作成 #1430

2026-06-22T16:01:50+09:00

diff --git a/reference/memory/indirect/valueless_after_move.md b/reference/memory/indirect/valueless_after_move.md
new file mode 100644
index 000000000..f866a5a8e
--- /dev/null
+++ b/reference/memory/indirect/valueless_after_move.md
@@ -0,0 +1,61 @@
+# valueless_after_move
+* memory[meta header]
+* std[meta namespace]
+* indirect[meta class]
+* function[meta id-type]
+* cpp26[meta cpp]
+
+```cpp
+constexpr bool valueless_after_move() const noexcept;
+```
+
+## 概要
+`*this`が無効値状態かどうかを判定する。`indirect`はムーブされたあとにのみ無効値状態となりうる。
+
+
+## 戻り値
+`*this`が無効値状態であれば`true`、そうでなければ`false`。
+
+
+## 例外
+投げない。
+
+
+## 例
+```cpp example
+#include <cassert>
+#include <memory>
+
+int main()
+{
+  std::indirect<int> a{42};
+  assert(!a.valueless_after_move());
+
+  std::indirect<int> b = std::move(a);
+  assert(a.valueless_after_move());  // ムーブ後は無効値状態
+  assert(!b.valueless_after_move());
+}
+```
+* std::indirect[color ff0000]
+
+### 出力
+```
+```
+
+
+## バージョン
+### 言語
+- C++26
+
+### 処理系
+- [Clang](/implementation.md#clang): 22 [mark noimpl]
+- [GCC](/implementation.md#gcc): 16.1 [mark verified]
+- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl]
+
+
+## 関連項目
+- [`std::indirect`](../indirect.md)
+
+
+## 参照
+- [P3019R14 `indirect` and `polymorphic`: Vocabulary Types for Composite Class Design](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3019r14.pdf)

polymorphic -- C++26対応としてindirectとpolymorphicのリファレンスを作成 #1430

2026-06-22T16:01:50+09:00

diff --git a/reference/memory/polymorphic.md b/reference/memory/polymorphic.md
new file mode 100644
index 000000000..ad7a74aed
--- /dev/null
+++ b/reference/memory/polymorphic.md
@@ -0,0 +1,147 @@
+# polymorphic
+* memory[meta header]
+* std[meta namespace]
+* class template[meta id-type]
+* cpp26[meta cpp]
+
+```cpp
+namespace std {
+  template <class T, class Allocator = allocator<T>>
+  class polymorphic;
+
+  namespace pmr {
+    template <class T>
+    using polymorphic = std::polymorphic<T, polymorphic_allocator<T>>;
+  }
+}
+```
+* allocator[link allocator.md]
+* polymorphic_allocator[link /reference/memory_resource/polymorphic_allocator.md]
+
+## 概要
+`std::polymorphic`クラスは、動的確保したオブジェクトに値の意味論をもたせつつ、`T`から派生した任意の型のオブジェクトを多態的に保持できる型である。
+
+[`std::indirect`](indirect.md)クラスが単一の型`T`のオブジェクトを保持するのに対し、`std::polymorphic<T>`クラスは`T`を基底とする派生型のオブジェクトを保持できる。値型としての性質は`std::indirect`クラスと共通している：
+
+- ディープコピー: `std::polymorphic<T>`クラスのオブジェクトをコピーすると、実際に保持している派生型のオブジェクトが、その派生型のコピーコンストラクタによって複製される（型消去をとおした仮想ディスパッチが用いられる）
+- `const`の伝播: `const`なアクセス経路から所有オブジェクトにアクセスすると、所有オブジェクトにも`const`が伝播する
+- 不完全型のサポート: テンプレートパラメータ`T`は不完全型でもよい
+
+これらの性質によって、`std::polymorphic`クラスは多態的な性質をもつクラスのメンバ変数として適しており、コンパイラによる特殊メンバ関数の自動生成と協調して動作する。
+
+所有オブジェクトを持たない状態を「無効値状態 (valueless state)」と呼ぶ。`std::polymorphic`クラスが無効値状態になるのは、ムーブ後に空となった場合のみである。無効値状態のオブジェクトに対する`operator*`や`operator->`の呼び出しは未定義動作を引き起こす。無効値状態かどうかは[`valueless_after_move()`](polymorphic/valueless_after_move.md)で判定できる。
+
+保持する型の集合が既知である場合は、[`std::variant`](/reference/variant/variant.md)や`indirect<std::variant<...>>`の使用を検討するとよい。
+
+
+## テンプレートパラメータ制約
+- `Allocator`はCpp17Allocator要件を満たすこと。
+- [`allocator_traits`](/reference/memory/allocator_traits.md)`<Allocator>::value_type`が`T`と同じ型であること
+
+
+## 適格要件
+- 以下のいずれかの場合に、プログラムは不適格となる
+    - `T`がオブジェクト型でない
+    - 配列型である
+    - (CV修飾された) [`std::in_place_t`](/reference/utility/in_place_t.md)である
+    - (CV修飾された) [`std::in_place_type_t`](/reference/utility/in_place_type_t.md)の特殊化である
+    - CV修飾された型である
+- `std::polymorphic`の明示的特殊化・部分特殊化をユーザーが宣言した場合、動作は未定義である
+
+
+## メンバ関数
+### 構築・破棄
+
+| 名前 | 説明 | 対応バージョン |
+|------|------|----------------|
+| [`(constructor)`](polymorphic/op_constructor.md) | コンストラクタ | C++26 |
+| [`(destructor)`](polymorphic/op_destructor.md) | デストラクタ | C++26 |
+| [`operator=`](polymorphic/op_assign.md) | 代入演算子 | C++26 |
+
+### 値へのアクセス
+
+| 名前 | 説明 | 対応バージョン |
+|------|------|----------------|
+| [`operator*`](polymorphic/op_deref.md) | 所有するオブジェクトへの参照を取得する | C++26 |
+| [`operator->`](polymorphic/op_arrow.md) | 所有するオブジェクトのメンバへアクセスする | C++26 |
+| [`valueless_after_move`](polymorphic/valueless_after_move.md) | 無効値状態かどうかを判定する | C++26 |
+
+### その他
+
+| 名前 | 説明 | 対応バージョン |
+|------|------|----------------|
+| [`get_allocator`](polymorphic/get_allocator.md) | アロケータを取得する | C++26 |
+| [`swap`](polymorphic/swap.md) | 他の`polymorphic`オブジェクトと値を交換する | C++26 |
+
+
+## メンバ型
+
+| 名前 | 定義 | 対応バージョン |
+|------|------|----------------|
+| `value_type` | `T` | C++26 |
+| `allocator_type` | `Allocator` | C++26 |
+| `pointer` | [`allocator_traits`](/reference/memory/allocator_traits.md)`<Allocator>::pointer` | C++26 |
+| `const_pointer` | [`allocator_traits`](/reference/memory/allocator_traits.md)`<Allocator>::const_pointer` | C++26 |
+
+
+## 非メンバ（*Hidden friends*）関数
+
+| 名前 | 説明 | 対応バージョン |
+|------|------|----------------|
+| [`swap`](polymorphic/swap_free.md) | 2つの`polymorphic`オブジェクトを交換する | C++26 |
+
+
+## 例
+```cpp example
+#include <cassert>
+#include <memory>
+
+struct Shape {
+  virtual ~Shape() = default;
+  virtual int area() const = 0;
+};
+
+struct Square : Shape {
+  int side;
+  Square(int s) : side(s) {}
+  int area() const override { return side * side; }
+};
+
+int main()
+{
+  // Shapeから派生したSquareを、値の意味論で多態的に保持する
+  std::polymorphic<Shape> a{std::in_place_type<Square>, 3};
+  assert(a->area() == 9);
+
+  // コピーは派生型(Square)のディープコピー
+  std::polymorphic<Shape> b = a;
+  assert(b->area() == 9);
+}
+```
+* std::polymorphic[color ff0000]
+* std::in_place_type[link /reference/utility/in_place_type_t.md]
+
+### 出力
+```
+```
+
+
+## バージョン
+### 言語
+- C++26
+
+### 処理系
+- [Clang](/implementation.md#clang): 22 [mark noimpl]
+- [GCC](/implementation.md#gcc): 16.1 [mark verified]
+- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl]
+
+
+## 関連項目
+- [`std::indirect`](indirect.md) 単一の型を保持する値型
+- [`std::variant`](/reference/variant/variant.md) 既知の型集合から1つを保持する型
+- [`std::unique_ptr`](unique_ptr.md) 多態的な所有権をもつが参照の意味論をもつスマートポインタ
+
+
+## 参照
+- [P3019R14 `indirect` and `polymorphic`: Vocabulary Types for Composite Class Design](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3019r14.pdf)
+    - C++26で`indirect`と`polymorphic`が追加された

get_allocator -- C++26対応としてindirectとpolymorphicのリファレンスを作成 #1430

2026-06-22T16:01:50+09:00

diff --git a/reference/memory/polymorphic/get_allocator.md b/reference/memory/polymorphic/get_allocator.md
new file mode 100644
index 000000000..c7981d7a0
--- /dev/null
+++ b/reference/memory/polymorphic/get_allocator.md
@@ -0,0 +1,39 @@
+# get_allocator
+* memory[meta header]
+* std[meta namespace]
+* polymorphic[meta class]
+* function[meta id-type]
+* cpp26[meta cpp]
+
+```cpp
+constexpr allocator_type get_allocator() const noexcept;
+```
+
+## 概要
+このオブジェクトが使用するアロケータを取得する。
+
+
+## 戻り値
+所有するアロケータのコピー。
+
+
+## 例外
+投げない。
+
+
+## バージョン
+### 言語
+- C++26
+
+### 処理系
+- [Clang](/implementation.md#clang): 22 [mark noimpl]
+- [GCC](/implementation.md#gcc): 16.1 [mark verified]
+- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl]
+
+
+## 関連項目
+- [`std::polymorphic`](../polymorphic.md)
+
+
+## 参照
+- [P3019R14 `indirect` and `polymorphic`: Vocabulary Types for Composite Class Design](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3019r14.pdf)

operator-> -- C++26対応としてindirectとpolymorphicのリファレンスを作成 #1430

2026-06-22T16:01:50+09:00

diff --git a/reference/memory/polymorphic/op_arrow.md b/reference/memory/polymorphic/op_arrow.md
new file mode 100644
index 000000000..fad8e5e62
--- /dev/null
+++ b/reference/memory/polymorphic/op_arrow.md
@@ -0,0 +1,74 @@
+# operator->
+* memory[meta header]
+* std[meta namespace]
+* polymorphic[meta class]
+* function[meta id-type]
+* cpp26[meta cpp]
+
+```cpp
+constexpr const_pointer operator->() const noexcept; // (1)
+constexpr pointer operator->() noexcept;             // (2)
+```
+
+## 概要
+所有するオブジェクトのメンバへ、基底型`T`としてアクセスするためのポインタを取得する。
+
+
+## 事前条件
+`*this`が無効値状態でないこと。
+
+
+## 戻り値
+所有するオブジェクトを指すポインタ。
+
+
+## 例外
+投げない。
+
+
+## 例
+```cpp example
+#include <cassert>
+#include <memory>
+
+struct Base {
+  virtual ~Base() = default;
+  virtual int f() const { return 0; }
+};
+struct Derived : Base {
+  int x = 42;
+  Derived() = default;
+  Derived(int x) : x(x) {}
+  int f() const override { return x; }
+};
+
+int main()
+{
+  std::polymorphic<Base> a{std::in_place_type<Derived>};
+  assert(a->f() == 42);  // 基底型Baseのメンバへアクセス（仮想ディスパッチ）
+}
+```
+* std::polymorphic[color ff0000]
+* std::in_place_type[link /reference/utility/in_place_type_t.md]
+
+### 出力
+```
+```
+
+
+## バージョン
+### 言語
+- C++26
+
+### 処理系
+- [Clang](/implementation.md#clang): 22 [mark noimpl]
+- [GCC](/implementation.md#gcc): 16.1 [mark verified]
+- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl]
+
+
+## 関連項目
+- [`std::polymorphic`](../polymorphic.md)
+
+
+## 参照
+- [P3019R14 `indirect` and `polymorphic`: Vocabulary Types for Composite Class Design](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3019r14.pdf)

代入演算子 -- C++26対応としてindirectとpolymorphicのリファレンスを作成 #1430

2026-06-22T16:01:50+09:00

diff --git a/reference/memory/polymorphic/op_assign.md b/reference/memory/polymorphic/op_assign.md
new file mode 100644
index 000000000..0e472b166
--- /dev/null
+++ b/reference/memory/polymorphic/op_assign.md
@@ -0,0 +1,93 @@
+# 代入演算子
+* memory[meta header]
+* std[meta namespace]
+* polymorphic[meta class]
+* function[meta id-type]
+* cpp26[meta cpp]
+
+```cpp
+constexpr polymorphic& operator=(const polymorphic& other);                // (1)
+constexpr polymorphic& operator=(polymorphic&& other) noexcept(see below); // (2)
+```
+
+## 概要
+- (1) : コピー代入。`other`が保持する派生型のオブジェクトをディープコピーする。
+- (2) : ムーブ代入。`other`から所有権を移す。
+
+
+## 適格要件
+- (1) : `T`は完全型であること。
+
+
+## 効果
+- (1) : `addressof(other) == this`であれば何もしない。そうでなければ、アロケータの伝播規則に従い、`other`が保持するオブジェクトのコピーを`*this`がもつようにする。`other`が無効値状態であれば`*this`も無効値状態にする。
+- (2) : `addressof(other) == this`であれば何もしない。そうでなければ、アロケータの伝播規則に従い、`other`から所有権を移すか、ムーブ構築する。
+
+
+## 戻り値
+`*this`への参照。
+
+
+## 例外
+- (1) : 強い例外安全性を保証する。例外が送出された場合、`*this`や`other`に影響はない。
+- (2) : 以下と等価な`noexcept`指定を持つ：
+
+```cpp
+noexcept(allocator_traits<Allocator>::propagate_on_container_move_assignment::value ||
+         allocator_traits<Allocator>::is_always_equal::value)
+```
+* allocator_traits[link /reference/memory/allocator_traits.md]
+
+
+## 例
+```cpp example
+#include <cassert>
+#include <memory>
+
+struct Base {
+  virtual ~Base() = default;
+  virtual int f() const { return 0; }
+};
+struct Derived : Base {
+  int x = 42;
+  Derived() = default;
+  Derived(int x) : x(x) {}
+  int f() const override { return x; }
+};
+
+int main()
+{
+  std::polymorphic<Base> a{std::in_place_type<Derived>, 1};
+  std::polymorphic<Base> b{std::in_place_type<Derived>, 2};
+
+  a = b;             // (1) コピー代入（派生型のディープコピー）
+  assert(a->f() == 2);
+
+  a = std::move(b);  // (2) ムーブ代入
+  assert(a->f() == 2);
+}
+```
+* std::polymorphic[color ff0000]
+* std::in_place_type[link /reference/utility/in_place_type_t.md]
+
+### 出力
+```
+```
+
+
+## バージョン
+### 言語
+- C++26
+
+### 処理系
+- [Clang](/implementation.md#clang): 22 [mark noimpl]
+- [GCC](/implementation.md#gcc): 16.1 [mark verified]
+- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl]
+
+
+## 関連項目
+- [`std::polymorphic`](../polymorphic.md)
+
+
+## 参照
+- [P3019R14 `indirect` and `polymorphic`: Vocabulary Types for Composite Class Design](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3019r14.pdf)

コンストラクタ -- C++26対応としてindirectとpolymorphicのリファレンスを作成 #1430

2026-06-22T16:01:50+09:00

diff --git a/reference/memory/polymorphic/op_constructor.md b/reference/memory/polymorphic/op_constructor.md
new file mode 100644
index 000000000..4a0e01af7
--- /dev/null
+++ b/reference/memory/polymorphic/op_constructor.md
@@ -0,0 +1,158 @@
+# コンストラクタ
+* memory[meta header]
+* std[meta namespace]
+* polymorphic[meta class]
+* function[meta id-type]
+* cpp26[meta cpp]
+
+```cpp
+explicit constexpr 
+  polymorphic();                             // (1)
+
+explicit constexpr
+  polymorphic(allocator_arg_t,
+              const Allocator& a);           // (2)
+
+constexpr
+  polymorphic(const polymorphic& other);     // (3)
+
+constexpr
+  polymorphic(allocator_arg_t,
+              const Allocator& a,
+              const polymorphic& other);     // (4)
+
+constexpr
+  polymorphic(polymorphic&& other) noexcept; // (5)
+
+constexpr
+  polymorphic(allocator_arg_t,
+              const Allocator& a,
+              polymorphic&& other) noexcept(see below); // (6)
+
+template <class U = T>
+explicit constexpr
+  polymorphic(U&& u);                          // (7)
+
+template <class U = T>
+explicit constexpr
+  polymorphic(allocator_arg_t,
+              const Allocator& a,
+              U&& u);                          // (8)
+
+template <class U, class... Ts>
+explicit constexpr
+  polymorphic(in_place_type_t<U>,
+              Ts&&... ts);                     // (9)
+
+template <class U, class... Ts>
+explicit constexpr
+  polymorphic(allocator_arg_t,
+              const Allocator& a,
+              in_place_type_t<U>, Ts&&... ts); // (10)
+
+template <class U, class I, class... Us>
+explicit constexpr
+  polymorphic(in_place_type_t<U>,
+              initializer_list<I> ilist,
+              Us&&... us);                    // (11)
+
+template <class U, class I, class... Us>
+explicit constexpr
+  polymorphic(allocator_arg_t, const Allocator& a,
+              in_place_type_t<U>,
+              initializer_list<I> ilist, Us&&... us); // (12)
+```
+* allocator_arg_t[link /reference/memory/allocator_arg_t.md]
+* in_place_type_t[link /reference/utility/in_place_type_t.md]
+* initializer_list[link /reference/initializer_list/initializer_list.md]
+
+## 概要
+`polymorphic`オブジェクトを構築する。`allocator_arg_t`を第1引数に取るオーバーロードは、使用するアロケータ`a`を明示的に指定する。
+
+- (1), (2) : デフォルトコンストラクタ。`T`をデフォルト構築して所有する。
+- (3), (4) : コピーコンストラクタ。`other`が保持する派生型のオブジェクトをディープコピーして所有する。`other`が無効値状態の場合、構築されるオブジェクトも無効値状態となる。
+- (5), (6) : ムーブコンストラクタ。`other`が保持するオブジェクトの所有権を移す。
+- (7), (8) : 単一の引数`u`から、その型`U`（`T`から派生していてもよい）のオブジェクトを構築して所有する。
+- (9), (10) : `in_place_type_t<U>`をマーカーとして、型`U`のオブジェクトを引数`ts...`から直接構築して所有する。
+- (11), (12) : `in_place_type_t<U>`をマーカーとして、型`U`のオブジェクトを初期化子リストと引数`us...`から直接構築して所有する。
+
+
+## テンプレートパラメータ制約
+- (7), (8) : [`remove_cvref_t`](/reference/type_traits/remove_cvref.md)`<U>`を`UU`とするとき、`UU`が`polymorphic`でも`in_place_type_t`の特殊化でもなく、[`derived_from`](/reference/concepts/derived_from.md)`<UU, T>`、[`is_constructible_v`](/reference/type_traits/is_constructible.md)`<UU, U>`、[`is_copy_constructible_v`](/reference/type_traits/is_copy_constructible.md)`<UU>`がいずれも`true`であること。(7)はさらに[`is_default_constructible_v`](/reference/type_traits/is_default_constructible.md)`<Allocator>`が`true`であること。
+- (9), (10) : [`is_same_v`](/reference/type_traits/is_same.md)`<`[`remove_cvref_t`](/reference/type_traits/remove_cvref.md)`<U>, U>`、[`derived_from`](/reference/concepts/derived_from.md)`<U, T>`、[`is_constructible_v`](/reference/type_traits/is_constructible.md)`<U, Ts...>`、[`is_copy_constructible_v`](/reference/type_traits/is_copy_constructible.md)`<U>`がいずれも`true`であること。(9)はさらに[`is_default_constructible_v`](/reference/type_traits/is_default_constructible.md)`<Allocator>`が`true`であること。
+- (11), (12) : [`is_same_v`](/reference/type_traits/is_same.md)`<`[`remove_cvref_t`](/reference/type_traits/remove_cvref.md)`<U>, U>`、[`derived_from`](/reference/concepts/derived_from.md)`<U, T>`、[`is_constructible_v`](/reference/type_traits/is_constructible.md)`<U, initializer_list<I>&, Us...>`、[`is_copy_constructible_v`](/reference/type_traits/is_copy_constructible.md)`<U>`がいずれも`true`であること。(11)はさらに[`is_default_constructible_v`](/reference/type_traits/is_default_constructible.md)`<Allocator>`が`true`であること。
+
+
+## 適格要件
+- (1), (2) : [`is_default_constructible_v`](/reference/type_traits/is_default_constructible.md)`<T>`と[`is_copy_constructible_v`](/reference/type_traits/is_copy_constructible.md)`<T>`がともに`true`であること。
+
+
+## 効果
+所有するオブジェクトを、指定された型・引数とアロケータ`alloc`を用いて構築する。`allocator_arg_t`版は`alloc`を`a`で初期化する。
+
+
+## 例外
+- すべてのオーバーロード : [`allocator_traits`](/reference/memory/allocator_traits.md)`<Allocator>::allocate`または[`allocator_traits`](/reference/memory/allocator_traits.md)`<Allocator>::construct`が例外を送出した場合を除いて、例外を送出しない。
+- (6) : 以下と等価な`noexcept`指定を持つ：
+
+```cpp
+noexcept(allocator_traits<Allocator>::is_always_equal::value)
+```
+* allocator_traits[link /reference/memory/allocator_traits.md]
+
+
+## 例
+```cpp example
+#include <cassert>
+#include <memory>
+
+struct Base {
+  virtual ~Base() = default;
+  virtual int f() const { return 0; }
+};
+struct Derived : Base {
+  int x = 42;
+  Derived() = default;
+  Derived(int x) : x(x) {}
+  int f() const override { return x; }
+};
+
+int main()
+{
+  // (9) in_place_typeで派生型Derivedを直接構築
+  std::polymorphic<Base> a{std::in_place_type<Derived>};
+  assert(a->f() == 42);
+
+  // (7) 派生型の値から構築
+  std::polymorphic<Base> b{Derived{10}};
+  assert(b->f() == 10);
+
+  // (3) コピー構築（派生型Derivedのディープコピー）
+  std::polymorphic<Base> c = a;
+  assert(c->f() == 42);
+}
+```
+* std::polymorphic[color ff0000]
+* std::in_place_type[link /reference/utility/in_place_type_t.md]
+
+### 出力
+```
+```
+
+
+## バージョン
+### 言語
+- C++26
+
+### 処理系
+- [Clang](/implementation.md#clang): 22 [mark noimpl]
+- [GCC](/implementation.md#gcc): 16.1 [mark verified]
+- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl]
+
+
+## 関連項目
+- [`std::polymorphic`](../polymorphic.md)
+
+
+## 参照
+- [P3019R14 `indirect` and `polymorphic`: Vocabulary Types for Composite Class Design](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3019r14.pdf)

operator* -- C++26対応としてindirectとpolymorphicのリファレンスを作成 #1430

2026-06-22T16:01:50+09:00

diff --git a/reference/memory/polymorphic/op_deref.md b/reference/memory/polymorphic/op_deref.md
new file mode 100644
index 000000000..bfc03fe52
--- /dev/null
+++ b/reference/memory/polymorphic/op_deref.md
@@ -0,0 +1,75 @@
+# operator*
+* memory[meta header]
+* std[meta namespace]
+* polymorphic[meta class]
+* function[meta id-type]
+* cpp26[meta cpp]
+
+```cpp
+constexpr const T& operator*() const noexcept; // (1)
+constexpr T& operator*() noexcept;             // (2)
+```
+
+## 概要
+所有するオブジェクトへの、基底型`T`としての参照を取得する。`const`なアクセス経路では`const`が所有オブジェクトに伝播する。
+
+
+## 事前条件
+`*this`が無効値状態でないこと。
+
+
+## 戻り値
+所有するオブジェクトへの`T`型としての参照。
+
+
+## 例外
+投げない。
+
+
+## 例
+```cpp example
+#include <cassert>
+#include <memory>
+
+struct Base {
+  virtual ~Base() = default;
+  virtual int f() const { return 0; }
+};
+struct Derived : Base {
+  int x = 42;
+  Derived() = default;
+  Derived(int x) : x(x) {}
+  int f() const override { return x; }
+};
+
+int main()
+{
+  std::polymorphic<Base> a{std::in_place_type<Derived>};
+  Base& r = *a;          // 基底型Baseとしての参照を取得
+  assert(r.f() == 42);   // 仮想関数で派生型Derivedの実装が呼ばれる
+}
+```
+* std::polymorphic[color ff0000]
+* std::in_place_type[link /reference/utility/in_place_type_t.md]
+
+### 出力
+```
+```
+
+
+## バージョン
+### 言語
+- C++26
+
+### 処理系
+- [Clang](/implementation.md#clang): 22 [mark noimpl]
+- [GCC](/implementation.md#gcc): 16.1 [mark verified]
+- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl]
+
+
+## 関連項目
+- [`std::polymorphic`](../polymorphic.md)
+
+
+## 参照
+- [P3019R14 `indirect` and `polymorphic`: Vocabulary Types for Composite Class Design](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3019r14.pdf)

デストラクタ -- C++26対応としてindirectとpolymorphicのリファレンスを作成 #1430

2026-06-22T16:01:50+09:00

diff --git a/reference/memory/polymorphic/op_destructor.md b/reference/memory/polymorphic/op_destructor.md
new file mode 100644
index 000000000..94fba4547
--- /dev/null
+++ b/reference/memory/polymorphic/op_destructor.md
@@ -0,0 +1,39 @@
+# デストラクタ
+* memory[meta header]
+* std[meta namespace]
+* polymorphic[meta class]
+* function[meta id-type]
+* cpp26[meta cpp]
+
+```cpp
+constexpr ~polymorphic();
+```
+
+## 概要
+`polymorphic`オブジェクトを破棄する。
+
+
+## 適格要件
+`T`は完全型であること。
+
+
+## 効果
+`*this`が無効値状態でなければ、所有するオブジェクトを[`allocator_traits`](/reference/memory/allocator_traits.md)`<Allocator>::destroy`で破棄し、ストレージを解放する。
+
+
+## バージョン
+### 言語
+- C++26
+
+### 処理系
+- [Clang](/implementation.md#clang): 22 [mark noimpl]
+- [GCC](/implementation.md#gcc): 16.1 [mark verified]
+- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl]
+
+
+## 関連項目
+- [`std::polymorphic`](../polymorphic.md)
+
+
+## 参照
+- [P3019R14 `indirect` and `polymorphic`: Vocabulary Types for Composite Class Design](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3019r14.pdf)

swap -- C++26対応としてindirectとpolymorphicのリファレンスを作成 #1430

2026-06-22T16:01:50+09:00

diff --git a/reference/memory/polymorphic/swap.md b/reference/memory/polymorphic/swap.md
new file mode 100644
index 000000000..695d15cce
--- /dev/null
+++ b/reference/memory/polymorphic/swap.md
@@ -0,0 +1,74 @@
+# swap
+* memory[meta header]
+* std[meta namespace]
+* polymorphic[meta class]
+* function[meta id-type]
+* cpp26[meta cpp]
+
+```cpp
+constexpr void swap(polymorphic& other) noexcept(see below);
+```
+
+## 概要
+`*this`と`other`の状態を交換する。所有オブジェクトまたは無効値状態を交換する。
+
+
+## 事前条件
+[`allocator_traits`](/reference/memory/allocator_traits.md)`<Allocator>::propagate_on_container_swap::value`が`true`の場合、`Allocator`は*Cpp17Swappable*要件を満たすこと。そうでない場合、`get_allocator() == other.get_allocator()`が`true`であること。
+
+
+## 効果
+`*this`と`other`の状態を交換する。`propagate_on_container_swap::value`が`true`の場合はアロケータも交換する。
+
+
+## 例外
+以下と等価な`noexcept`指定を持つ：
+
+```cpp
+noexcept(allocator_traits<Allocator>::propagate_on_container_swap::value ||
+         allocator_traits<Allocator>::is_always_equal::value)
+```
+* allocator_traits[link /reference/memory/allocator_traits.md]
+
+
+## 例
+```cpp example
+#include <cassert>
+#include <memory>
+
+struct Base { virtual ~Base() = default; virtual int f() const = 0; };
+struct D1 : Base { int f() const override { return 1; } };
+struct D2 : Base { int f() const override { return 2; } };
+
+int main()
+{
+  std::polymorphic<Base> a{std::in_place_type<D1>};
+  std::polymorphic<Base> b{std::in_place_type<D2>};
+  a.swap(b);
+  assert(a->f() == 2 && b->f() == 1);
+}
+```
+* std::polymorphic[color ff0000]
+* std::in_place_type[link /reference/utility/in_place_type_t.md]
+
+### 出力
+```
+```
+
+
+## バージョン
+### 言語
+- C++26
+
+### 処理系
+- [Clang](/implementation.md#clang): 22 [mark noimpl]
+- [GCC](/implementation.md#gcc): 16.1 [mark verified]
+- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl]
+
+
+## 関連項目
+- [`std::polymorphic`](../polymorphic.md)
+
+
+## 参照
+- [P3019R14 `indirect` and `polymorphic`: Vocabulary Types for Composite Class Design](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3019r14.pdf)

swap -- C++26対応としてindirectとpolymorphicのリファレンスを作成 #1430

2026-06-22T16:01:50+09:00

diff --git a/reference/memory/polymorphic/swap_free.md b/reference/memory/polymorphic/swap_free.md
new file mode 100644
index 000000000..f680893d8
--- /dev/null
+++ b/reference/memory/polymorphic/swap_free.md
@@ -0,0 +1,68 @@
+# swap
+* memory[meta header]
+* std[meta namespace]
+* polymorphic[meta class]
+* function[meta id-type]
+* cpp26[meta cpp]
+
+```cpp
+friend constexpr void swap(polymorphic& lhs, polymorphic& rhs) noexcept(see below);
+```
+
+## 概要
+2つの`polymorphic`オブジェクトを交換する。*Hidden friends*として定義される。
+
+
+## 効果
+`lhs.swap(rhs)`と等価。
+
+
+## 例外
+以下と等価な`noexcept`指定を持つ：
+
+```cpp
+noexcept(noexcept(lhs.swap(rhs)))
+```
+
+
+## 例
+```cpp example
+#include <cassert>
+#include <memory>
+
+struct Base { virtual ~Base() = default; virtual int f() const = 0; };
+struct D1 : Base { int f() const override { return 1; } };
+struct D2 : Base { int f() const override { return 2; } };
+
+int main()
+{
+  std::polymorphic<Base> a{std::in_place_type<D1>};
+  std::polymorphic<Base> b{std::in_place_type<D2>};
+  swap(a, b);   // ADLにより非メンバswapが呼ばれる
+  assert(a->f() == 2 && b->f() == 1);
+}
+```
+* std::polymorphic[color ff0000]
+* std::in_place_type[link /reference/utility/in_place_type_t.md]
+
+### 出力
+```
+```
+
+
+## バージョン
+### 言語
+- C++26
+
+### 処理系
+- [Clang](/implementation.md#clang): 22 [mark noimpl]
+- [GCC](/implementation.md#gcc): 16.1 [mark verified]
+- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl]
+
+
+## 関連項目
+- [`std::polymorphic`](../polymorphic.md)
+
+
+## 参照
+- [P3019R14 `indirect` and `polymorphic`: Vocabulary Types for Composite Class Design](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3019r14.pdf)

valueless_after_move -- C++26対応としてindirectとpolymorphicのリファレンスを作成 #1430

2026-06-22T16:01:50+09:00

diff --git a/reference/memory/polymorphic/valueless_after_move.md b/reference/memory/polymorphic/valueless_after_move.md
new file mode 100644
index 000000000..687f983f7
--- /dev/null
+++ b/reference/memory/polymorphic/valueless_after_move.md
@@ -0,0 +1,72 @@
+# valueless_after_move
+* memory[meta header]
+* std[meta namespace]
+* polymorphic[meta class]
+* function[meta id-type]
+* cpp26[meta cpp]
+
+```cpp
+constexpr bool valueless_after_move() const noexcept;
+```
+
+## 概要
+`*this`が無効値状態かどうかを判定する。`polymorphic`はムーブされたあとにのみ無効値状態となりうる。
+
+
+## 戻り値
+`*this`が無効値状態であれば`true`、そうでなければ`false`。
+
+
+## 例外
+投げない。
+
+
+## 例
+```cpp example
+#include <cassert>
+#include <memory>
+
+struct Base {
+  virtual ~Base() = default;
+  virtual int f() const { return 0; }
+};
+struct Derived : Base {
+  int x = 42;
+  Derived() = default;
+  Derived(int x) : x(x) {}
+  int f() const override { return x; }
+};
+
+int main()
+{
+  std::polymorphic<Base> a{std::in_place_type<Derived>};
+  assert(!a.valueless_after_move());
+
+  std::polymorphic<Base> b = std::move(a);
+  assert(a.valueless_after_move());  // ムーブ後は無効値状態
+}
+```
+* std::polymorphic[color ff0000]
+* std::in_place_type[link /reference/utility/in_place_type_t.md]
+
+### 出力
+```
+```
+
+
+## バージョン
+### 言語
+- C++26
+
+### 処理系
+- [Clang](/implementation.md#clang): 22 [mark noimpl]
+- [GCC](/implementation.md#gcc): 16.1 [mark verified]
+- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl]
+
+
+## 関連項目
+- [`std::polymorphic`](../polymorphic.md)
+
+
+## 参照
+- [P3019R14 `indirect` and `polymorphic`: Vocabulary Types for Composite Class Design](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3019r14.pdf)

constant_wrapper -- constant_wrapper: meta aliasタグ追加

2026-06-21T23:39:30+09:00

diff --git a/reference/utility/constant_wrapper.md b/reference/utility/constant_wrapper.md
index d44643773..42db28c1c 100644
--- a/reference/utility/constant_wrapper.md
+++ b/reference/utility/constant_wrapper.md
@@ -3,6 +3,7 @@
 * std[meta namespace]
 * class template[meta id-type]
 * cpp26[meta cpp]
+* cw[meta alias]
 
 ```cpp
 namespace std {