diff --git a/GLOBAL_QUALIFY_LIST.txt b/GLOBAL_QUALIFY_LIST.txt index 658c0ce887..c462dde5eb 100644 --- a/GLOBAL_QUALIFY_LIST.txt +++ b/GLOBAL_QUALIFY_LIST.txt @@ -385,6 +385,8 @@ * [link /reference/unordered_set.md] * std::unordered_set[link /reference/unordered_set/unordered_set.md] * [link /reference/utility.md] + * std::constant_wrapper[link /reference/utility/constant_wrapper.md] + * std::cw[link /reference/utility/constant_wrapper.md] * std::exchange[link /reference/utility/exchange.md] * std::forward_like[link /reference/utility/forward_like.md] * std::forward[link /reference/utility/forward.md] diff --git a/lang/cpp26.md b/lang/cpp26.md index 11ad849456..62800568c6 100644 --- a/lang/cpp26.md +++ b/lang/cpp26.md @@ -516,6 +516,7 @@ C++26とは、2026年中に改訂される予定の、C++バージョンの通 - [``](/reference/utility.md)に、タイムトラベル最適化を抑止するための観測可能ポイントとして[`std::observable_checkpoint()`](/reference/utility/observable_checkpoint.md)を追加 - [`std::exception_ptr`](/reference/exception/exception_ptr.md)を指定した例外型にキャストする[`std::exception_ptr_cast()`](/reference/exception/exception_ptr_cast.md)関数を追加 - [``](/reference/compare.md)に、型の順序を取得する[`std::type_order`](/reference/compare/type_order.md)クラスを追加 +- [``](/reference/utility.md)に、定数を型として包むことで、関数の引数として渡しても定数式として扱えるようにする定数ラッパー[`std::constant_wrapper`](/reference/utility/constant_wrapper.md)クラスと、それを簡潔に生成する変数テンプレート[`std::cw`](/reference/utility/constant_wrapper.md)を追加 ### デバッグ @@ -525,7 +526,6 @@ C++26とは、2026年中に改訂される予定の、C++バージョンの通 ### 型特性 - [``](/reference/type_traits.md)に、共用体の指定されたメンバがアクティブかを定数式で判定するための関数として[`std::is_within_lifetime()`](/reference/type_traits/is_within_lifetime.md)を追加 - [``](/reference/type_traits.md)に、仮想継承の関係を判定する[`std::is_virtual_base_of`](/reference/type_traits/is_virtual_base_of.md)を追加 -- [``](/reference/type_traits.md)に、[`std::integral_constant`](/reference/type_traits/integral_constant.md)クラスを置き換える定数ラッパーとして[`std::constant_wrapper`](/reference/type_traits/constant_wrapper.md.nolink)クラスを追加 - [`std::integer_sequence`](/reference/utility/integer_sequence.md)クラスを[構造化束縛](/lang/cpp17/structured_bindings.md)と[template for文](/lang/cpp26/expansion_statements.md)で使用できるようにするため、タプルインタフェースの特殊化を追加 diff --git a/lang/cpp26/feature_test_macros.md b/lang/cpp26/feature_test_macros.md index 1087a6ab35..df2ad2ab00 100755 --- a/lang/cpp26/feature_test_macros.md +++ b/lang/cpp26/feature_test_macros.md @@ -50,7 +50,7 @@ |`__cpp_lib_bind_front`|`202306L`|[`std::bind_front()`](/reference/functional/bind_front.md)に、非型テンプレート引数として関数を指定するオーバーロードを追加|[``](/reference/functional.md)| |`__cpp_lib_bitset`|`202306L`|[`std::bitset`](/reference/bitset/bitset.md)に、[`std::basic_string_view`](/reference/string_view/basic_string_view.md)を受け取るコンストラクタを追加|[``](/reference/bitset.md)| |`__cpp_lib_chrono`|`202306L`|[``](/reference/chrono.md)のクラスに、ハッシュ値サポートとして[`std::hash`](/reference/functional/hash.md)の特殊化を追加|[``](/reference/chrono.md)| -|`__cpp_lib_constant_wrapper`|`202506L`|[``](/reference/type_traits.md)に[`std::constant_wrapper`](/reference/type_traits/constant_wrapper.md.nolink)を追加|[``](/reference/type_traits.md)| +|`__cpp_lib_constant_wrapper`|`202606L`|[``](/reference/utility.md)に[`std::constant_wrapper`](/reference/utility/constant_wrapper.md)を追加|[``](/reference/utility.md)| |`__cpp_lib_constexpr_algorithms`|`202306L`|[`std::stable_sort()`](/reference/algorithm/stable_sort.md) / [`std::ranges::stable_sort()`](/reference/algorithm/ranges_stable_sort.md)を`constexpr`対応|[``](/reference/algorithm.md), [``](/reference/utility.md)| |`__cpp_lib_constexpr_atomic`|`202411L`|[``](/reference/atomic.md)ライブラリのアトミック操作を`constexpr`対応|[``](/reference/atomic.md)| |`__cpp_lib_constexpr_cmath`|`202306L`|[``](/reference/cmath.md)の関数 (特殊関数と丸めモードに依存する関数以外の全て) を`constexpr`対応|[``](/reference/cmath.md), [``](/reference/cstdlib.md)| diff --git a/reference/mdspan/canonical-index.md b/reference/mdspan/canonical-index.md index bfd46fd8c4..5c51b06c47 100644 --- a/reference/mdspan/canonical-index.md +++ b/reference/mdspan/canonical-index.md @@ -24,7 +24,7 @@ constexpr auto canonical-index(S s); ## 効果 以下と等価 -- `S`が[`integral-constant-like`](/reference/span/integral-constant-like.md)のモデルであるとき、`return` [`cw`](/reference/type_traits/constant_wrapper.md.nolink)`` +- `S`が[`integral-constant-like`](/reference/span/integral-constant-like.md)のモデルであるとき、`return` [`cw`](/reference/utility/constant_wrapper.md)`` - そうではないとき、`return IndexType(`[`std::move`](/reference/utility/move.md)`(s))` diff --git a/reference/mdspan/canonical-slice.md b/reference/mdspan/canonical-slice.md index 9851624efa..f426da7005 100644 --- a/reference/mdspan/canonical-slice.md +++ b/reference/mdspan/canonical-slice.md @@ -57,8 +57,8 @@ if constexpr (is_convertible_v) { * canonical-index[link canonical-index.md] * is_convertible_v[link /reference/type_traits/is_convertible.md] * is_same_v[link /reference/type_traits/is_same.md] -* constant_wrapper[link /reference/type_traits/constant_wrapper.md.nolink] -* cw[link /reference/type_traits/constant_wrapper.md.nolink] +* constant_wrapper[link /reference/utility/constant_wrapper.md] +* cw[link /reference/utility/constant_wrapper.md] * std::move[link /reference/utility/move.md] ここで`is-strided-slice`は、型`S`が[`strided_slice`](strided_slice.md)の特殊化であることを表す説明専用コンセプトとする。 diff --git a/reference/mdspan/layout_left/mapping/submdspan_mapping.md b/reference/mdspan/layout_left/mapping/submdspan_mapping.md index de47a5bb70..6cafa80dce 100644 --- a/reference/mdspan/layout_left/mapping/submdspan_mapping.md +++ b/reference/mdspan/layout_left/mapping/submdspan_mapping.md @@ -48,7 +48,7 @@ friend constexpr auto submdspan_mapping( 下記を満たす型`S`を、単位ストライド幅スライス型と定義する。 -- `S`が[`strided_slice`](../../strided_slice.md)の特殊化であり、`S::stride_type`が[`constant_wrapper`](/reference/type_traits/constant_wrapper.md.nolink)の特殊化かつ`S::stride_type::value`が`1`、または +- `S`が[`strided_slice`](../../strided_slice.md)の特殊化であり、`S::stride_type`が[`constant_wrapper`](/reference/utility/constant_wrapper.md)の特殊化かつ`S::stride_type::value`が`1`、または - `S`が[`full_extent_t`](../../full_extent_t.md) 説明専用の`submdspan-mapping-impl`関数テンプレートは下記の値を返す。 diff --git a/reference/mdspan/layout_left_padded/mapping/submdspan_mapping.md b/reference/mdspan/layout_left_padded/mapping/submdspan_mapping.md index 2cd6724385..ce80de29eb 100644 --- a/reference/mdspan/layout_left_padded/mapping/submdspan_mapping.md +++ b/reference/mdspan/layout_left_padded/mapping/submdspan_mapping.md @@ -48,7 +48,7 @@ friend constexpr auto submdspan_mapping( 下記を満たす型`S`を、単位ストライド幅スライス型と定義する。 -- `S`が[`strided_slice`](../../strided_slice.md)の特殊化であり、`S::stride_type`が[`constant_wrapper`](/reference/type_traits/constant_wrapper.md.nolink)の特殊化かつ`S::stride_type::value`が`1`、または +- `S`が[`strided_slice`](../../strided_slice.md)の特殊化であり、`S::stride_type`が[`constant_wrapper`](/reference/utility/constant_wrapper.md)の特殊化かつ`S::stride_type::value`が`1`、または - `S`が[`full_extent_t`](../../full_extent_t.md) 説明専用の`submdspan-mapping-impl`関数テンプレートは下記の値を返す。 diff --git a/reference/mdspan/layout_right/mapping/submdspan_mapping.md b/reference/mdspan/layout_right/mapping/submdspan_mapping.md index c5d6788afe..a56fc5ac43 100644 --- a/reference/mdspan/layout_right/mapping/submdspan_mapping.md +++ b/reference/mdspan/layout_right/mapping/submdspan_mapping.md @@ -48,7 +48,7 @@ friend constexpr auto submdspan_mapping( 下記を満たす型`S`を、単位ストライド幅スライス型と定義する。 -- `S`が[`strided_slice`](../../strided_slice.md)の特殊化であり、`S::stride_type`が[`constant_wrapper`](/reference/type_traits/constant_wrapper.md.nolink)の特殊化かつ`S::stride_type::value`が`1`、または +- `S`が[`strided_slice`](../../strided_slice.md)の特殊化であり、`S::stride_type`が[`constant_wrapper`](/reference/utility/constant_wrapper.md)の特殊化かつ`S::stride_type::value`が`1`、または - `S`が[`full_extent_t`](../../full_extent_t.md) 説明専用の`submdspan-mapping-impl`関数テンプレートは下記の値を返す。 diff --git a/reference/mdspan/layout_right_padded/mapping/submdspan_mapping.md b/reference/mdspan/layout_right_padded/mapping/submdspan_mapping.md index 783e777928..e2e90d2839 100644 --- a/reference/mdspan/layout_right_padded/mapping/submdspan_mapping.md +++ b/reference/mdspan/layout_right_padded/mapping/submdspan_mapping.md @@ -48,7 +48,7 @@ friend constexpr auto submdspan_mapping( 下記を満たす型`S`を、単位ストライド幅スライス型と定義する。 -- `S`が[`strided_slice`](../../strided_slice.md)の特殊化であり、`S::stride_type`が[`constant_wrapper`](/reference/type_traits/constant_wrapper.md.nolink)の特殊化かつ`S::stride_type::value`が`1`、または +- `S`が[`strided_slice`](../../strided_slice.md)の特殊化であり、`S::stride_type`が[`constant_wrapper`](/reference/utility/constant_wrapper.md)の特殊化かつ`S::stride_type::value`が`1`、または - `S`が[`full_extent_t`](../../full_extent_t.md) 説明専用の`submdspan-mapping-impl`関数テンプレートは下記の値を返す。 diff --git a/reference/mdspan/sliceable-mapping.md b/reference/mdspan/sliceable-mapping.md index a34d437029..f5142a6952 100644 --- a/reference/mdspan/sliceable-mapping.md +++ b/reference/mdspan/sliceable-mapping.md @@ -30,7 +30,7 @@ concept sliceable-mapping = see below; - オブジェクトのパック`invalid_slices` : `sizeof...(invalid_slices) == M_rank`であり、`invalid_slices...[k]`のcv非修飾型が下記いずれでもない整数`k`が存在する - 型`IT` - [`full_extent_t`](full_extent_t.md) - - [`constant_wrapper`](/reference/type_traits/constant_wrapper.md.nolink)の特殊化 + - [`constant_wrapper`](/reference/utility/constant_wrapper.md)の特殊化 - [`strided_slice`](strided_slice.md)の特殊化 下記を満たすとき、型`M`はスライス可能レイアウトマッピング(sliceable layout mapping)要件を満たす。 diff --git a/reference/mdspan/submdspan_canonicalize_slices.md b/reference/mdspan/submdspan_canonicalize_slices.md index 2f58fada7b..bea3e5bd32 100644 --- a/reference/mdspan/submdspan_canonicalize_slices.md +++ b/reference/mdspan/submdspan_canonicalize_slices.md @@ -30,7 +30,7 @@ namespace std { - `(`[`is_convertible_v`](/reference/type_traits/is_convertible.md)` && ...)`が`true` ### 正則`submdspan`スライス型 -符号付きもしくは符号なし整数型`IndexType`に対して、型`S`が`IndexType`もしくは値`0`以上の任意の値`v`を保持する[`constant_wrapper`](/reference/type_traits/constant_wrapper.md.nolink)であるとき、型`S`は`IndexType`の正則`submdspan`インデクス型となる。 +符号付きもしくは符号なし整数型`IndexType`に対して、型`S`が`IndexType`もしくは値`0`以上の任意の値`v`を保持する[`constant_wrapper`](/reference/utility/constant_wrapper.md)であるとき、型`S`は`IndexType`の正則`submdspan`インデクス型となる。 符号付きもしくは符号なし整数型`IndexType`に対して、下記のうちただ1つだけを満たすとき、型`S`は`IndexType`の正則`submdspan`スライス型(canonical `submdspan` slice type)となる。 @@ -38,7 +38,7 @@ namespace std { - `S`が`IndexType`の正則`submdspan`インデクス型である - `S`が[`strided_slice`](strided_slice.md)の特殊化であり、下記を全て満たす - `S::offset_type`, `S::extent_type`, `S::stride_type`が、全て`IndexType`の正則`submdspan`インデクス型である - - `S::stride_type`および`S::extent_type`がいずれも[`constant_wrapper`](/reference/type_traits/constant_wrapper.md.nolink)の特殊化であり、`S::stride_type::value`が`0`より大きい + - `S::stride_type`および`S::extent_type`がいずれも[`constant_wrapper`](/reference/utility/constant_wrapper.md)の特殊化であり、`S::stride_type::value`が`0`より大きい ### 縮約スライス型と`MAP_RANK` ある型が[`full_extent_t`](full_extent_t.md)ないし[`strided_slice`](strided_slice.md)の特殊化いずれでもないとき、縮約スライス型(collapsing slice type)となる。 @@ -49,10 +49,10 @@ namespace std { [`extents`](extents.md)の特殊化である型`E`に対して、型`S`が`E::index_type`の正則スライス型であり、かつ`E::static_extent(k)`に等しい`x`に対して`x`が`dynamic_extent`に等しいか下記を満たすとき、型`S`は`E`の`k`番目次元の有効`submdspan`スライス型(valid `submdspan` slice type)となる。 - `S`が[`strided_slice`](strided_slice.md)の特殊化であるとき : - - `S::offset_type`が[`constant_wrapper`](/reference/type_traits/constant_wrapper.md.nolink)の特殊化であるとき、`S::offset_type::value`が`x`以下 - - `S::extent_type`が[`constant_wrapper`](/reference/type_traits/constant_wrapper.md.nolink)の特殊化であるとき、`S::extent_type::value`が`x`以下 - - `S::offset_type`および`S::extent_type`が[`constant_wrapper`](/reference/type_traits/constant_wrapper.md.nolink)の特殊化であるとき、`S::offset_type::value + S::extent_type::value`が`x`以下 -- `S`が[`constant_wrapper`](/reference/type_traits/constant_wrapper.md.nolink)の特殊化であるとき、`S::value`が`x`より小さい + - `S::offset_type`が[`constant_wrapper`](/reference/utility/constant_wrapper.md)の特殊化であるとき、`S::offset_type::value`が`x`以下 + - `S::extent_type`が[`constant_wrapper`](/reference/utility/constant_wrapper.md)の特殊化であるとき、`S::extent_type::value`が`x`以下 + - `S::offset_type`および`S::extent_type`が[`constant_wrapper`](/reference/utility/constant_wrapper.md)の特殊化であるとき、`S::offset_type::value + S::extent_type::value`が`x`以下 +- `S`が[`constant_wrapper`](/reference/utility/constant_wrapper.md)の特殊化であるとき、`S::value`が`x`より小さい ### 有効`submdspan`スライス [`extents`](extents.md)の特殊化である型`E`のオブジェクト`e`と、型`S`のオブジェクト`s`に対して、下記を満たすとき`s`は`e`の`k`番目次元の有効`submdspan`スライス(valid `submdspan` slice)となる。 diff --git a/reference/mdspan/submdspan_extents.md b/reference/mdspan/submdspan_extents.md index 8467d5db46..087fb07ce1 100644 --- a/reference/mdspan/submdspan_extents.md +++ b/reference/mdspan/submdspan_extents.md @@ -47,8 +47,8 @@ auto [...slices] = submdspan_canonicalize_slices(src, raw_slices...); - [`SubExtents::rank()`](extents/rank.md)が[`MAP_RANK`](submdspan_canonicalize_slices.md)`(slices, Extents::rank())`に等しく、かつ - `slices...[k]`の型が[縮約スライス型(collapsing slice type)](submdspan_canonicalize_slices.md)ではない`Extents`の各次元インデクス`k`に対して、説明用の`S_k`を`slices...[k]`の型としたとき、[`SubExtents::static_extent`](extents/static_extent.md)`(`[`MAP_RANK`](submdspan_canonicalize_slices.md)`(slices, k))`が下記と等しいこと。 - 型`S_k`が[`full_extent_t`](full_extent_t.md)のとき、[`SubExtents::static_extent`](extents/static_extent.md)`(k)`、そうでなければ、 - - 型`S_k`が[`strided_slice`](strided_slice.md)の特殊化かつメンバ型`S_k::extent_type`が[`constant_wrapper`](/reference/type_traits/constant_wrapper.md.nolink)``のとき、値`0`、そうでなければ - - 型`S_k`が[`strided_slice`](strided_slice.md)の特殊化かつメンバ型`extent_type`および`stride_type`がいずれも[`constant_wrapper`](/reference/type_traits/constant_wrapper.md.nolink)の特殊化であるとき、`1 + ((S_k::extent_type::value - 1) / S_k::stride_type::value)` + - 型`S_k`が[`strided_slice`](strided_slice.md)の特殊化かつメンバ型`S_k::extent_type`が[`constant_wrapper`](/reference/utility/constant_wrapper.md)``のとき、値`0`、そうでなければ + - 型`S_k`が[`strided_slice`](strided_slice.md)の特殊化かつメンバ型`extent_type`および`stride_type`がいずれも[`constant_wrapper`](/reference/utility/constant_wrapper.md)の特殊化であるとき、`1 + ((S_k::extent_type::value - 1) / S_k::stride_type::value)` - そうでなければ、[`dynamic_extent`](/reference/span/dynamic_extent.md) 以下を満たす`SubExtents`型の値`ext`を返す。 diff --git a/reference/utility.md b/reference/utility.md index 027556eaf8..8caee1d460 100644 --- a/reference/utility.md +++ b/reference/utility.md @@ -107,6 +107,14 @@ | [`constant_arg`](utility/constant_arg_t.md) | 定数引数を表現するためのタグ値 (variable template) | C++26 | +## 定数のラッパー + +| 名前 | 説明 | 対応バージョン | +|------|------|----------------| +| [`constant_wrapper`](utility/constant_wrapper.md) | 定数を型として包むラッパー (class template) | C++26 | +| [`cw`](utility/constant_wrapper.md) | `constant_wrapper`を簡潔に生成する変数テンプレート (variable template) | C++26 | + + ## コンパイル時の整数シーケンス | 名前 | 説明 | 対応バージョン | diff --git a/reference/utility/constant_wrapper.md b/reference/utility/constant_wrapper.md new file mode 100644 index 0000000000..af91577b6b --- /dev/null +++ b/reference/utility/constant_wrapper.md @@ -0,0 +1,257 @@ +# constant_wrapper +* utility[meta header] +* std[meta namespace] +* class template[meta id-type] +* cpp26[meta cpp] + +```cpp +namespace std { + template + struct constant_wrapper; + + // 型Tが定数として扱えることを表す説明用コンセプト + template + concept constexpr-param = + requires { typename constant_wrapper; }; + + // すべての演算子オーバーロードを提供する説明用の基底クラス + struct cw-operators; + + // constant_wrapperを簡潔に生成する変数テンプレート + template + constexpr auto cw = constant_wrapper{}; +} +``` + +## 概要 +`constant_wrapper`クラステンプレートは、定数`X`を型として包むことで、その値を「型の世界」で扱えるようにするためのラッパーである。 + +`constant_wrapper`のみで構成された式は、それが現れる文脈に関わらず、常にコア定数式として評価される。これによって、通常はテンプレート引数としてしか渡せない定数を、関数の引数として渡しても定数式として利用できるようになる。とくに、テンプレート引数を明示的に指定できないコンストラクタ呼び出しなどで有用である。 + +変数テンプレート[`cw`](#cw)を使うと、`std::constant_wrapper<42>{}`と書く代わりに`std::cw<42>`と簡潔に書ける。 + +```cpp +// 通常の定数を関数引数として受け取り、コンパイル時に計算する +constexpr auto add(auto a, auto b) +{ + return a + b; +} + +auto result = add(std::cw<42>, std::cw<13>); // resultはconstant_wrapper<55>型 +static_assert(result == 55); // resultが定数式でなくても、その値は定数式 +``` + +`constant_wrapper`はあらゆる演算子をオーバーロードしている。オペランドがすべて`constant_wrapper`である場合は、演算結果も`constant_wrapper`になり、「型の世界」にとどまる。オペランドのいずれかが通常の値である場合は、保持する値にアンラップされて通常の演算がおこなわれる。 + +クラステンプレート`constant_wrapper`の2つめのテンプレートパラメータは無名であり、引数依存の名前探索 (ADL) を補助するために存在する。これによって、包んでいる値が引数として適合するオーバーロードを、`constant_wrapper`自身が適合しない場合でも発見できるようになる。 + + +## メンバ関数 + +| 名前 | 説明 | 対応バージョン | +|------|------|----------------| +| `(constructor)` | デフォルトコンストラクタ（暗黙定義） | C++26 | +| [`operator=`](constant_wrapper/op_assign.md) | 代入（`value`が`const`のため`constant_wrapper`では不適格） | C++26 | +| [`operator value_type`](constant_wrapper/op_value_type.md) | 保持する値への変換演算子 | C++26 | +| [`operator()`](constant_wrapper/op_call.md) | 保持する値を関数として呼び出す（静的メンバ関数） | C++26 | +| [`operator[]`](constant_wrapper/op_at.md) | 保持する値に添字アクセスする（静的メンバ関数） | C++26 | + +また、説明用の基底クラス`cw-operators`から以下の擬似的な変更操作を継承する。ただし`constant_wrapper`が保持する`value`は`const`であるため、これらの演算子と上記`operator=`は、保持する値そのものを変更する式（`++value`、`value op= x`、`value = x`）が不適格となり、`constant_wrapper`に対してはオーバーロード解決に参加しない（使用できない）。 + +| 名前 | 説明 | 対応バージョン | +|------|------|----------------| +| [`operator++`](constant_wrapper/op_increment.md) | インクリメント | C++26 | +| [`operator--`](constant_wrapper/op_decrement.md) | デクリメント | C++26 | +| [`operator+=`](constant_wrapper/op_plus_assign.md) | 加算の複合代入 | C++26 | +| [`operator-=`](constant_wrapper/op_minus_assign.md) | 減算の複合代入 | C++26 | +| [`operator*=`](constant_wrapper/op_multiply_assign.md) | 乗算の複合代入 | C++26 | +| [`operator/=`](constant_wrapper/op_divide_assign.md) | 除算の複合代入 | C++26 | +| [`operator%=`](constant_wrapper/op_modulo_assign.md) | 剰余の複合代入 | C++26 | +| [`operator&=`](constant_wrapper/op_and_assign.md) | ビット論理積の複合代入 | C++26 | +| [operator|=](constant_wrapper/op_or_assign.md) | ビット論理和の複合代入 | C++26 | +| [`operator^=`](constant_wrapper/op_xor_assign.md) | ビット排他的論理和の複合代入 | C++26 | +| [`operator<<=`](constant_wrapper/op_left_shift_assign.md) | 左シフトの複合代入 | C++26 | +| [`operator>>=`](constant_wrapper/op_right_shift_assign.md) | 右シフトの複合代入 | C++26 | + + +## メンバ型 + +| 名前 | 説明 | 対応バージョン | +|------|------|----------------| +| `type` | `constant_wrapper`自身を表す型 | C++26 | +| `value_type` | 保持する値の型 `decltype(X)`、すなわちラップした値`X`の型 | C++26 | + +たとえば`std::cw<42>`（`X`は`int`の`42`）の場合、`type`は`std::constant_wrapper<42>`、`value_type`は`int`となる。 + + +## 静的メンバ変数 + +| 名前 | 説明 | 設定される値・型 | 対応バージョン | +|------|------|------------------|----------------| +| `value` | 保持する定数値への参照 | テンプレート引数`X`への参照（`static constexpr decltype(auto) value = (X);`）。型は`const value_type&` | C++26 | + +たとえば`std::cw<42>`の場合、`value`の値は`42`、その型は`const int&`となる。`value`はテンプレートパラメータオブジェクトへの参照であるため、ダングリングしない。 + + +## 非メンバ関数 +`constant_wrapper`は、説明用の基底クラス`cw-operators`を継承することで、以下の演算子を *Hidden friends* として提供する。 + +いずれの演算子も、オペランドがすべて説明用コンセプト`constexpr-param`（`constant_wrapper`のように、静的メンバ`value`を定数として持つ型）のモデルであることを要求し、演算結果を包んだ`constant_wrapper`を返す。 + +| 名前 | 説明 | 対応バージョン | +|------|------|----------------| +| [`operator+`](constant_wrapper/op_unary_plus.md) | 単項`+` | C++26 | +| [`operator-`](constant_wrapper/op_unary_minus.md) | 単項`-`（符号反転） | C++26 | +| [`operator~`](constant_wrapper/op_flip.md) | ビット反転 | C++26 | +| [`operator!`](constant_wrapper/op_not.md) | 論理否定 | C++26 | +| [`operator&`](constant_wrapper/op_address.md) | 単項`&`（アドレス取得） | C++26 | +| [`operator*`](constant_wrapper/op_deref.md) | 単項`*`（間接参照） | C++26 | +| [`operator+`](constant_wrapper/op_plus.md) | 加算 | C++26 | +| [`operator-`](constant_wrapper/op_minus.md) | 減算 | C++26 | +| [`operator*`](constant_wrapper/op_multiply.md) | 乗算 | C++26 | +| [`operator/`](constant_wrapper/op_divide.md) | 除算 | C++26 | +| [`operator%`](constant_wrapper/op_modulo.md) | 剰余 | C++26 | +| [`operator<<`](constant_wrapper/op_left_shift.md) | 左シフト | C++26 | +| [`operator>>`](constant_wrapper/op_right_shift.md) | 右シフト | C++26 | +| [`operator&`](constant_wrapper/op_and.md) | ビット論理積 | C++26 | +| [operator|](constant_wrapper/op_or.md) | ビット論理和 | C++26 | +| [`operator^`](constant_wrapper/op_xor.md) | ビット排他的論理和 | C++26 | +| [`operator&&`](constant_wrapper/op_logical_and.md) | 論理積 | C++26 | +| [operator||](constant_wrapper/op_logical_or.md) | 論理和 | C++26 | +| [`operator<=>`](constant_wrapper/op_compare_3way.md) | 三方比較 | C++26 | +| [`operator<`](constant_wrapper/op_less.md) | 左辺が右辺より小さいかの判定 | C++26 | +| [`operator<=`](constant_wrapper/op_less_equal.md) | 左辺が右辺以下かの判定 | C++26 | +| [`operator>`](constant_wrapper/op_greater.md) | 左辺が右辺より大きいかの判定 | C++26 | +| [`operator>=`](constant_wrapper/op_greater_equal.md) | 左辺が右辺以上かの判定 | C++26 | +| [`operator==`](constant_wrapper/op_equal.md) | 等値比較 | C++26 | +| [`operator!=`](constant_wrapper/op_not_equal.md) | 非等値比較 | C++26 | +| [`operator,`](constant_wrapper/op_comma.md) | カンマ演算子（`delete`定義） | C++26 | +| [`operator->*`](constant_wrapper/op_member_pointer.md) | メンバポインタ参照 | C++26 | + + +## 変数テンプレート`cw` +```cpp +namespace std { + template + constexpr auto cw = constant_wrapper{}; +} +``` + +`cw`は、`constant_wrapper`のオブジェクトを簡潔に生成するための変数テンプレートである。`std::cw`は`std::constant_wrapper{}`と等価である。 + + +## 備考 +- `operator()`と`operator[]`は静的メンバ関数であり、保持する値`value`をアンラップして呼び出す。引数がすべて`constexpr-param`のモデルであり、その結果をふたたび`constant_wrapper`で包める場合は、包んだ`constant_wrapper`を返す。そうでない場合は、アンラップした結果をそのまま返す。 + - この「保持する値そのものになる。ただし包んだままにできるなら包んだままにする」という規則は、すべての演算子に共通する。たとえば、`std::cw<1> + 1`は`int`の`2`に、`std::cw<1> + std::cw<1>`は`constant_wrapper<2>`になる。 +- `operator,`（カンマ演算子）は`delete`定義されている。 + + +## 例 +### 基本的な使い方 +```cpp example +#include +#include + +// 定数を通常の関数引数として受け取り、コンパイル時に計算する高階関数 +constexpr auto add(auto a, auto b) +{ + return a + b; +} + +int main() +{ + // cw<42>とcw<13>は、値を型として保持する + auto result = add(std::cw<42>, std::cw<13>); + + // resultはconstant_wrapper<55>型であり、 + // result自身が定数式でなくても、その値は定数式として使用できる + static_assert(result == 55); + + std::cout << result << std::endl; +} +``` +* std::cw[color ff0000] + +#### 出力 +``` +55 +``` + +### 演算結果を型として保持する +```cpp example +#include +#include + +int main() +{ + // オペランドがすべてconstant_wrapperなら、演算結果も再びconstant_wrapperになる + auto a = std::cw<10> + std::cw<5>; + static_assert(std::is_same_v>); + + // オペランドのいずれかが通常の値なら、保持する値へアンラップして演算する + auto b = std::cw<10> + 5; + static_assert(std::is_same_v); +} +``` +* std::cw[color ff0000] +* std::constant_wrapper[color ff0000] + +#### 出力 +``` +``` + +### 関数や添字をアンラップして呼び出す +```cpp example +#include +#include + +constexpr int triple(int x) { return x * 3; } + +// constant_wrapperはNTTPとして使うために名前空間スコープに置く +constexpr int data[] = {0, 10, 20, 30}; + +int main() +{ + // cwを関数呼び出しすると、保持する関数を呼び出す + // 引数もconstant_wrapperなら、結果を再びconstant_wrapperで包む + auto r = std::cw(std::cw<7>); + static_assert(r == 21); + std::cout << r << std::endl; + + // 配列を保持して添字アクセスする + auto e = std::cw[std::cw<2>]; + static_assert(e == 20); + std::cout << e << std::endl; +} +``` +* std::cw[color ff0000] + +#### 出力 +``` +21 +20 +``` + + +## バージョン +### 言語 +- C++26 + +### 処理系 +- [Clang](/implementation.md#clang): 23 [mark verified] +- [GCC](/implementation.md#gcc): 16.1 [mark verified] +- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl] + + +## 関連項目 +- [`std::integral_constant`](/reference/type_traits/integral_constant.md) 型として整数定数を表すクラス +- [`std::function_ref`](/reference/functional/function_ref.md) メンバ関数ポインタなどを束縛する際に`constant_wrapper`を受け取る + + +## 参照 +- [P2781R9 `std::constant_wrapper`](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p2781r9.html) + - C++26で`constant_wrapper`と変数テンプレート`cw`が追加された +- [P3978R3 `constant_wrapper` should unwrap on call and subscript](https://open-std.org/jtc1/sc22/wg21/docs/papers/2026/p3978r3.pdf) + - `operator()`と`operator[]`を静的メンバ関数とし、`INVOKE`を用いて値をアンラップして呼び出すよう変更された。あわせて`constant_wrapper`と`cw`の定義が[``](/reference/type_traits.md)から[``](/reference/utility.md)へ移動した +- [P4206R0 Revert string support in `std::constant_wrapper`](https://open-std.org/jtc1/sc22/wg21/docs/papers/2026/p4206r0.html) + - 文字列リテラルのサポートを削除し、テンプレートパラメータを説明用の`cw-fixed-value`から`auto`に戻した。これにともない`value_type`は`decltype(X)`、`value`は`X`自身を参照するよう簡略化された。仕様としてはC++29に導入されるが、C++26に対する欠陥報告 (DR) である diff --git a/reference/utility/constant_wrapper/op_address.md b/reference/utility/constant_wrapper/op_address.md new file mode 100644 index 0000000000..30dae9cd08 --- /dev/null +++ b/reference/utility/constant_wrapper/op_address.md @@ -0,0 +1,40 @@ +# operator& (単項) +* utility[meta header] +* std[meta namespace] +* function template[meta id-type] +* cpp26[meta cpp] + +```cpp +namespace std { + template + friend constexpr auto operator&(T x) noexcept; +} +``` + +## 概要 +`constant_wrapper`が保持する値のアドレスをとる。 + +## 戻り値 +`constant_wrapper<(&T::value)>{}`を返す。 + +## 備考 +- *Hidden friends*として定義されるため、引数依存の名前探索 (ADL) でのみ発見される。 +- オペランドのいずれかが`constant_wrapper`でない場合、保持する値へアンラップして通常の演算がおこなわれる。 + +## バージョン +### 言語 +- C++26 + +### 処理系 +- [Clang](/implementation.md#clang): 23 [mark verified] +- [GCC](/implementation.md#gcc): 16.1 [mark verified] +- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl] + + +## 関連項目 +- [`std::constant_wrapper`](../constant_wrapper.md) + + +## 参照 +- [P2781R9 `std::constant_wrapper`](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p2781r9.html) +- [P3978R3 `constant_wrapper` should unwrap on call and subscript](https://open-std.org/jtc1/sc22/wg21/docs/papers/2026/p3978r3.pdf) diff --git a/reference/utility/constant_wrapper/op_and.md b/reference/utility/constant_wrapper/op_and.md new file mode 100644 index 0000000000..5df84e91d3 --- /dev/null +++ b/reference/utility/constant_wrapper/op_and.md @@ -0,0 +1,59 @@ +# operator& +* utility[meta header] +* std[meta namespace] +* function template[meta id-type] +* cpp26[meta cpp] + +```cpp +namespace std { + template + friend constexpr auto operator&(L x, R y) noexcept; +} +``` + +## 概要 +2つの`constant_wrapper`が保持する値のビット論理積をおこなう。 + +## 戻り値 +`constant_wrapper<(L::value & R::value)>{}`を返す。 + +## 備考 +- *Hidden friends*として定義されるため、引数依存の名前探索 (ADL) でのみ発見される。 +- オペランドのいずれかが`constant_wrapper`でない場合、保持する値へアンラップして通常の演算がおこなわれる。 + +## 例 +```cpp example +#include +#include + +int main() +{ + // オペランドがすべてconstant_wrapperなので、結果もconstant_wrapperになる + auto x = std::cw<6> & std::cw<3>; + static_assert(x == 2); + static_assert(std::is_same_v>); +} +``` + +### 出力 +``` + +``` + +## バージョン +### 言語 +- C++26 + +### 処理系 +- [Clang](/implementation.md#clang): 23 [mark verified] +- [GCC](/implementation.md#gcc): 16.1 [mark verified] +- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl] + + +## 関連項目 +- [`std::constant_wrapper`](../constant_wrapper.md) + + +## 参照 +- [P2781R9 `std::constant_wrapper`](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p2781r9.html) +- [P3978R3 `constant_wrapper` should unwrap on call and subscript](https://open-std.org/jtc1/sc22/wg21/docs/papers/2026/p3978r3.pdf) diff --git a/reference/utility/constant_wrapper/op_and_assign.md b/reference/utility/constant_wrapper/op_and_assign.md new file mode 100644 index 0000000000..370869febf --- /dev/null +++ b/reference/utility/constant_wrapper/op_and_assign.md @@ -0,0 +1,41 @@ +# operator&= +* utility[meta header] +* std[meta namespace] +* constant_wrapper[meta class] +* function template[meta id-type] +* cpp26[meta cpp] + +```cpp +namespace std { + template + constexpr auto operator&=(this T self, R y) noexcept; +} +``` + +## 概要 +`constant_wrapper`が保持する値に対して、`&=`によるビット論理積の複合代入をおこなう。 + +## 戻り値 +`constant_wrapper<(T::value &= R::value)>{}`を返す。 + +## 備考 +- `constant_wrapper`が保持する`value`は`const`であるため、保持する値そのものを変更する式（`++value`、`value op= x`、`value = x`）は不適格となる。 +- したがって、このオーバーロードは説明用基底クラス`cw-operators`のインターフェースとして宣言されているものの、`constant_wrapper`に対してはオーバーロード解決に参加せず、使用できない。 + +## バージョン +### 言語 +- C++26 + +### 処理系 +- [Clang](/implementation.md#clang): 23 [mark verified] +- [GCC](/implementation.md#gcc): 16.1 [mark verified] +- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl] + + +## 関連項目 +- [`std::constant_wrapper`](../constant_wrapper.md) + + +## 参照 +- [P2781R9 `std::constant_wrapper`](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p2781r9.html) +- [P3978R3 `constant_wrapper` should unwrap on call and subscript](https://open-std.org/jtc1/sc22/wg21/docs/papers/2026/p3978r3.pdf) diff --git a/reference/utility/constant_wrapper/op_assign.md b/reference/utility/constant_wrapper/op_assign.md new file mode 100644 index 0000000000..dcc2e2f5a9 --- /dev/null +++ b/reference/utility/constant_wrapper/op_assign.md @@ -0,0 +1,41 @@ +# operator= +* utility[meta header] +* std[meta namespace] +* constant_wrapper[meta class] +* function template[meta id-type] +* cpp26[meta cpp] + +```cpp +namespace std { + template + constexpr auto operator=(R y) const noexcept; +} +``` + +## 概要 +`constant_wrapper`が保持する値に、別の`constant_wrapper`が保持する値を代入する。 + +## 戻り値 +`constant_wrapper<(value = R::value)>{}`を返す。 + +## 備考 +- `constant_wrapper`が保持する`value`は`const`であるため、`value = R::value`という代入式は不適格となる。 +- したがって、このオーバーロードは宣言されているものの、`constant_wrapper`に対してはオーバーロード解決に参加せず、使用できない。 + +## バージョン +### 言語 +- C++26 + +### 処理系 +- [Clang](/implementation.md#clang): 23 [mark verified] +- [GCC](/implementation.md#gcc): 16.1 [mark verified] +- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl] + + +## 関連項目 +- [`std::constant_wrapper`](../constant_wrapper.md) + + +## 参照 +- [P2781R9 `std::constant_wrapper`](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p2781r9.html) +- [P3978R3 `constant_wrapper` should unwrap on call and subscript](https://open-std.org/jtc1/sc22/wg21/docs/papers/2026/p3978r3.pdf) diff --git a/reference/utility/constant_wrapper/op_at.md b/reference/utility/constant_wrapper/op_at.md new file mode 100644 index 0000000000..b4a24df326 --- /dev/null +++ b/reference/utility/constant_wrapper/op_at.md @@ -0,0 +1,64 @@ +# operator[] +* utility[meta header] +* std[meta namespace] +* constant_wrapper[meta class] +* function template[meta id-type] +* cpp26[meta cpp] + +```cpp +namespace std { + template + static constexpr decltype(auto) operator[](Args&&... args) noexcept(/*see below*/); +} +``` + +## 概要 +`constant_wrapper`が保持する値に対して、添字アクセスをおこなう。 + +## 戻り値 +`subscr-expr`を以下のように定めたとき、`subscr-expr`を返す: + +- すべての`remove_cvref_t...`が`constexpr-param`のモデルであり、かつ`constant_wrapper::value...]>`が妥当な型である場合は、`constant_wrapper::value...]>{}` +- そうでない場合は、`value[std::forward(args)...]` + +## 備考 +- 静的メンバ関数である。 +- 添字がすべて`constant_wrapper`であり、その結果をふたたび`constant_wrapper`で包める場合は、結果を包んで「型の世界」にとどめる。そうでない場合は、保持する値をアンラップして添字アクセスした結果をそのまま返す。 +- 例外指定は`noexcept(subscr-expr)`と等価である。 + +## 例 +```cpp example +#include + +constexpr int data[] = {0, 10, 20, 30}; + +int main() +{ + // 配列を保持して添字アクセスする + auto e = std::cw[std::cw<2>]; + static_assert(e == 20); +} +``` + +### 出力 +``` + +``` + +## バージョン +### 言語 +- C++26 + +### 処理系 +- [Clang](/implementation.md#clang): 23 [mark verified] +- [GCC](/implementation.md#gcc): 16.1 [mark verified] +- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl] + + +## 関連項目 +- [`std::constant_wrapper`](../constant_wrapper.md) + + +## 参照 +- [P2781R9 `std::constant_wrapper`](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p2781r9.html) +- [P3978R3 `constant_wrapper` should unwrap on call and subscript](https://open-std.org/jtc1/sc22/wg21/docs/papers/2026/p3978r3.pdf) diff --git a/reference/utility/constant_wrapper/op_call.md b/reference/utility/constant_wrapper/op_call.md new file mode 100644 index 0000000000..9db20a42a4 --- /dev/null +++ b/reference/utility/constant_wrapper/op_call.md @@ -0,0 +1,65 @@ +# operator() +* utility[meta header] +* std[meta namespace] +* constant_wrapper[meta class] +* function template[meta id-type] +* cpp26[meta cpp] + +```cpp +namespace std { + template + static constexpr decltype(auto) operator()(Args&&... args) noexcept(/*see below*/); +} +``` + +## 概要 +`constant_wrapper`が保持する値を、関数として呼び出す。 + +## 戻り値 +`call-expr`を以下のように定めたとき、`call-expr`を返す: + +- すべての`remove_cvref_t...`が`constexpr-param`のモデルであり、かつ`constant_wrapper::value...)>`が妥当な型である場合は、`constant_wrapper::value...)>{}` +- そうでない場合は、`INVOKE(value, std::forward(args)...)` + +## 備考 +- 静的メンバ関数である。 +- 引数がすべて`constant_wrapper`であり、その結果をふたたび`constant_wrapper`で包める場合は、結果を包んで「型の世界」にとどめる。そうでない場合は、保持する値をアンラップして呼び出した結果をそのまま返す。 +- 例外指定は`noexcept(call-expr)`と等価である。 + +## 例 +```cpp example +#include + +constexpr int triple(int x) { return x * 3; } + +int main() +{ + // cwを呼び出すと、保持する関数を呼び出す + // 引数もconstant_wrapperなら、結果をconstant_wrapperで包む + auto r = std::cw(std::cw<7>); + static_assert(r == 21); +} +``` + +### 出力 +``` + +``` + +## バージョン +### 言語 +- C++26 + +### 処理系 +- [Clang](/implementation.md#clang): 23 [mark verified] +- [GCC](/implementation.md#gcc): 16.1 [mark verified] +- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl] + + +## 関連項目 +- [`std::constant_wrapper`](../constant_wrapper.md) + + +## 参照 +- [P2781R9 `std::constant_wrapper`](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p2781r9.html) +- [P3978R3 `constant_wrapper` should unwrap on call and subscript](https://open-std.org/jtc1/sc22/wg21/docs/papers/2026/p3978r3.pdf) diff --git a/reference/utility/constant_wrapper/op_comma.md b/reference/utility/constant_wrapper/op_comma.md new file mode 100644 index 0000000000..4a634fa85c --- /dev/null +++ b/reference/utility/constant_wrapper/op_comma.md @@ -0,0 +1,36 @@ +# operator, +* utility[meta header] +* std[meta namespace] +* function template[meta id-type] +* cpp26[meta cpp] + +```cpp +namespace std { + template + friend constexpr auto operator,(L x, R y) noexcept = delete; +} +``` + +## 概要 +`constant_wrapper`に対するカンマ演算子は`delete`定義されている。 + +## 備考 +- カンマ演算子の誤用を防ぐために`delete`定義されている。 + +## バージョン +### 言語 +- C++26 + +### 処理系 +- [Clang](/implementation.md#clang): 23 [mark verified] +- [GCC](/implementation.md#gcc): 16.1 [mark verified] +- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl] + + +## 関連項目 +- [`std::constant_wrapper`](../constant_wrapper.md) + + +## 参照 +- [P2781R9 `std::constant_wrapper`](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p2781r9.html) +- [P3978R3 `constant_wrapper` should unwrap on call and subscript](https://open-std.org/jtc1/sc22/wg21/docs/papers/2026/p3978r3.pdf) diff --git a/reference/utility/constant_wrapper/op_compare_3way.md b/reference/utility/constant_wrapper/op_compare_3way.md new file mode 100644 index 0000000000..b7fefc834f --- /dev/null +++ b/reference/utility/constant_wrapper/op_compare_3way.md @@ -0,0 +1,56 @@ +# operator<=> +* utility[meta header] +* std[meta namespace] +* function template[meta id-type] +* cpp26[meta cpp] + +```cpp +namespace std { + template + friend constexpr auto operator<=>(L x, R y) noexcept; +} +``` + +## 概要 +2つの`constant_wrapper`が保持する値を三方比較する。 + +## 戻り値 +`constant_wrapper<(L::value <=> R::value)>{}`を返す。 + +## 備考 +- *Hidden friends*として定義されるため、引数依存の名前探索 (ADL) でのみ発見される。 +- オペランドのいずれかが`constant_wrapper`でない場合、保持する値へアンラップして通常の演算がおこなわれる。 + +## 例 +```cpp example +#include + +int main() +{ + // 比較結果（順序付け）を保持するconstant_wrapperを返す + static_assert((std::cw<3> <=> std::cw<5>) < 0); +} +``` + +### 出力 +``` + +``` + +## バージョン +### 言語 +- C++26 + +### 処理系 +- [Clang](/implementation.md#clang): 23 [mark verified] +- [GCC](/implementation.md#gcc): 16.1 [mark verified] +- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl] + + +## 関連項目 +- [`std::constant_wrapper`](../constant_wrapper.md) + + +## 参照 +- [P2781R9 `std::constant_wrapper`](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p2781r9.html) +- [P3978R3 `constant_wrapper` should unwrap on call and subscript](https://open-std.org/jtc1/sc22/wg21/docs/papers/2026/p3978r3.pdf) diff --git a/reference/utility/constant_wrapper/op_decrement.md b/reference/utility/constant_wrapper/op_decrement.md new file mode 100644 index 0000000000..6fc7a1a09a --- /dev/null +++ b/reference/utility/constant_wrapper/op_decrement.md @@ -0,0 +1,47 @@ +# operator-- +* utility[meta header] +* std[meta namespace] +* constant_wrapper[meta class] +* function template[meta id-type] +* cpp26[meta cpp] + +```cpp +namespace std { + template + constexpr auto operator--(this T self) noexcept; // 前置 + template + constexpr auto operator--(this T self, int) noexcept; // 後置 +} +``` + +## 概要 +`constant_wrapper`が保持する値をデクリメントする。 + +- 前置: デクリメント後の値を保持する`constant_wrapper`を返す。 +- 後置: デクリメント前の値を保持する`constant_wrapper`を返す。 + +## 戻り値 +- 前置: `constant_wrapper<(--T::value)>{}`を返す。 +- 後置: `constant_wrapper<(T::value--)>{}`を返す。 + +## 備考 +- `constant_wrapper`が保持する`value`は`const`であるため、保持する値そのものを変更する式（`++value`、`value op= x`、`value = x`）は不適格となる。 +- したがって、このオーバーロードは説明用基底クラス`cw-operators`のインターフェースとして宣言されているものの、`constant_wrapper`に対してはオーバーロード解決に参加せず、使用できない。 + +## バージョン +### 言語 +- C++26 + +### 処理系 +- [Clang](/implementation.md#clang): 23 [mark verified] +- [GCC](/implementation.md#gcc): 16.1 [mark verified] +- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl] + + +## 関連項目 +- [`std::constant_wrapper`](../constant_wrapper.md) + + +## 参照 +- [P2781R9 `std::constant_wrapper`](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p2781r9.html) +- [P3978R3 `constant_wrapper` should unwrap on call and subscript](https://open-std.org/jtc1/sc22/wg21/docs/papers/2026/p3978r3.pdf) diff --git a/reference/utility/constant_wrapper/op_deref.md b/reference/utility/constant_wrapper/op_deref.md new file mode 100644 index 0000000000..9734a6354c --- /dev/null +++ b/reference/utility/constant_wrapper/op_deref.md @@ -0,0 +1,40 @@ +# operator* (単項) +* utility[meta header] +* std[meta namespace] +* function template[meta id-type] +* cpp26[meta cpp] + +```cpp +namespace std { + template + friend constexpr auto operator*(T x) noexcept; +} +``` + +## 概要 +`constant_wrapper`が保持するポインタを間接参照する。 + +## 戻り値 +`constant_wrapper<(*T::value)>{}`を返す。 + +## 備考 +- *Hidden friends*として定義されるため、引数依存の名前探索 (ADL) でのみ発見される。 +- オペランドのいずれかが`constant_wrapper`でない場合、保持する値へアンラップして通常の演算がおこなわれる。 + +## バージョン +### 言語 +- C++26 + +### 処理系 +- [Clang](/implementation.md#clang): 23 [mark verified] +- [GCC](/implementation.md#gcc): 16.1 [mark verified] +- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl] + + +## 関連項目 +- [`std::constant_wrapper`](../constant_wrapper.md) + + +## 参照 +- [P2781R9 `std::constant_wrapper`](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p2781r9.html) +- [P3978R3 `constant_wrapper` should unwrap on call and subscript](https://open-std.org/jtc1/sc22/wg21/docs/papers/2026/p3978r3.pdf) diff --git a/reference/utility/constant_wrapper/op_divide.md b/reference/utility/constant_wrapper/op_divide.md new file mode 100644 index 0000000000..6ba70b4363 --- /dev/null +++ b/reference/utility/constant_wrapper/op_divide.md @@ -0,0 +1,59 @@ +# operator/ +* utility[meta header] +* std[meta namespace] +* function template[meta id-type] +* cpp26[meta cpp] + +```cpp +namespace std { + template + friend constexpr auto operator/(L x, R y) noexcept; +} +``` + +## 概要 +2つの`constant_wrapper`が保持する値の除算をおこなう。 + +## 戻り値 +`constant_wrapper<(L::value / R::value)>{}`を返す。 + +## 備考 +- *Hidden friends*として定義されるため、引数依存の名前探索 (ADL) でのみ発見される。 +- オペランドのいずれかが`constant_wrapper`でない場合、保持する値へアンラップして通常の演算がおこなわれる。 + +## 例 +```cpp example +#include +#include + +int main() +{ + // オペランドがすべてconstant_wrapperなので、結果もconstant_wrapperになる + auto x = std::cw<6> / std::cw<2>; + static_assert(x == 3); + static_assert(std::is_same_v>); +} +``` + +### 出力 +``` + +``` + +## バージョン +### 言語 +- C++26 + +### 処理系 +- [Clang](/implementation.md#clang): 23 [mark verified] +- [GCC](/implementation.md#gcc): 16.1 [mark verified] +- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl] + + +## 関連項目 +- [`std::constant_wrapper`](../constant_wrapper.md) + + +## 参照 +- [P2781R9 `std::constant_wrapper`](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p2781r9.html) +- [P3978R3 `constant_wrapper` should unwrap on call and subscript](https://open-std.org/jtc1/sc22/wg21/docs/papers/2026/p3978r3.pdf) diff --git a/reference/utility/constant_wrapper/op_divide_assign.md b/reference/utility/constant_wrapper/op_divide_assign.md new file mode 100644 index 0000000000..de37b0cd9a --- /dev/null +++ b/reference/utility/constant_wrapper/op_divide_assign.md @@ -0,0 +1,41 @@ +# operator/= +* utility[meta header] +* std[meta namespace] +* constant_wrapper[meta class] +* function template[meta id-type] +* cpp26[meta cpp] + +```cpp +namespace std { + template + constexpr auto operator/=(this T self, R y) noexcept; +} +``` + +## 概要 +`constant_wrapper`が保持する値に対して、`/=`による除算の複合代入をおこなう。 + +## 戻り値 +`constant_wrapper<(T::value /= R::value)>{}`を返す。 + +## 備考 +- `constant_wrapper`が保持する`value`は`const`であるため、保持する値そのものを変更する式（`++value`、`value op= x`、`value = x`）は不適格となる。 +- したがって、このオーバーロードは説明用基底クラス`cw-operators`のインターフェースとして宣言されているものの、`constant_wrapper`に対してはオーバーロード解決に参加せず、使用できない。 + +## バージョン +### 言語 +- C++26 + +### 処理系 +- [Clang](/implementation.md#clang): 23 [mark verified] +- [GCC](/implementation.md#gcc): 16.1 [mark verified] +- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl] + + +## 関連項目 +- [`std::constant_wrapper`](../constant_wrapper.md) + + +## 参照 +- [P2781R9 `std::constant_wrapper`](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p2781r9.html) +- [P3978R3 `constant_wrapper` should unwrap on call and subscript](https://open-std.org/jtc1/sc22/wg21/docs/papers/2026/p3978r3.pdf) diff --git a/reference/utility/constant_wrapper/op_equal.md b/reference/utility/constant_wrapper/op_equal.md new file mode 100644 index 0000000000..2f98457ebf --- /dev/null +++ b/reference/utility/constant_wrapper/op_equal.md @@ -0,0 +1,56 @@ +# operator== +* utility[meta header] +* std[meta namespace] +* function template[meta id-type] +* cpp26[meta cpp] + +```cpp +namespace std { + template + friend constexpr auto operator==(L x, R y) noexcept; +} +``` + +## 概要 +2つの`constant_wrapper`が保持する値を`==`で比較する。 + +## 戻り値 +`constant_wrapper<(L::value == R::value)>{}`を返す。 + +## 備考 +- *Hidden friends*として定義されるため、引数依存の名前探索 (ADL) でのみ発見される。 +- オペランドのいずれかが`constant_wrapper`でない場合、保持する値へアンラップして通常の演算がおこなわれる。 + +## 例 +```cpp example +#include + +int main() +{ + // 比較結果を保持するconstant_wrapperを返す + static_assert(std::cw<5> == std::cw<5>); +} +``` + +### 出力 +``` + +``` + +## バージョン +### 言語 +- C++26 + +### 処理系 +- [Clang](/implementation.md#clang): 23 [mark verified] +- [GCC](/implementation.md#gcc): 16.1 [mark verified] +- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl] + + +## 関連項目 +- [`std::constant_wrapper`](../constant_wrapper.md) + + +## 参照 +- [P2781R9 `std::constant_wrapper`](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p2781r9.html) +- [P3978R3 `constant_wrapper` should unwrap on call and subscript](https://open-std.org/jtc1/sc22/wg21/docs/papers/2026/p3978r3.pdf) diff --git a/reference/utility/constant_wrapper/op_flip.md b/reference/utility/constant_wrapper/op_flip.md new file mode 100644 index 0000000000..f800918022 --- /dev/null +++ b/reference/utility/constant_wrapper/op_flip.md @@ -0,0 +1,59 @@ +# operator~ +* utility[meta header] +* std[meta namespace] +* function template[meta id-type] +* cpp26[meta cpp] + +```cpp +namespace std { + template + friend constexpr auto operator~(T x) noexcept; +} +``` + +## 概要 +`constant_wrapper`が保持する値のビットを反転する。 + +## 戻り値 +`constant_wrapper<(~T::value)>{}`を返す。 + +## 備考 +- *Hidden friends*として定義されるため、引数依存の名前探索 (ADL) でのみ発見される。 +- オペランドのいずれかが`constant_wrapper`でない場合、保持する値へアンラップして通常の演算がおこなわれる。 + +## 例 +```cpp example +#include +#include + +int main() +{ + // オペランドがすべてconstant_wrapperなので、結果もconstant_wrapperになる + auto x = ~std::cw<0>; + static_assert(x == -1); + static_assert(std::is_same_v>); +} +``` + +### 出力 +``` + +``` + +## バージョン +### 言語 +- C++26 + +### 処理系 +- [Clang](/implementation.md#clang): 23 [mark verified] +- [GCC](/implementation.md#gcc): 16.1 [mark verified] +- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl] + + +## 関連項目 +- [`std::constant_wrapper`](../constant_wrapper.md) + + +## 参照 +- [P2781R9 `std::constant_wrapper`](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p2781r9.html) +- [P3978R3 `constant_wrapper` should unwrap on call and subscript](https://open-std.org/jtc1/sc22/wg21/docs/papers/2026/p3978r3.pdf) diff --git a/reference/utility/constant_wrapper/op_greater.md b/reference/utility/constant_wrapper/op_greater.md new file mode 100644 index 0000000000..d3b87ef890 --- /dev/null +++ b/reference/utility/constant_wrapper/op_greater.md @@ -0,0 +1,56 @@ +# operator> +* utility[meta header] +* std[meta namespace] +* function template[meta id-type] +* cpp26[meta cpp] + +```cpp +namespace std { + template + friend constexpr auto operator>(L x, R y) noexcept; +} +``` + +## 概要 +2つの`constant_wrapper`が保持する値を`>`で比較する。 + +## 戻り値 +`constant_wrapper<(L::value > R::value)>{}`を返す。 + +## 備考 +- *Hidden friends*として定義されるため、引数依存の名前探索 (ADL) でのみ発見される。 +- オペランドのいずれかが`constant_wrapper`でない場合、保持する値へアンラップして通常の演算がおこなわれる。 + +## 例 +```cpp example +#include + +int main() +{ + // 比較結果を保持するconstant_wrapperを返す + static_assert(std::cw<5> > std::cw<3>); +} +``` + +### 出力 +``` + +``` + +## バージョン +### 言語 +- C++26 + +### 処理系 +- [Clang](/implementation.md#clang): 23 [mark verified] +- [GCC](/implementation.md#gcc): 16.1 [mark verified] +- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl] + + +## 関連項目 +- [`std::constant_wrapper`](../constant_wrapper.md) + + +## 参照 +- [P2781R9 `std::constant_wrapper`](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p2781r9.html) +- [P3978R3 `constant_wrapper` should unwrap on call and subscript](https://open-std.org/jtc1/sc22/wg21/docs/papers/2026/p3978r3.pdf) diff --git a/reference/utility/constant_wrapper/op_greater_equal.md b/reference/utility/constant_wrapper/op_greater_equal.md new file mode 100644 index 0000000000..05261c497a --- /dev/null +++ b/reference/utility/constant_wrapper/op_greater_equal.md @@ -0,0 +1,56 @@ +# operator>= +* utility[meta header] +* std[meta namespace] +* function template[meta id-type] +* cpp26[meta cpp] + +```cpp +namespace std { + template + friend constexpr auto operator>=(L x, R y) noexcept; +} +``` + +## 概要 +2つの`constant_wrapper`が保持する値を`>=`で比較する。 + +## 戻り値 +`constant_wrapper<(L::value >= R::value)>{}`を返す。 + +## 備考 +- *Hidden friends*として定義されるため、引数依存の名前探索 (ADL) でのみ発見される。 +- オペランドのいずれかが`constant_wrapper`でない場合、保持する値へアンラップして通常の演算がおこなわれる。 + +## 例 +```cpp example +#include + +int main() +{ + // 比較結果を保持するconstant_wrapperを返す + static_assert(std::cw<5> >= std::cw<5>); +} +``` + +### 出力 +``` + +``` + +## バージョン +### 言語 +- C++26 + +### 処理系 +- [Clang](/implementation.md#clang): 23 [mark verified] +- [GCC](/implementation.md#gcc): 16.1 [mark verified] +- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl] + + +## 関連項目 +- [`std::constant_wrapper`](../constant_wrapper.md) + + +## 参照 +- [P2781R9 `std::constant_wrapper`](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p2781r9.html) +- [P3978R3 `constant_wrapper` should unwrap on call and subscript](https://open-std.org/jtc1/sc22/wg21/docs/papers/2026/p3978r3.pdf) diff --git a/reference/utility/constant_wrapper/op_increment.md b/reference/utility/constant_wrapper/op_increment.md new file mode 100644 index 0000000000..5301ae6315 --- /dev/null +++ b/reference/utility/constant_wrapper/op_increment.md @@ -0,0 +1,47 @@ +# operator++ +* utility[meta header] +* std[meta namespace] +* constant_wrapper[meta class] +* function template[meta id-type] +* cpp26[meta cpp] + +```cpp +namespace std { + template + constexpr auto operator++(this T self) noexcept; // 前置 + template + constexpr auto operator++(this T self, int) noexcept; // 後置 +} +``` + +## 概要 +`constant_wrapper`が保持する値をインクリメントする。 + +- 前置: インクリメント後の値を保持する`constant_wrapper`を返す。 +- 後置: インクリメント前の値を保持する`constant_wrapper`を返す。 + +## 戻り値 +- 前置: `constant_wrapper<(++T::value)>{}`を返す。 +- 後置: `constant_wrapper<(T::value++)>{}`を返す。 + +## 備考 +- `constant_wrapper`が保持する`value`は`const`であるため、保持する値そのものを変更する式（`++value`、`value op= x`、`value = x`）は不適格となる。 +- したがって、このオーバーロードは説明用基底クラス`cw-operators`のインターフェースとして宣言されているものの、`constant_wrapper`に対してはオーバーロード解決に参加せず、使用できない。 + +## バージョン +### 言語 +- C++26 + +### 処理系 +- [Clang](/implementation.md#clang): 23 [mark verified] +- [GCC](/implementation.md#gcc): 16.1 [mark verified] +- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl] + + +## 関連項目 +- [`std::constant_wrapper`](../constant_wrapper.md) + + +## 参照 +- [P2781R9 `std::constant_wrapper`](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p2781r9.html) +- [P3978R3 `constant_wrapper` should unwrap on call and subscript](https://open-std.org/jtc1/sc22/wg21/docs/papers/2026/p3978r3.pdf) diff --git a/reference/utility/constant_wrapper/op_left_shift.md b/reference/utility/constant_wrapper/op_left_shift.md new file mode 100644 index 0000000000..72012733d6 --- /dev/null +++ b/reference/utility/constant_wrapper/op_left_shift.md @@ -0,0 +1,59 @@ +# operator<< +* utility[meta header] +* std[meta namespace] +* function template[meta id-type] +* cpp26[meta cpp] + +```cpp +namespace std { + template + friend constexpr auto operator<<(L x, R y) noexcept; +} +``` + +## 概要 +2つの`constant_wrapper`が保持する値の左シフトをおこなう。 + +## 戻り値 +`constant_wrapper<(L::value << R::value)>{}`を返す。 + +## 備考 +- *Hidden friends*として定義されるため、引数依存の名前探索 (ADL) でのみ発見される。 +- オペランドのいずれかが`constant_wrapper`でない場合、保持する値へアンラップして通常の演算がおこなわれる。 + +## 例 +```cpp example +#include +#include + +int main() +{ + // オペランドがすべてconstant_wrapperなので、結果もconstant_wrapperになる + auto x = std::cw<1> << std::cw<4>; + static_assert(x == 16); + static_assert(std::is_same_v>); +} +``` + +### 出力 +``` + +``` + +## バージョン +### 言語 +- C++26 + +### 処理系 +- [Clang](/implementation.md#clang): 23 [mark verified] +- [GCC](/implementation.md#gcc): 16.1 [mark verified] +- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl] + + +## 関連項目 +- [`std::constant_wrapper`](../constant_wrapper.md) + + +## 参照 +- [P2781R9 `std::constant_wrapper`](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p2781r9.html) +- [P3978R3 `constant_wrapper` should unwrap on call and subscript](https://open-std.org/jtc1/sc22/wg21/docs/papers/2026/p3978r3.pdf) diff --git a/reference/utility/constant_wrapper/op_left_shift_assign.md b/reference/utility/constant_wrapper/op_left_shift_assign.md new file mode 100644 index 0000000000..e29848e05c --- /dev/null +++ b/reference/utility/constant_wrapper/op_left_shift_assign.md @@ -0,0 +1,41 @@ +# operator<<= +* utility[meta header] +* std[meta namespace] +* constant_wrapper[meta class] +* function template[meta id-type] +* cpp26[meta cpp] + +```cpp +namespace std { + template + constexpr auto operator<<=(this T self, R y) noexcept; +} +``` + +## 概要 +`constant_wrapper`が保持する値に対して、`<<=`による左シフトの複合代入をおこなう。 + +## 戻り値 +`constant_wrapper<(T::value <<= R::value)>{}`を返す。 + +## 備考 +- `constant_wrapper`が保持する`value`は`const`であるため、保持する値そのものを変更する式（`++value`、`value op= x`、`value = x`）は不適格となる。 +- したがって、このオーバーロードは説明用基底クラス`cw-operators`のインターフェースとして宣言されているものの、`constant_wrapper`に対してはオーバーロード解決に参加せず、使用できない。 + +## バージョン +### 言語 +- C++26 + +### 処理系 +- [Clang](/implementation.md#clang): 23 [mark verified] +- [GCC](/implementation.md#gcc): 16.1 [mark verified] +- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl] + + +## 関連項目 +- [`std::constant_wrapper`](../constant_wrapper.md) + + +## 参照 +- [P2781R9 `std::constant_wrapper`](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p2781r9.html) +- [P3978R3 `constant_wrapper` should unwrap on call and subscript](https://open-std.org/jtc1/sc22/wg21/docs/papers/2026/p3978r3.pdf) diff --git a/reference/utility/constant_wrapper/op_less.md b/reference/utility/constant_wrapper/op_less.md new file mode 100644 index 0000000000..d56bf93192 --- /dev/null +++ b/reference/utility/constant_wrapper/op_less.md @@ -0,0 +1,56 @@ +# operator< +* utility[meta header] +* std[meta namespace] +* function template[meta id-type] +* cpp26[meta cpp] + +```cpp +namespace std { + template + friend constexpr auto operator<(L x, R y) noexcept; +} +``` + +## 概要 +2つの`constant_wrapper`が保持する値を`<`で比較する。 + +## 戻り値 +`constant_wrapper<(L::value < R::value)>{}`を返す。 + +## 備考 +- *Hidden friends*として定義されるため、引数依存の名前探索 (ADL) でのみ発見される。 +- オペランドのいずれかが`constant_wrapper`でない場合、保持する値へアンラップして通常の演算がおこなわれる。 + +## 例 +```cpp example +#include + +int main() +{ + // 比較結果を保持するconstant_wrapperを返す + static_assert(std::cw<3> < std::cw<5>); +} +``` + +### 出力 +``` + +``` + +## バージョン +### 言語 +- C++26 + +### 処理系 +- [Clang](/implementation.md#clang): 23 [mark verified] +- [GCC](/implementation.md#gcc): 16.1 [mark verified] +- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl] + + +## 関連項目 +- [`std::constant_wrapper`](../constant_wrapper.md) + + +## 参照 +- [P2781R9 `std::constant_wrapper`](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p2781r9.html) +- [P3978R3 `constant_wrapper` should unwrap on call and subscript](https://open-std.org/jtc1/sc22/wg21/docs/papers/2026/p3978r3.pdf) diff --git a/reference/utility/constant_wrapper/op_less_equal.md b/reference/utility/constant_wrapper/op_less_equal.md new file mode 100644 index 0000000000..bf1352f2d9 --- /dev/null +++ b/reference/utility/constant_wrapper/op_less_equal.md @@ -0,0 +1,56 @@ +# operator<= +* utility[meta header] +* std[meta namespace] +* function template[meta id-type] +* cpp26[meta cpp] + +```cpp +namespace std { + template + friend constexpr auto operator<=(L x, R y) noexcept; +} +``` + +## 概要 +2つの`constant_wrapper`が保持する値を`<=`で比較する。 + +## 戻り値 +`constant_wrapper<(L::value <= R::value)>{}`を返す。 + +## 備考 +- *Hidden friends*として定義されるため、引数依存の名前探索 (ADL) でのみ発見される。 +- オペランドのいずれかが`constant_wrapper`でない場合、保持する値へアンラップして通常の演算がおこなわれる。 + +## 例 +```cpp example +#include + +int main() +{ + // 比較結果を保持するconstant_wrapperを返す + static_assert(std::cw<5> <= std::cw<5>); +} +``` + +### 出力 +``` + +``` + +## バージョン +### 言語 +- C++26 + +### 処理系 +- [Clang](/implementation.md#clang): 23 [mark verified] +- [GCC](/implementation.md#gcc): 16.1 [mark verified] +- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl] + + +## 関連項目 +- [`std::constant_wrapper`](../constant_wrapper.md) + + +## 参照 +- [P2781R9 `std::constant_wrapper`](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p2781r9.html) +- [P3978R3 `constant_wrapper` should unwrap on call and subscript](https://open-std.org/jtc1/sc22/wg21/docs/papers/2026/p3978r3.pdf) diff --git a/reference/utility/constant_wrapper/op_logical_and.md b/reference/utility/constant_wrapper/op_logical_and.md new file mode 100644 index 0000000000..6758ea1eb0 --- /dev/null +++ b/reference/utility/constant_wrapper/op_logical_and.md @@ -0,0 +1,41 @@ +# operator&& +* utility[meta header] +* std[meta namespace] +* function template[meta id-type] +* cpp26[meta cpp] + +```cpp +namespace std { + template + friend constexpr auto operator&&(L x, R y) noexcept; +} +``` + +## 概要 +2つの`constant_wrapper`が保持する値の論理積をとる。 + +## 戻り値 +`constant_wrapper<(L::value && R::value)>{}`を返す。 + +## 備考 +- このオーバーロードは、オペランドのいずれかの値の型が`bool`に変換できない (`!is_constructible_v`) 場合にのみ使用される。 +- 両方の値が`bool`に変換できる場合は、このオーバーロードは使用されず、変換演算子をとおして組み込みの`&&`／`||`（短絡評価）が適用される。 +- *Hidden friends*として定義される。 + +## バージョン +### 言語 +- C++26 + +### 処理系 +- [Clang](/implementation.md#clang): 23 [mark verified] +- [GCC](/implementation.md#gcc): 16.1 [mark verified] +- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl] + + +## 関連項目 +- [`std::constant_wrapper`](../constant_wrapper.md) + + +## 参照 +- [P2781R9 `std::constant_wrapper`](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p2781r9.html) +- [P3978R3 `constant_wrapper` should unwrap on call and subscript](https://open-std.org/jtc1/sc22/wg21/docs/papers/2026/p3978r3.pdf) diff --git a/reference/utility/constant_wrapper/op_logical_or.md b/reference/utility/constant_wrapper/op_logical_or.md new file mode 100644 index 0000000000..4a77e4bdc2 --- /dev/null +++ b/reference/utility/constant_wrapper/op_logical_or.md @@ -0,0 +1,41 @@ +# operator|| +* utility[meta header] +* std[meta namespace] +* function template[meta id-type] +* cpp26[meta cpp] + +```cpp +namespace std { + template + friend constexpr auto operator||(L x, R y) noexcept; +} +``` + +## 概要 +2つの`constant_wrapper`が保持する値の論理和をとる。 + +## 戻り値 +`constant_wrapper<(L::value || R::value)>{}`を返す。 + +## 備考 +- このオーバーロードは、オペランドのいずれかの値の型が`bool`に変換できない (`!is_constructible_v`) 場合にのみ使用される。 +- 両方の値が`bool`に変換できる場合は、このオーバーロードは使用されず、変換演算子をとおして組み込みの`&&`／`||`（短絡評価）が適用される。 +- *Hidden friends*として定義される。 + +## バージョン +### 言語 +- C++26 + +### 処理系 +- [Clang](/implementation.md#clang): 23 [mark verified] +- [GCC](/implementation.md#gcc): 16.1 [mark verified] +- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl] + + +## 関連項目 +- [`std::constant_wrapper`](../constant_wrapper.md) + + +## 参照 +- [P2781R9 `std::constant_wrapper`](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p2781r9.html) +- [P3978R3 `constant_wrapper` should unwrap on call and subscript](https://open-std.org/jtc1/sc22/wg21/docs/papers/2026/p3978r3.pdf) diff --git a/reference/utility/constant_wrapper/op_member_pointer.md b/reference/utility/constant_wrapper/op_member_pointer.md new file mode 100644 index 0000000000..18dc8f421f --- /dev/null +++ b/reference/utility/constant_wrapper/op_member_pointer.md @@ -0,0 +1,40 @@ +# operator->* +* utility[meta header] +* std[meta namespace] +* function template[meta id-type] +* cpp26[meta cpp] + +```cpp +namespace std { + template + friend constexpr auto operator->*(L x, R y) noexcept; +} +``` + +## 概要 +`constant_wrapper`が保持する値に対してメンバポインタ参照をおこなう。 + +## 戻り値 +`constant_wrapper<(L::value->*(R::value))>{}`を返す。 + +## 備考 +- *Hidden friends*として定義されるため、引数依存の名前探索 (ADL) でのみ発見される。 +- オペランドのいずれかが`constant_wrapper`でない場合、保持する値へアンラップして通常の演算がおこなわれる。 + +## バージョン +### 言語 +- C++26 + +### 処理系 +- [Clang](/implementation.md#clang): 23 [mark verified] +- [GCC](/implementation.md#gcc): 16.1 [mark verified] +- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl] + + +## 関連項目 +- [`std::constant_wrapper`](../constant_wrapper.md) + + +## 参照 +- [P2781R9 `std::constant_wrapper`](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p2781r9.html) +- [P3978R3 `constant_wrapper` should unwrap on call and subscript](https://open-std.org/jtc1/sc22/wg21/docs/papers/2026/p3978r3.pdf) diff --git a/reference/utility/constant_wrapper/op_minus.md b/reference/utility/constant_wrapper/op_minus.md new file mode 100644 index 0000000000..353eb270dc --- /dev/null +++ b/reference/utility/constant_wrapper/op_minus.md @@ -0,0 +1,59 @@ +# operator- +* utility[meta header] +* std[meta namespace] +* function template[meta id-type] +* cpp26[meta cpp] + +```cpp +namespace std { + template + friend constexpr auto operator-(L x, R y) noexcept; +} +``` + +## 概要 +2つの`constant_wrapper`が保持する値の減算をおこなう。 + +## 戻り値 +`constant_wrapper<(L::value - R::value)>{}`を返す。 + +## 備考 +- *Hidden friends*として定義されるため、引数依存の名前探索 (ADL) でのみ発見される。 +- オペランドのいずれかが`constant_wrapper`でない場合、保持する値へアンラップして通常の演算がおこなわれる。 + +## 例 +```cpp example +#include +#include + +int main() +{ + // オペランドがすべてconstant_wrapperなので、結果もconstant_wrapperになる + auto x = std::cw<6> - std::cw<2>; + static_assert(x == 4); + static_assert(std::is_same_v>); +} +``` + +### 出力 +``` + +``` + +## バージョン +### 言語 +- C++26 + +### 処理系 +- [Clang](/implementation.md#clang): 23 [mark verified] +- [GCC](/implementation.md#gcc): 16.1 [mark verified] +- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl] + + +## 関連項目 +- [`std::constant_wrapper`](../constant_wrapper.md) + + +## 参照 +- [P2781R9 `std::constant_wrapper`](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p2781r9.html) +- [P3978R3 `constant_wrapper` should unwrap on call and subscript](https://open-std.org/jtc1/sc22/wg21/docs/papers/2026/p3978r3.pdf) diff --git a/reference/utility/constant_wrapper/op_minus_assign.md b/reference/utility/constant_wrapper/op_minus_assign.md new file mode 100644 index 0000000000..8ef2cf8412 --- /dev/null +++ b/reference/utility/constant_wrapper/op_minus_assign.md @@ -0,0 +1,41 @@ +# operator-= +* utility[meta header] +* std[meta namespace] +* constant_wrapper[meta class] +* function template[meta id-type] +* cpp26[meta cpp] + +```cpp +namespace std { + template + constexpr auto operator-=(this T self, R y) noexcept; +} +``` + +## 概要 +`constant_wrapper`が保持する値に対して、`-=`による減算の複合代入をおこなう。 + +## 戻り値 +`constant_wrapper<(T::value -= R::value)>{}`を返す。 + +## 備考 +- `constant_wrapper`が保持する`value`は`const`であるため、保持する値そのものを変更する式（`++value`、`value op= x`、`value = x`）は不適格となる。 +- したがって、このオーバーロードは説明用基底クラス`cw-operators`のインターフェースとして宣言されているものの、`constant_wrapper`に対してはオーバーロード解決に参加せず、使用できない。 + +## バージョン +### 言語 +- C++26 + +### 処理系 +- [Clang](/implementation.md#clang): 23 [mark verified] +- [GCC](/implementation.md#gcc): 16.1 [mark verified] +- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl] + + +## 関連項目 +- [`std::constant_wrapper`](../constant_wrapper.md) + + +## 参照 +- [P2781R9 `std::constant_wrapper`](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p2781r9.html) +- [P3978R3 `constant_wrapper` should unwrap on call and subscript](https://open-std.org/jtc1/sc22/wg21/docs/papers/2026/p3978r3.pdf) diff --git a/reference/utility/constant_wrapper/op_modulo.md b/reference/utility/constant_wrapper/op_modulo.md new file mode 100644 index 0000000000..e87a983ecd --- /dev/null +++ b/reference/utility/constant_wrapper/op_modulo.md @@ -0,0 +1,59 @@ +# operator% +* utility[meta header] +* std[meta namespace] +* function template[meta id-type] +* cpp26[meta cpp] + +```cpp +namespace std { + template + friend constexpr auto operator%(L x, R y) noexcept; +} +``` + +## 概要 +2つの`constant_wrapper`が保持する値の剰余をおこなう。 + +## 戻り値 +`constant_wrapper<(L::value % R::value)>{}`を返す。 + +## 備考 +- *Hidden friends*として定義されるため、引数依存の名前探索 (ADL) でのみ発見される。 +- オペランドのいずれかが`constant_wrapper`でない場合、保持する値へアンラップして通常の演算がおこなわれる。 + +## 例 +```cpp example +#include +#include + +int main() +{ + // オペランドがすべてconstant_wrapperなので、結果もconstant_wrapperになる + auto x = std::cw<7> % std::cw<3>; + static_assert(x == 1); + static_assert(std::is_same_v>); +} +``` + +### 出力 +``` + +``` + +## バージョン +### 言語 +- C++26 + +### 処理系 +- [Clang](/implementation.md#clang): 23 [mark verified] +- [GCC](/implementation.md#gcc): 16.1 [mark verified] +- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl] + + +## 関連項目 +- [`std::constant_wrapper`](../constant_wrapper.md) + + +## 参照 +- [P2781R9 `std::constant_wrapper`](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p2781r9.html) +- [P3978R3 `constant_wrapper` should unwrap on call and subscript](https://open-std.org/jtc1/sc22/wg21/docs/papers/2026/p3978r3.pdf) diff --git a/reference/utility/constant_wrapper/op_modulo_assign.md b/reference/utility/constant_wrapper/op_modulo_assign.md new file mode 100644 index 0000000000..16bd872096 --- /dev/null +++ b/reference/utility/constant_wrapper/op_modulo_assign.md @@ -0,0 +1,41 @@ +# operator%= +* utility[meta header] +* std[meta namespace] +* constant_wrapper[meta class] +* function template[meta id-type] +* cpp26[meta cpp] + +```cpp +namespace std { + template + constexpr auto operator%=(this T self, R y) noexcept; +} +``` + +## 概要 +`constant_wrapper`が保持する値に対して、`%=`による剰余の複合代入をおこなう。 + +## 戻り値 +`constant_wrapper<(T::value %= R::value)>{}`を返す。 + +## 備考 +- `constant_wrapper`が保持する`value`は`const`であるため、保持する値そのものを変更する式（`++value`、`value op= x`、`value = x`）は不適格となる。 +- したがって、このオーバーロードは説明用基底クラス`cw-operators`のインターフェースとして宣言されているものの、`constant_wrapper`に対してはオーバーロード解決に参加せず、使用できない。 + +## バージョン +### 言語 +- C++26 + +### 処理系 +- [Clang](/implementation.md#clang): 23 [mark verified] +- [GCC](/implementation.md#gcc): 16.1 [mark verified] +- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl] + + +## 関連項目 +- [`std::constant_wrapper`](../constant_wrapper.md) + + +## 参照 +- [P2781R9 `std::constant_wrapper`](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p2781r9.html) +- [P3978R3 `constant_wrapper` should unwrap on call and subscript](https://open-std.org/jtc1/sc22/wg21/docs/papers/2026/p3978r3.pdf) diff --git a/reference/utility/constant_wrapper/op_multiply.md b/reference/utility/constant_wrapper/op_multiply.md new file mode 100644 index 0000000000..5ff69654ae --- /dev/null +++ b/reference/utility/constant_wrapper/op_multiply.md @@ -0,0 +1,59 @@ +# operator* +* utility[meta header] +* std[meta namespace] +* function template[meta id-type] +* cpp26[meta cpp] + +```cpp +namespace std { + template + friend constexpr auto operator*(L x, R y) noexcept; +} +``` + +## 概要 +2つの`constant_wrapper`が保持する値の乗算をおこなう。 + +## 戻り値 +`constant_wrapper<(L::value * R::value)>{}`を返す。 + +## 備考 +- *Hidden friends*として定義されるため、引数依存の名前探索 (ADL) でのみ発見される。 +- オペランドのいずれかが`constant_wrapper`でない場合、保持する値へアンラップして通常の演算がおこなわれる。 + +## 例 +```cpp example +#include +#include + +int main() +{ + // オペランドがすべてconstant_wrapperなので、結果もconstant_wrapperになる + auto x = std::cw<6> * std::cw<2>; + static_assert(x == 12); + static_assert(std::is_same_v>); +} +``` + +### 出力 +``` + +``` + +## バージョン +### 言語 +- C++26 + +### 処理系 +- [Clang](/implementation.md#clang): 23 [mark verified] +- [GCC](/implementation.md#gcc): 16.1 [mark verified] +- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl] + + +## 関連項目 +- [`std::constant_wrapper`](../constant_wrapper.md) + + +## 参照 +- [P2781R9 `std::constant_wrapper`](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p2781r9.html) +- [P3978R3 `constant_wrapper` should unwrap on call and subscript](https://open-std.org/jtc1/sc22/wg21/docs/papers/2026/p3978r3.pdf) diff --git a/reference/utility/constant_wrapper/op_multiply_assign.md b/reference/utility/constant_wrapper/op_multiply_assign.md new file mode 100644 index 0000000000..a873f4c6e8 --- /dev/null +++ b/reference/utility/constant_wrapper/op_multiply_assign.md @@ -0,0 +1,41 @@ +# operator*= +* utility[meta header] +* std[meta namespace] +* constant_wrapper[meta class] +* function template[meta id-type] +* cpp26[meta cpp] + +```cpp +namespace std { + template + constexpr auto operator*=(this T self, R y) noexcept; +} +``` + +## 概要 +`constant_wrapper`が保持する値に対して、`*=`による乗算の複合代入をおこなう。 + +## 戻り値 +`constant_wrapper<(T::value *= R::value)>{}`を返す。 + +## 備考 +- `constant_wrapper`が保持する`value`は`const`であるため、保持する値そのものを変更する式（`++value`、`value op= x`、`value = x`）は不適格となる。 +- したがって、このオーバーロードは説明用基底クラス`cw-operators`のインターフェースとして宣言されているものの、`constant_wrapper`に対してはオーバーロード解決に参加せず、使用できない。 + +## バージョン +### 言語 +- C++26 + +### 処理系 +- [Clang](/implementation.md#clang): 23 [mark verified] +- [GCC](/implementation.md#gcc): 16.1 [mark verified] +- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl] + + +## 関連項目 +- [`std::constant_wrapper`](../constant_wrapper.md) + + +## 参照 +- [P2781R9 `std::constant_wrapper`](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p2781r9.html) +- [P3978R3 `constant_wrapper` should unwrap on call and subscript](https://open-std.org/jtc1/sc22/wg21/docs/papers/2026/p3978r3.pdf) diff --git a/reference/utility/constant_wrapper/op_not.md b/reference/utility/constant_wrapper/op_not.md new file mode 100644 index 0000000000..0636f94c93 --- /dev/null +++ b/reference/utility/constant_wrapper/op_not.md @@ -0,0 +1,56 @@ +# operator! +* utility[meta header] +* std[meta namespace] +* function template[meta id-type] +* cpp26[meta cpp] + +```cpp +namespace std { + template + friend constexpr auto operator!(T x) noexcept; +} +``` + +## 概要 +`constant_wrapper`が保持する値の論理否定をとる。 + +## 戻り値 +`constant_wrapper<(!T::value)>{}`を返す。 + +## 備考 +- *Hidden friends*として定義されるため、引数依存の名前探索 (ADL) でのみ発見される。 +- オペランドのいずれかが`constant_wrapper`でない場合、保持する値へアンラップして通常の演算がおこなわれる。 + +## 例 +```cpp example +#include + +int main() +{ + // 比較結果を保持するconstant_wrapperを返す + static_assert(!std::cw); +} +``` + +### 出力 +``` + +``` + +## バージョン +### 言語 +- C++26 + +### 処理系 +- [Clang](/implementation.md#clang): 23 [mark verified] +- [GCC](/implementation.md#gcc): 16.1 [mark verified] +- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl] + + +## 関連項目 +- [`std::constant_wrapper`](../constant_wrapper.md) + + +## 参照 +- [P2781R9 `std::constant_wrapper`](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p2781r9.html) +- [P3978R3 `constant_wrapper` should unwrap on call and subscript](https://open-std.org/jtc1/sc22/wg21/docs/papers/2026/p3978r3.pdf) diff --git a/reference/utility/constant_wrapper/op_not_equal.md b/reference/utility/constant_wrapper/op_not_equal.md new file mode 100644 index 0000000000..811e6a0f58 --- /dev/null +++ b/reference/utility/constant_wrapper/op_not_equal.md @@ -0,0 +1,56 @@ +# operator!= +* utility[meta header] +* std[meta namespace] +* function template[meta id-type] +* cpp26[meta cpp] + +```cpp +namespace std { + template + friend constexpr auto operator!=(L x, R y) noexcept; +} +``` + +## 概要 +2つの`constant_wrapper`が保持する値を`!=`で比較する。 + +## 戻り値 +`constant_wrapper<(L::value != R::value)>{}`を返す。 + +## 備考 +- *Hidden friends*として定義されるため、引数依存の名前探索 (ADL) でのみ発見される。 +- オペランドのいずれかが`constant_wrapper`でない場合、保持する値へアンラップして通常の演算がおこなわれる。 + +## 例 +```cpp example +#include + +int main() +{ + // 比較結果を保持するconstant_wrapperを返す + static_assert(std::cw<5> != std::cw<3>); +} +``` + +### 出力 +``` + +``` + +## バージョン +### 言語 +- C++26 + +### 処理系 +- [Clang](/implementation.md#clang): 23 [mark verified] +- [GCC](/implementation.md#gcc): 16.1 [mark verified] +- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl] + + +## 関連項目 +- [`std::constant_wrapper`](../constant_wrapper.md) + + +## 参照 +- [P2781R9 `std::constant_wrapper`](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p2781r9.html) +- [P3978R3 `constant_wrapper` should unwrap on call and subscript](https://open-std.org/jtc1/sc22/wg21/docs/papers/2026/p3978r3.pdf) diff --git a/reference/utility/constant_wrapper/op_or.md b/reference/utility/constant_wrapper/op_or.md new file mode 100644 index 0000000000..ee49e64b13 --- /dev/null +++ b/reference/utility/constant_wrapper/op_or.md @@ -0,0 +1,59 @@ +# operator| +* utility[meta header] +* std[meta namespace] +* function template[meta id-type] +* cpp26[meta cpp] + +```cpp +namespace std { + template + friend constexpr auto operator|(L x, R y) noexcept; +} +``` + +## 概要 +2つの`constant_wrapper`が保持する値のビット論理和をおこなう。 + +## 戻り値 +`constant_wrapper<(L::value | R::value)>{}`を返す。 + +## 備考 +- *Hidden friends*として定義されるため、引数依存の名前探索 (ADL) でのみ発見される。 +- オペランドのいずれかが`constant_wrapper`でない場合、保持する値へアンラップして通常の演算がおこなわれる。 + +## 例 +```cpp example +#include +#include + +int main() +{ + // オペランドがすべてconstant_wrapperなので、結果もconstant_wrapperになる + auto x = std::cw<6> | std::cw<1>; + static_assert(x == 7); + static_assert(std::is_same_v>); +} +``` + +### 出力 +``` + +``` + +## バージョン +### 言語 +- C++26 + +### 処理系 +- [Clang](/implementation.md#clang): 23 [mark verified] +- [GCC](/implementation.md#gcc): 16.1 [mark verified] +- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl] + + +## 関連項目 +- [`std::constant_wrapper`](../constant_wrapper.md) + + +## 参照 +- [P2781R9 `std::constant_wrapper`](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p2781r9.html) +- [P3978R3 `constant_wrapper` should unwrap on call and subscript](https://open-std.org/jtc1/sc22/wg21/docs/papers/2026/p3978r3.pdf) diff --git a/reference/utility/constant_wrapper/op_or_assign.md b/reference/utility/constant_wrapper/op_or_assign.md new file mode 100644 index 0000000000..db18fc8da4 --- /dev/null +++ b/reference/utility/constant_wrapper/op_or_assign.md @@ -0,0 +1,41 @@ +# operator|= +* utility[meta header] +* std[meta namespace] +* constant_wrapper[meta class] +* function template[meta id-type] +* cpp26[meta cpp] + +```cpp +namespace std { + template + constexpr auto operator|=(this T self, R y) noexcept; +} +``` + +## 概要 +`constant_wrapper`が保持する値に対して、`|=`によるビット論理和の複合代入をおこなう。 + +## 戻り値 +`constant_wrapper<(T::value |= R::value)>{}`を返す。 + +## 備考 +- `constant_wrapper`が保持する`value`は`const`であるため、保持する値そのものを変更する式（`++value`、`value op= x`、`value = x`）は不適格となる。 +- したがって、このオーバーロードは説明用基底クラス`cw-operators`のインターフェースとして宣言されているものの、`constant_wrapper`に対してはオーバーロード解決に参加せず、使用できない。 + +## バージョン +### 言語 +- C++26 + +### 処理系 +- [Clang](/implementation.md#clang): 23 [mark verified] +- [GCC](/implementation.md#gcc): 16.1 [mark verified] +- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl] + + +## 関連項目 +- [`std::constant_wrapper`](../constant_wrapper.md) + + +## 参照 +- [P2781R9 `std::constant_wrapper`](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p2781r9.html) +- [P3978R3 `constant_wrapper` should unwrap on call and subscript](https://open-std.org/jtc1/sc22/wg21/docs/papers/2026/p3978r3.pdf) diff --git a/reference/utility/constant_wrapper/op_plus.md b/reference/utility/constant_wrapper/op_plus.md new file mode 100644 index 0000000000..4014ee7094 --- /dev/null +++ b/reference/utility/constant_wrapper/op_plus.md @@ -0,0 +1,59 @@ +# operator+ +* utility[meta header] +* std[meta namespace] +* function template[meta id-type] +* cpp26[meta cpp] + +```cpp +namespace std { + template + friend constexpr auto operator+(L x, R y) noexcept; +} +``` + +## 概要 +2つの`constant_wrapper`が保持する値の加算をおこなう。 + +## 戻り値 +`constant_wrapper<(L::value + R::value)>{}`を返す。 + +## 備考 +- *Hidden friends*として定義されるため、引数依存の名前探索 (ADL) でのみ発見される。 +- オペランドのいずれかが`constant_wrapper`でない場合、保持する値へアンラップして通常の演算がおこなわれる。 + +## 例 +```cpp example +#include +#include + +int main() +{ + // オペランドがすべてconstant_wrapperなので、結果もconstant_wrapperになる + auto x = std::cw<6> + std::cw<2>; + static_assert(x == 8); + static_assert(std::is_same_v>); +} +``` + +### 出力 +``` + +``` + +## バージョン +### 言語 +- C++26 + +### 処理系 +- [Clang](/implementation.md#clang): 23 [mark verified] +- [GCC](/implementation.md#gcc): 16.1 [mark verified] +- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl] + + +## 関連項目 +- [`std::constant_wrapper`](../constant_wrapper.md) + + +## 参照 +- [P2781R9 `std::constant_wrapper`](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p2781r9.html) +- [P3978R3 `constant_wrapper` should unwrap on call and subscript](https://open-std.org/jtc1/sc22/wg21/docs/papers/2026/p3978r3.pdf) diff --git a/reference/utility/constant_wrapper/op_plus_assign.md b/reference/utility/constant_wrapper/op_plus_assign.md new file mode 100644 index 0000000000..775449aa7e --- /dev/null +++ b/reference/utility/constant_wrapper/op_plus_assign.md @@ -0,0 +1,41 @@ +# operator+= +* utility[meta header] +* std[meta namespace] +* constant_wrapper[meta class] +* function template[meta id-type] +* cpp26[meta cpp] + +```cpp +namespace std { + template + constexpr auto operator+=(this T self, R y) noexcept; +} +``` + +## 概要 +`constant_wrapper`が保持する値に対して、`+=`による加算の複合代入をおこなう。 + +## 戻り値 +`constant_wrapper<(T::value += R::value)>{}`を返す。 + +## 備考 +- `constant_wrapper`が保持する`value`は`const`であるため、保持する値そのものを変更する式（`++value`、`value op= x`、`value = x`）は不適格となる。 +- したがって、このオーバーロードは説明用基底クラス`cw-operators`のインターフェースとして宣言されているものの、`constant_wrapper`に対してはオーバーロード解決に参加せず、使用できない。 + +## バージョン +### 言語 +- C++26 + +### 処理系 +- [Clang](/implementation.md#clang): 23 [mark verified] +- [GCC](/implementation.md#gcc): 16.1 [mark verified] +- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl] + + +## 関連項目 +- [`std::constant_wrapper`](../constant_wrapper.md) + + +## 参照 +- [P2781R9 `std::constant_wrapper`](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p2781r9.html) +- [P3978R3 `constant_wrapper` should unwrap on call and subscript](https://open-std.org/jtc1/sc22/wg21/docs/papers/2026/p3978r3.pdf) diff --git a/reference/utility/constant_wrapper/op_right_shift.md b/reference/utility/constant_wrapper/op_right_shift.md new file mode 100644 index 0000000000..96b302fbdf --- /dev/null +++ b/reference/utility/constant_wrapper/op_right_shift.md @@ -0,0 +1,59 @@ +# operator>> +* utility[meta header] +* std[meta namespace] +* function template[meta id-type] +* cpp26[meta cpp] + +```cpp +namespace std { + template + friend constexpr auto operator>>(L x, R y) noexcept; +} +``` + +## 概要 +2つの`constant_wrapper`が保持する値の右シフトをおこなう。 + +## 戻り値 +`constant_wrapper<(L::value >> R::value)>{}`を返す。 + +## 備考 +- *Hidden friends*として定義されるため、引数依存の名前探索 (ADL) でのみ発見される。 +- オペランドのいずれかが`constant_wrapper`でない場合、保持する値へアンラップして通常の演算がおこなわれる。 + +## 例 +```cpp example +#include +#include + +int main() +{ + // オペランドがすべてconstant_wrapperなので、結果もconstant_wrapperになる + auto x = std::cw<16> >> std::cw<2>; + static_assert(x == 4); + static_assert(std::is_same_v>); +} +``` + +### 出力 +``` + +``` + +## バージョン +### 言語 +- C++26 + +### 処理系 +- [Clang](/implementation.md#clang): 23 [mark verified] +- [GCC](/implementation.md#gcc): 16.1 [mark verified] +- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl] + + +## 関連項目 +- [`std::constant_wrapper`](../constant_wrapper.md) + + +## 参照 +- [P2781R9 `std::constant_wrapper`](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p2781r9.html) +- [P3978R3 `constant_wrapper` should unwrap on call and subscript](https://open-std.org/jtc1/sc22/wg21/docs/papers/2026/p3978r3.pdf) diff --git a/reference/utility/constant_wrapper/op_right_shift_assign.md b/reference/utility/constant_wrapper/op_right_shift_assign.md new file mode 100644 index 0000000000..b2dbd81b54 --- /dev/null +++ b/reference/utility/constant_wrapper/op_right_shift_assign.md @@ -0,0 +1,41 @@ +# operator>>= +* utility[meta header] +* std[meta namespace] +* constant_wrapper[meta class] +* function template[meta id-type] +* cpp26[meta cpp] + +```cpp +namespace std { + template + constexpr auto operator>>=(this T self, R y) noexcept; +} +``` + +## 概要 +`constant_wrapper`が保持する値に対して、`>>=`による右シフトの複合代入をおこなう。 + +## 戻り値 +`constant_wrapper<(T::value >>= R::value)>{}`を返す。 + +## 備考 +- `constant_wrapper`が保持する`value`は`const`であるため、保持する値そのものを変更する式（`++value`、`value op= x`、`value = x`）は不適格となる。 +- したがって、このオーバーロードは説明用基底クラス`cw-operators`のインターフェースとして宣言されているものの、`constant_wrapper`に対してはオーバーロード解決に参加せず、使用できない。 + +## バージョン +### 言語 +- C++26 + +### 処理系 +- [Clang](/implementation.md#clang): 23 [mark verified] +- [GCC](/implementation.md#gcc): 16.1 [mark verified] +- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl] + + +## 関連項目 +- [`std::constant_wrapper`](../constant_wrapper.md) + + +## 参照 +- [P2781R9 `std::constant_wrapper`](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p2781r9.html) +- [P3978R3 `constant_wrapper` should unwrap on call and subscript](https://open-std.org/jtc1/sc22/wg21/docs/papers/2026/p3978r3.pdf) diff --git a/reference/utility/constant_wrapper/op_unary_minus.md b/reference/utility/constant_wrapper/op_unary_minus.md new file mode 100644 index 0000000000..b3039d443c --- /dev/null +++ b/reference/utility/constant_wrapper/op_unary_minus.md @@ -0,0 +1,59 @@ +# operator- (単項) +* utility[meta header] +* std[meta namespace] +* function template[meta id-type] +* cpp26[meta cpp] + +```cpp +namespace std { + template + friend constexpr auto operator-(T x) noexcept; +} +``` + +## 概要 +`constant_wrapper`が保持する値の符号を反転する。 + +## 戻り値 +`constant_wrapper<(-T::value)>{}`を返す。 + +## 備考 +- *Hidden friends*として定義されるため、引数依存の名前探索 (ADL) でのみ発見される。 +- オペランドのいずれかが`constant_wrapper`でない場合、保持する値へアンラップして通常の演算がおこなわれる。 + +## 例 +```cpp example +#include +#include + +int main() +{ + // オペランドがすべてconstant_wrapperなので、結果もconstant_wrapperになる + auto x = -std::cw<5>; + static_assert(x == -5); + static_assert(std::is_same_v>); +} +``` + +### 出力 +``` + +``` + +## バージョン +### 言語 +- C++26 + +### 処理系 +- [Clang](/implementation.md#clang): 23 [mark verified] +- [GCC](/implementation.md#gcc): 16.1 [mark verified] +- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl] + + +## 関連項目 +- [`std::constant_wrapper`](../constant_wrapper.md) + + +## 参照 +- [P2781R9 `std::constant_wrapper`](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p2781r9.html) +- [P3978R3 `constant_wrapper` should unwrap on call and subscript](https://open-std.org/jtc1/sc22/wg21/docs/papers/2026/p3978r3.pdf) diff --git a/reference/utility/constant_wrapper/op_unary_plus.md b/reference/utility/constant_wrapper/op_unary_plus.md new file mode 100644 index 0000000000..0ec3bafe76 --- /dev/null +++ b/reference/utility/constant_wrapper/op_unary_plus.md @@ -0,0 +1,59 @@ +# operator+ (単項) +* utility[meta header] +* std[meta namespace] +* function template[meta id-type] +* cpp26[meta cpp] + +```cpp +namespace std { + template + friend constexpr auto operator+(T x) noexcept; +} +``` + +## 概要 +`constant_wrapper`が保持する値に単項`+`を適用する。 + +## 戻り値 +`constant_wrapper<(+T::value)>{}`を返す。 + +## 備考 +- *Hidden friends*として定義されるため、引数依存の名前探索 (ADL) でのみ発見される。 +- オペランドのいずれかが`constant_wrapper`でない場合、保持する値へアンラップして通常の演算がおこなわれる。 + +## 例 +```cpp example +#include +#include + +int main() +{ + // オペランドがすべてconstant_wrapperなので、結果もconstant_wrapperになる + auto x = +std::cw<5>; + static_assert(x == 5); + static_assert(std::is_same_v>); +} +``` + +### 出力 +``` + +``` + +## バージョン +### 言語 +- C++26 + +### 処理系 +- [Clang](/implementation.md#clang): 23 [mark verified] +- [GCC](/implementation.md#gcc): 16.1 [mark verified] +- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl] + + +## 関連項目 +- [`std::constant_wrapper`](../constant_wrapper.md) + + +## 参照 +- [P2781R9 `std::constant_wrapper`](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p2781r9.html) +- [P3978R3 `constant_wrapper` should unwrap on call and subscript](https://open-std.org/jtc1/sc22/wg21/docs/papers/2026/p3978r3.pdf) diff --git a/reference/utility/constant_wrapper/op_value_type.md b/reference/utility/constant_wrapper/op_value_type.md new file mode 100644 index 0000000000..9197efbc56 --- /dev/null +++ b/reference/utility/constant_wrapper/op_value_type.md @@ -0,0 +1,53 @@ +# operator value_type +* utility[meta header] +* std[meta namespace] +* constant_wrapper[meta class] +* function[meta id-type] +* cpp26[meta cpp] + +```cpp +namespace std { + constexpr operator value_type() const noexcept; +} +``` + +## 概要 +保持する値`value`への暗黙の変換をおこなう。これにより、`constant_wrapper`を通常の値として扱える。 + +## 戻り値 +`value`を返す。 + +## 例 +```cpp example +#include + +int main() +{ + // 変換演算子により、constant_wrapperを通常の値として使用できる + int n = std::cw<42>; + static_assert(std::cw<42> == 42); +} +``` + +### 出力 +``` + +``` + +## バージョン +### 言語 +- C++26 + +### 処理系 +- [Clang](/implementation.md#clang): 23 [mark verified] +- [GCC](/implementation.md#gcc): 16.1 [mark verified] +- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl] + + +## 関連項目 +- [`std::constant_wrapper`](../constant_wrapper.md) + + +## 参照 +- [P2781R9 `std::constant_wrapper`](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p2781r9.html) +- [P3978R3 `constant_wrapper` should unwrap on call and subscript](https://open-std.org/jtc1/sc22/wg21/docs/papers/2026/p3978r3.pdf) diff --git a/reference/utility/constant_wrapper/op_xor.md b/reference/utility/constant_wrapper/op_xor.md new file mode 100644 index 0000000000..f7031adc7b --- /dev/null +++ b/reference/utility/constant_wrapper/op_xor.md @@ -0,0 +1,59 @@ +# operator^ +* utility[meta header] +* std[meta namespace] +* function template[meta id-type] +* cpp26[meta cpp] + +```cpp +namespace std { + template + friend constexpr auto operator^(L x, R y) noexcept; +} +``` + +## 概要 +2つの`constant_wrapper`が保持する値のビット排他的論理和をおこなう。 + +## 戻り値 +`constant_wrapper<(L::value ^ R::value)>{}`を返す。 + +## 備考 +- *Hidden friends*として定義されるため、引数依存の名前探索 (ADL) でのみ発見される。 +- オペランドのいずれかが`constant_wrapper`でない場合、保持する値へアンラップして通常の演算がおこなわれる。 + +## 例 +```cpp example +#include +#include + +int main() +{ + // オペランドがすべてconstant_wrapperなので、結果もconstant_wrapperになる + auto x = std::cw<6> ^ std::cw<3>; + static_assert(x == 5); + static_assert(std::is_same_v>); +} +``` + +### 出力 +``` + +``` + +## バージョン +### 言語 +- C++26 + +### 処理系 +- [Clang](/implementation.md#clang): 23 [mark verified] +- [GCC](/implementation.md#gcc): 16.1 [mark verified] +- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl] + + +## 関連項目 +- [`std::constant_wrapper`](../constant_wrapper.md) + + +## 参照 +- [P2781R9 `std::constant_wrapper`](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p2781r9.html) +- [P3978R3 `constant_wrapper` should unwrap on call and subscript](https://open-std.org/jtc1/sc22/wg21/docs/papers/2026/p3978r3.pdf) diff --git a/reference/utility/constant_wrapper/op_xor_assign.md b/reference/utility/constant_wrapper/op_xor_assign.md new file mode 100644 index 0000000000..7c40913589 --- /dev/null +++ b/reference/utility/constant_wrapper/op_xor_assign.md @@ -0,0 +1,41 @@ +# operator^= +* utility[meta header] +* std[meta namespace] +* constant_wrapper[meta class] +* function template[meta id-type] +* cpp26[meta cpp] + +```cpp +namespace std { + template + constexpr auto operator^=(this T self, R y) noexcept; +} +``` + +## 概要 +`constant_wrapper`が保持する値に対して、`^=`によるビット排他的論理和の複合代入をおこなう。 + +## 戻り値 +`constant_wrapper<(T::value ^= R::value)>{}`を返す。 + +## 備考 +- `constant_wrapper`が保持する`value`は`const`であるため、保持する値そのものを変更する式（`++value`、`value op= x`、`value = x`）は不適格となる。 +- したがって、このオーバーロードは説明用基底クラス`cw-operators`のインターフェースとして宣言されているものの、`constant_wrapper`に対してはオーバーロード解決に参加せず、使用できない。 + +## バージョン +### 言語 +- C++26 + +### 処理系 +- [Clang](/implementation.md#clang): 23 [mark verified] +- [GCC](/implementation.md#gcc): 16.1 [mark verified] +- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl] + + +## 関連項目 +- [`std::constant_wrapper`](../constant_wrapper.md) + + +## 参照 +- [P2781R9 `std::constant_wrapper`](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p2781r9.html) +- [P3978R3 `constant_wrapper` should unwrap on call and subscript](https://open-std.org/jtc1/sc22/wg21/docs/papers/2026/p3978r3.pdf) diff --git a/start_editing/page_names.md b/start_editing/page_names.md index b1e2ba1ab4..b947d57ad8 100644 --- a/start_editing/page_names.md +++ b/start_editing/page_names.md @@ -22,7 +22,9 @@ cpprefjpサイトでは、ページファイル名の付け方について、い | `operator[ ]` | 添字演算子 | `op_at` | | | `operator()` | 関数呼び出し演算子 | `op_call` | | | `operator*` (単項) | 間接参照演算子 | `op_deref` | dereferenceの略 | +| `operator&` (単項) | アドレス取得演算子 | `op_address` | | | `operator->` | ポインタアクセス演算子 | `op_arrow` | | +| `operator->*` | メンバポインタ参照演算子 | `op_member_pointer` | | | `operator+=` | 加算の複合代入 | `op_plus_assign` | | | `operator-=` | 減算の複合代入 | `op_minus_assign` | | | `operator*=` | 乗算の複合代入 | `op_multiply_assign` | | @@ -63,6 +65,7 @@ cpprefjpサイトでは、ページファイル名の付け方について、い | `operator>>` | ビット右シフト演算子 | `op_right_shift` | | | `operator<<` | 出力ストリーム演算子 | `op_ostream` | ビットシフトと意味論が異なるため、別ページとしている | | `operator>>` | 入力ストリーム演算子 | `op_istream` | ビットシフトと意味論が異なるため、別ページとしている | +| `operator,` | カンマ演算子 | `op_comma` | | C++にはこの表に含まれない演算子もいくつかあるが、ここでは標準ライブラリでオーバーロードされ、本サイトが掲載している演算子のみを記載している。