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

address -- atomic_ref::address : C++26で戻り値型が`void*`に変更になった (close #1631)

2026-06-09T12:37:47+09:00

diff --git a/reference/atomic/atomic_ref/address.md b/reference/atomic/atomic_ref/address.md
index dad2c19b6..9b89555bf 100644
--- a/reference/atomic/atomic_ref/address.md
+++ b/reference/atomic/atomic_ref/address.md
@@ -6,12 +6,15 @@
 * cpp26[meta cpp]
 
 ```cpp
-constexpr T* address() const noexcept;
+constexpr address-return-type address() const noexcept;
 ```
+* address-return-type[italic]
 
 ## 概要
 参照しているオブジェクトのアドレスを取得する。
 
+戻り値型`address-return-type`は説明専用の型エイリアスであり、`COPYCV(T, void)*`と定義される。`COPYCV(T, void)`は、`T`の最上位のCV修飾を`void`に付加した型である。たとえば`atomic_ref<int>`では`void*`、`atomic_ref<const int>`では`const void*`を返す。
+
 ### この関数を必要とする状況
 #### データ構造の要素へのアトミックアクセス
 配列の各要素にアトミックアクセスする際、[`std::atomic`](/reference/atomic/atomic.md)オブジェクトでは以下のように記述する。
@@ -29,7 +32,7 @@ int fetch_add_idx(std::atomic<int>* base, size_t i, int value) {
 
 ```cpp
 int fetch_add_idx(std::atomic_ref<int> base, size_t i, int value) {
-  int* p = base.address();
+  int* p = static_cast<int*>(base.address());
   return std::atomic_ref{*(p+i)}.fetch_add(value);
 }
 ```
@@ -41,7 +44,7 @@ int fetch_add_idx(std::atomic_ref<int> base, size_t i, int value) {
 ```cpp
 void thread(atomic_ref<int>* data, atomic_ref<int> counter, int nthreads) {
   data->fetch_add(42, memory_order_relaxed);
-  int* d = data->address();       // dataへの生ポインタを取得
+  int* d = static_cast<int*>(data->address()); // dataへの生ポインタを取得
   data->~atomic_ref();            // このスレッドのデータへのatomic_refを破棄する
   int pos = counter.fetch_add(1); // データの破棄が完了したことを伝える
   if (pos != (nthreads - 1))
@@ -55,13 +58,26 @@ void thread(atomic_ref<int>* data, atomic_ref<int> counter, int nthreads) {
 
 
 ## 戻り値
-`*this`が参照するオブジェクトをアドレス値を返す
+`*this`が参照するオブジェクトを指すポインタを、`T`のCV修飾を引き継いだ`void`へのポインタとして返す
 
 
 ## 例外
 投げない
 
 
+## 備考
+- 戻り値を`void`へのポインタとしているのは、参照先オブジェクトへの不用意なアクセスという誤用を防ぐためである
+    - この関数の主な用途は、ポインタ値そのもの（ハッシュ化や比較、配列のインデックス計算など）を使うことである。一方、参照先のオブジェクトを直接読み書きすると、同じオブジェクトを参照するほかの`atomic_ref`が生存している状況ではデータ競合となる
+    - 仮に戻り値が`T*`であれば、以下のように参照先を何気なく読み書きでき、アトミック性を壊すアクセスに気付きにくいという問題が起きる：
+    ```cpp
+    int x = 0;
+    std::atomic_ref ar{x};
+
+    int* p = ar.address(); // 戻り値型がT*であった場合、
+    int value = *p;        // 非アトミックな間接参照が容易にできてしまう
+    ```
+
+
 ## 例
 ```cpp example
 #include <iostream>
@@ -69,8 +85,8 @@ void thread(atomic_ref<int>* data, atomic_ref<int> counter, int nthreads) {
 #include <thread>
 
 void f(std::atomic_ref<int> ar, int i) {
-  int* p = ar.address();
-  std::atomic_ref{p + i}.fetch_add(1);
+  int* p = static_cast<int*>(ar.address());
+  std::atomic_ref{*(p + i)}.fetch_add(1);
 }
 
 int main()
@@ -109,3 +125,5 @@ int main()
 
 ## 参照
 - [P2835R7 Expose `std::atomic_ref` 's object address](https://open-std.org/jtc1/sc22/wg21/docs/papers/2024/p2835r7.html)
+- [P3936R1 Safer `atomic_ref::address` (FR-030-310)](https://open-std.org/jtc1/sc22/wg21/docs/papers/2026/p3936r1.pdf)
+    - C++26で、誤用を防ぐために戻り値型を`T*`から`COPYCV(T, void)*`（`T`のCV修飾を引き継いだ`void`へのポインタ）に変更した

C++26 -- C++26対応として、C23標準ライブラリを追加 (#1657)

2026-06-08T20:56:08+09:00

C++26

概要

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

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

言語機能

変数

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

文字列

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

分岐・ループ

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

関数

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

クラス

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

属性

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

テンプレート

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

定数式

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

プリプロセッサ

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

ソースコード

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

モジュール

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

機能の非推奨化

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

機能の削除

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

ライブラリ更新の概要

新ライブラリ

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

全体

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

コンテナ

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

アルゴリズム

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

関数オブジェクト

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

文字列

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

ファイル

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

入出力

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

並行・並列・非同期処理

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

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

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

日付・時間

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

数値

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

ユーティリティ

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

デバッグ

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

型特性

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

制約

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

機能の非推奨化

<type_traits>のstd::is_trivialを非推奨化
- これはstd::is_trivially_copyableとstd::is_trivially_default_constructibleの2つが合わさったものであるが、それらは異なる状況で必要になるものであった
std::memory_order::consumeと、それに関連してstd::kill_dependency()を非推奨化し、[[carries_dependency]]属性を削除
std::filesystem::pathクラスの、以下の非テンプレート版メンバ関数を非推奨化
- string()
- generic_string()
- これらは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対応として、C23標準ライブラリを追加 (#1657)

2026-06-08T20:56:08+09:00

リファレンス

言語サポートライブラリ

ヘッダ	説明	対応バージョン
`<limits>`	実装プロパティ
`<version>`	実装依存のバージョン情報	C++20
`<stdfloat>`	拡張浮動小数点数型	C++23
`<new>`	動的メモリ管理
`<typeinfo>`	型情報
`<source_location>`	ソースコード上の位置	C++20
`<exception>`	例外ハンドリング
`<initializer_list>`	初期化子リスト	C++11
`<compare>`	比較演算	C++20
`<coroutine>`	コルーチン	C++20

コンセプトライブラリ

ヘッダ	説明	対応バージョン
`<concepts>`	言語関係のコンセプト	C++20

診断ライブラリ

ヘッダ	説明	対応バージョン
`<stdexcept>`	例外クラス
`<system_error>`	システムエラーサポート	C++11

汎用的なユーティリティライブラリ

ヘッダ	説明	対応バージョン
`<utility>`	ユーティリティコンポーネント
`<bitset>`	ビットの固定サイズシーケンス
`<ratio>`	コンパイル時有理数	C++11
`<tuple>`	タプル	C++11
`<optional>`	任意で値を持たせられるオブジェクト	C++17
`<variant>`	候補の型を切り替えながら保持できる記憶域型	C++17
`<any>`	あらゆる型の値を保持できる記憶域型	C++17
`<expected>`	正常値かエラー値のどちらかを持たせられるオブジェクト	C++23
`<type_traits>`	型特性	C++11
`<functional>`	関数オブジェクト
`<memory>`	メモリ
`<scoped_allocator>`	スコープ付きアロケータ	C++11
`<memory_resource>`	多相アロケータ	C++17
`<chrono>`	時間ユーティリティ	C++11
`<typeindex>`	型のインデックス	C++11
`<execution>`	実行ポリシー、実行制御ライブラリ(C++26)	C++17
`<charconv>`	高速な文字列 ⇔ 数値変換	C++17
`<format>`	文字列フォーマット	C++20
`<stacktrace>`	スタックトレース	C++23
`<meta>`	静的リフレクション	C++26

文字列ライブラリ

ヘッダ	説明	対応バージョン
`<string>`	文字列クラスと、文字特性
`<string_view>`	所有権を持たず文字列を参照する文字列クラス	C++17

ローカライズライブラリ

ヘッダ	説明	対応バージョン
`<locale>`	ロケール
`<text_encoding>`	文字列エンコーディングの識別	C++26
`<codecvt>`	コード変換ファセット	C++11 C++17から非推奨 C++26で削除

コンテナライブラリ

ヘッダ	説明	対応バージョン
`<array>`	配列	C++11
`<deque>`	両端キュー
`<forward_list>`	単方向リスト	C++11
`<list>`	双方向リスト
`<queue>`	FIFOキュー
`<stack>`	LIFOスタック
`<vector>`	可変長配列
`<inplace_vector>`	容量固定の可変長配列	C++26
`<map>`	順序付き連想配列
`<set>`	順序付き集合
`<flat_map>`	ソート済みキーによる順序付き連想配列	C++23
`<flat_set>`	ソート済みキーによる順序付き集合	C++23
`<unordered_map>`	非順序連想配列	C++11
`<unordered_set>`	非順序集合	C++11
`<span>`	部分シーケンスの参照	C++20
`<mdspan>`	多次元配列ビュー	C++23

イテレータライブラリ

ヘッダ	説明	対応バージョン
`<iterator>`	イテレータの定義

レンジライブラリ

ヘッダ	説明	対応バージョン
`<ranges>`	レンジアルゴリズム	C++20
`<generator>`	コルーチンによるレンジ生成	C++23

アルゴリズムライブラリ

ヘッダ	説明	対応バージョン
`<algorithm>`	アルゴリズム

数値ライブラリ

ヘッダ	説明	対応バージョン
`<complex>`	複素数
`<bit>`	ビット操作	C++20
`<random>`	乱数生成	C++11
`<valarray>`	数値の配列
`<numeric>`	一般的な数値操作
`<numbers>`	数値	C++20
`<linalg>`	線形代数	C++26

デバッグライブラリ

ヘッダ	説明	対応バージョン
`<debugging>`	デバッグサポート	C++26
`<contracts>`	契約プログラミング	C++26

入出力ライブラリ

ヘッダ	説明	対応バージョン
`<iosfwd>`	先行宣言
`<iostream>`	標準`iostream`オブジェクト
`<ios>`	`iostream`基底クラス
`<streambuf>`	ストリームバッファ
`<istream>`	入力ストリーム
`<ostream>`	出力ストリーム
`<iomanip>`	フォーマットとマニピュレータ
`<sstream>`	文字列ストリーム
`<strstream>`	古い文字列ストリーム	C++98から非推奨 C++26で削除
`<fstream>`	ファイルストリーム
`<filesystem>`	ファイルシステム	C++17
`<syncstream>`	同期化出力ストリームラッパー	C++20
`<spanstream>`	メモリバッファの所有権をもたないストリーム	C++23
`<print>`	書式指定による出力	C++23

正規表現ライブラリ

ヘッダ	説明	対応バージョン
`<regex>`	正規表現	C++11

アトミック操作ライブラリ

ヘッダ	説明	対応バージョン
`<atomic>`	アトミックアクセスのためのコンポーネント	C++11
`<stdatomic.h>`	アトミック操作のC互換ライブラリ	C++23

スレッドサポートライブラリ

ヘッダ	説明	対応バージョン
`<stop_token>`	停止状態	C++20
`<thread>`	スレッド	C++11
`<mutex>`	ミューテックス	C++11
`<shared_mutex>`	共有ミューテックス	C++14
`<condition_variable>`	条件変数	C++11
`<semaphore>`	セマフォ	C++20
`<latch>`	ラッチ同期	C++20
`<barrier>`	バリア同期	C++20
`<future>`	Future	C++11
`<rcu>`	データの参照・更新	C++26
`<hazard_pointer>`	ハザードポインタ	C++26
`<simd>`	データ並列	C++26

C言語互換ライブラリ

ヘッダ	説明	対応バージョン
`<cassert>`	アサート
`<ccomplex>`	複素数	C++11 (C99) C++17で非推奨 C++20で削除
`<cctype>`	文字種別の判定と変換
`<cerrno>`	エラー番号
`<cfenv>`	浮動小数点環境へのアクセス	C++11 (C99)
`<cfloat>`	浮動小数点数の定数
`<cinttypes>`	固定精度整数のための書式指定マクロ	C++11 (C99)
`<ciso646>`	`&&`に対する別名`and`のような、各種演算子に対するマクロを定義する。ただしC++ではこれらの別名はキーワードとして定義されるため、このヘッダでは何も定義されない。	C++20で削除
`<climits>`	整数型の最小値、最大値を表すマクロ
`<clocale>`	ロケール
`<cmath>`	数学関数
`<csetjmp>`	ジャンプ処理
`<csignal>`	シグナル
`<cstdalign>`	アライメント操作のマクロ	C++17で非推奨 C++20で削除
`<cstdarg>`	可変引数操作
`<stdbit.h>`	ビット操作	C++26
`<stdckdint.h>`	検査付き整数演算	C++26
`<cstdbool>`	真理値型の定義	C++11 (C99) C++17で非推奨 C++20で削除
`<cstddef>`	基本的な型、値、マクロの定義
`<cstdint>`	大きさが規定されている整数型	C++11 (C99)
`<cstdio>`	入出力
`<cstdlib>`	ユーティリティ関数
`<cstring>`	文字列操作
`<ctgmath>`	ジェネリックな数学関数	C++11 (C99) C++17で非推奨 C++20で削除
`<ctime>`	日付・時間
`<cuchar>`	ユニコード文字型	C++11 (C11)
`<cwchar>`	ワイド文字型
`<cwctype>`	ワイド文字の種別と判定

説明専用ライブラリ

ヘッダ	説明	対応バージョン
`exposition-only`	説明のためのものを集めたページ (実際のライブラリではない)

参照

P2867R2 Remove Deprecated strstreams From C++26

cfloat -- C++26対応として、C23標準ライブラリを追加 (#1657)

2026-06-08T20:56:08+09:00

cfloat

<cfloat>ヘッダでは、浮動小数点数に関連する定数値マクロを定義する。これは、C言語の標準ライブラリ<float.h>と同じである。

本ヘッダはフリースタンディング環境でも提供される。

浮動小数点数 $x$ は以下のようにモデル化される。

$$x = sb^e\sum^p_{k=1}f_kb^{-k},\qquad e_{\rm min} \le e \le e_{\rm max}$$

各パラメータは以下の通り。

$$ \begin{array}{ll} s&\text{符号($\pm 1$)}\\ b&\text{指数表現の基数(1 より大きい整数)}\\ e&\text{指数(最小 $e_{\rm min}$ 最大 $e_{\rm max}$ の整数)}\\ p&\text{精度(基数 $b$ での仮数部の桁数)}\\ f_k&\text{$b$ より小さい非負整数(仮数部の有効数字)}\\ \end{array} $$

浮動小数点型で表される値としては、ゼロと $f_1 \gt 0$ である正規化数の他に、$e = e_{\rm min}$ かつ $f_1 = 0$ である非正規化数（subnormal numbers）、$e \gt e_{\rm min}$ かつ $f_1 = 0$ である正規化されていない数（unnormalized numbers）、および、浮動小数点数ではない無限大や NaN 等が含まれているかもしれない（実装によっては含まれていないかもしれない）。
NaN とは非数（Not-a-Number）を表し、ほとんど全ての演算で浮動小数点例外を起こさず結果に伝播する quiet NaN（quiet：静かな）と、演算のオペランドに使用されると浮動小数点例外を引き起こす signaling NaN（signaling：信号を発する）がある。
ゼロと浮動小数点数ではない値（無限大や NaN 等）には符号があるかもしれない（実装によっては無いかもしれない）。

本ヘッダで提供される整数値を表すマクロは、FLT_ROUNDS を除いて #if プリプロセッサディレクティブに使用可能な定数式である。

丸め

マクロ	説明	対応バージョン
`FLT_ROUNDS`	浮動小数点加算の丸めモード

基数

マクロ	説明	対応バージョン
`FLT_RADIX`	指数表現の基数。上記モデルでは、$b$

浮動小数点の評価方法

マクロ	説明	対応バージョン
`FLT_EVAL_METHOD`	浮動小数点数がどのように評価されるかを表す整数値	C++11

桁数

マクロ	説明	対応バージョン
`FLT_DIG`	`float`で正確に表現可能な10進数の最大の桁数。上記モデルでは、$b$ が $10$ の累乗の場合、$p \log_{10} b$、それ以外の場合、$\lfloor (p - 1)\log_{10} b\rfloor$
`DBL_DIG`	`double`で正確に表現可能な10進数の最大の桁数。上記モデルでは、$b$ が $10$ の累乗の場合、$p \log_{10} b$、それ以外の場合、$\lfloor (p - 1)\log_{10} b\rfloor$
`LDBL_DIG`	`long double`で正確に表現可能な10進数の最大の桁数。上記モデルでは、$b$ が $10$ の累乗の場合、$p \log_{10} b$、それ以外の場合、$\lfloor (p - 1)\log_{10} b\rfloor$
`FLT_DECIMAL_DIG`	`float`の数値を10進数で正確に表すのに必要な有効数字の桁数。上記モデルでは、$b$ が $10$ の累乗の場合、$p \log_{10} b$、それ以外の場合、$\lceil 1 + p \log_{10} b\rceil$	C++17
`DBL_DECIMAL_DIG`	`double`の数値を10進数で正確に表すのに必要な有効数字の桁数。上記モデルでは、$b$ が $10$ の累乗の場合、$p \log_{10} b$、それ以外の場合、$\lceil 1 + p \log_{10} b\rceil$	C++17
`LDBL_DECIMAL_DIG`	`long double`の数値を10進数で正確に表すのに必要な有効数字の桁数。上記モデルでは、$b$ が $10$ の累乗の場合、$p \log_{10} b$、それ以外の場合、$\lceil 1 + p \log_{10} b\rceil$	C++17
`DECIMAL_DIG`	精度が一番高い浮動小数点型の数値を10進数で正確に表すのに必要な有効数字の桁数。上記モデルでは、$p_{\rm max}$ を精度が一番高い浮動小数点型の $p$ とすると、$b$ が $10$ の累乗の場合、$p_{\rm max} \log_{10} b$、それ以外の場合、$\lceil 1 + p_{\rm max}\log_{10} b\rceil$	C++11 C++26で非推奨
`FLT_MANT_DIG`	`float`を基数 `FLT_RADIX` で表現した際の仮数部の桁数。上記モデルでは、$p$
`DBL_MANT_DIG`	`double`を基数 `FLT_RADIX` で表現した際の仮数部の桁数。上記モデルでは、$p$
`LDBL_MANT_DIG`	`long double`を基数 `FLT_RADIX` で表現した際の仮数部の桁数。上記モデルでは、$p$

機械イプシロン

マクロ	説明	対応バージョン
`FLT_EPSILON`	`float`における、$1$ と $1$ より大きい最小の数との差。（機械イプシロン）上記モデルでは、$b^{1-p}$
`DBL_EPSILON`	`double`における、$1$ と $1$ より大きい最小の数との差。（機械イプシロン）上記モデルでは、$b^{1-p}$
`LDBL_EPSILON`	`long double`における、$1$ と $1$ より大きい最小の数との差。（機械イプシロン）上記モデルでは、$b^{1-p}$

非正規化数

マクロ	説明	対応バージョン
`FLT_HAS_SUBNORM`	`float`における非正規化数のサポート状況を判定する	C++17 C++26で非推奨
`DBL_HAS_SUBNORM`	`double`における非正規化数のサポート状況を判定する	C++17 C++26で非推奨
`LDBL_HAS_SUBNORM`	`long double`における非正規化数のサポート状況を判定する	C++17 C++26で非推奨

無限大とNaN

マクロ	説明	対応バージョン
`INFINITY`	`float`型の正の無限大	C++26で`<cfloat>`に追加
`NAN`	`float`型のquiet NaN	C++26で`<cfloat>`に追加
`FLT_SNAN`	`float`型のシグナルNaN	C++26
`DBL_SNAN`	`double`型のシグナルNaN	C++26
`LDBL_SNAN`	`long double`型のシグナルNaN	C++26

バージョン情報

マクロ	説明	対応バージョン
`__STDC_VERSION_FLOAT_H__`	`<cfloat>`が提供するC標準ライブラリ機能のバージョン (`202311L`)	C++26

最大値

マクロ	説明	対応バージョン
`FLT_MAX`	`float`の最大の有限値。上記モデルでは、$(1-b^{-p})b^{e_{\rm max}}$
`DBL_MAX`	`double`の最大の有限値。上記モデルでは、$(1-b^{-p})b^{e_{\rm max}}$
`LDBL_MAX`	`long double`の最大の有限値。上記モデルでは、$(1-b^{-p})b^{e_{\rm max}}$
`FLT_MAX_10_EXP`	$10$ の $n$ 乗が、`float`の有限の値として表現可能であるような、最大の整数値 $n$。上記モデルでは、$\lfloor\log_{10} ((1-b^{-p})b^{e_{\rm max}})\rfloor$
`DBL_MAX_10_EXP`	$10$ の $n$ 乗が、`double`の有限の値として表現可能であるような、最大の整数値 $n$。上記モデルでは、$\lfloor\log_{10} ((1-b^{-p})b^{e_{\rm max}})\rfloor$
`LDBL_MAX_10_EXP`	$10$ の $n$ 乗が、`long double`の有限の値として表現可能であるような、最大の整数値 $n$。上記モデルでは、$\lfloor\log_{10} ((1-b^{-p})b^{e_{\rm max}})\rfloor$
`FLT_MAX_EXP`	`FLT_RADIX` の $n - 1$ 乗が、`float`の有限の値として表現可能であるような、最大の整数値 $n$。上記モデルでは、$e_{\rm max}$
`DBL_MAX_EXP`	`FLT_RADIX` の $n - 1$ 乗が、`double`の有限の値として表現可能であるような、最大の整数値 $n$。上記モデルでは、$e_{\rm max}$
`LDBL_MAX_EXP`	`FLT_RADIX` の $n - 1$ 乗が、`long double`の有限の値として表現可能であるような、最大の整数値 $n$。上記モデルでは、$e_{\rm max}$

最小値

マクロ	説明	対応バージョン
`FLT_MIN`	`float`の正の正規化数のうち最小のもの。上記モデルでは、$b^{e_{\rm min} - 1}$
`DBL_MIN`	`double`の正の正規化数のうち最小のもの。上記モデルでは、$b^{e_{\rm min} - 1}$
`LDBL_MIN`	`long double`の正の正規化数のうち最小のもの。上記モデルでは、$b^{e_{\rm min} - 1}$
`FLT_TRUE_MIN`	`float`の正の最小値	C++17
`DBL_TRUE_MIN`	`double`の正の最小値	C++17
`LDBL_TRUE_MIN`	`long double`の正の最小値	C++17
`FLT_MIN_10_EXP`	$10$ の $n$ 乗が`float`の正の正規化数であるような最小の負の整数値 $n$。上記モデルでは、$\lceil\log_{10} b^{e_{\rm min} - 1}\rceil$
`DBL_MIN_10_EXP`	$10$ の $n$ 乗が`double`の正の正規化数であるような最小の負の整数値 $n$。上記モデルでは、$\lceil\log_{10} b^{e_{\rm min} - 1}\rceil$
`LDBL_MIN_10_EXP`	$10$ の $n$ 乗が`long double`の正の正規化数であるような最小の負の整数値 $n$。上記モデルでは、$\lceil\log_{10} b^{e_{\rm min} - 1}\rceil$
`FLT_MIN_EXP`	`FLT_RADIX` の $n - 1$ 乗が`float`の正規化数として表現可能な最小の負の整数値 $n$。上記モデルでは、$e_{\rm min}$
`DBL_MIN_EXP`	`FLT_RADIX` の $n - 1$ 乗が`double`の正規化数として表現可能な最小の負の整数値 $n$。上記モデルでは、$e_{\rm min}$
`LDBL_MIN_EXP`	`FLT_RADIX` の $n - 1$ 乗が`long double`の正規化数として表現可能な最小の負の整数値 $n$。上記モデルでは、$e_{\rm min}$

参照

P0063R3 C++17 should refer to C11 instead of C99
P0175R1 Synopses for the C library
P3348R4 C++26 should refer to C23 not C17
- C++26がC23を参照するようになり、INFINITY・NAN・FLT_SNAN・DBL_SNAN・LDBL_SNAN・__STDC_VERSION_FLOAT_H__が追加された。DECIMAL_DIGが非推奨となり、FLT_HAS_SUBNORM・DBL_HAS_SUBNORM・LDBL_HAS_SUBNORMが廃止予定 (obsolescent) となった

DBL_HAS_SUBNORM -- C++26対応として、C23標準ライブラリを追加 (#1657)

2026-06-08T20:56:08+09:00

diff --git a/reference/cfloat/dbl_has_subnorm.md b/reference/cfloat/dbl_has_subnorm.md
index 5f6b13c26..90038be2e 100644
--- a/reference/cfloat/dbl_has_subnorm.md
+++ b/reference/cfloat/dbl_has_subnorm.md
@@ -2,11 +2,15 @@
 * cfloat[meta header]
 * macro[meta id-type]
 * cpp17[meta cpp]
+* cpp26deprecated[meta cpp]
 
 ```cpp
 #define DBL_HAS_SUBNORM implementation-defined
 ```
 
+このマクロは、C++26で廃止予定 (obsolescent) となった。
+
+
 ## 概要
 `DBL_HAS_SUBNORM` は、`double`型における非正規化数のサポート状況を表すマクロである。
 
@@ -27,6 +31,15 @@
 - このマクロは、非正規化数を表現できる場合の、浮動小数点数の正の最小値を表す[`DBL_TRUE_MIN`](dbl_true_min.md)のために定義された
 
 
+## 非推奨・削除の詳細
+このマクロはコンパイル時定数として非正規化数のサポート状況を取得するものであったが、これは必ずしもコンパイル時に確定する値ではなく、有用でないため廃止予定 (obsolescent) となった：
+
+- ハードウェアによっては非正規化数をソフトウェアエミュレーションでサポートする場合があり、サポート状況が判定できず`-1` (indeterminable) となることがある
+- ハードウェアサポートがある場合でも、実行時のフラグ切り替えによって非正規化数をゼロにフラッシュ (flush-to-zero) するよう設定できるため、サポート状況がコンパイル時に確定しない場合がある
+
+C++23では、対応する[`std::numeric_limits`](/reference/limits/numeric_limits.md)`<double>::`[`has_denorm`](/reference/limits/numeric_limits/has_denorm.md)が同じ理由ですでに非推奨となっている。
+
+
 ## 例
 ```cpp example
 #include <iostream>
@@ -64,3 +77,5 @@ int main()
 - [WG14/N1378 `xxx_TRUE_MIN` macros for `<float.h>`](http://www.open-std.org/jtc1/sc22/wg14/www/docs/n1378.htm)
 - [P0063R3 C++17 should refer to C11 instead of C99](http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0063r3.html)
 - [P0175R1 Synopses for the C library](http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0175r1.html)
+- [P3348R4 C++26 should refer to C23 not C17](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3348r4.html)
+    - C++26がC23を参照するようになり、このマクロが廃止予定 (obsolescent) となった

DBL_SNAN -- C++26対応として、C23標準ライブラリを追加 (#1657)

2026-06-08T20:56:08+09:00

diff --git a/reference/cfloat/dbl_snan.md b/reference/cfloat/dbl_snan.md
new file mode 100644
index 000000000..bc59c1267
--- /dev/null
+++ b/reference/cfloat/dbl_snan.md
@@ -0,0 +1,61 @@
+# DBL_SNAN
+* cfloat[meta header]
+* macro[meta id-type]
+* cpp26[meta cpp]
+
+```cpp
+#define DBL_SNAN see below
+```
+
+## 概要
+`double`型のシグナルNaN (signaling NaN) を表す定数式マクロ。
+
+[`std::numeric_limits`](/reference/limits/numeric_limits.md)`<double>::`[`signaling_NaN`](/reference/limits/numeric_limits/signaling_nan.md)`()`と等しい。
+
+C23で`<float.h>`に追加されたマクロであり、C++26で`<cfloat>`に取り込まれた。
+
+
+## 備考
+- シグナルNaNがサポートされない場合、このマクロは定義されない
+
+
+## 例
+```cpp example
+#include <iostream>
+#include <cfloat>
+#include <cmath>
+
+int main()
+{
+  double x = DBL_SNAN;
+  std::cout << std::boolalpha << std::isnan(x) << std::endl;
+}
+```
+* DBL_SNAN[color ff0000]
+* std::isnan[link /reference/cmath/isnan.md]
+
+### 出力
+```
+true
+```
+
+
+## バージョン
+### 言語
+- C++26
+
+### 処理系
+- [Clang](/implementation.md#clang): 22 [mark noimpl]
+- [GCC](/implementation.md#gcc): 16.1 [mark noimpl]
+- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl]
+
+
+## 関連項目
+- [`FLT_SNAN`](flt_snan.md): `float`型のシグナルNaN
+- [`LDBL_SNAN`](ldbl_snan.md): `long double`型のシグナルNaN
+- [`NAN`](/reference/cmath/nan.md): `float`型のquiet NaN
+
+
+## 参照
+- [P3348R4 C++26 should refer to C23 not C17](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3348r4.html)
+    - C++26がC23を参照するようになり、このマクロが`<cfloat>`に追加された

DECIMAL_DIG -- C++26対応として、C23標準ライブラリを追加 (#1657)

2026-06-08T20:56:08+09:00

diff --git a/reference/cfloat/decimal_dig.md b/reference/cfloat/decimal_dig.md
index ab376685f..b9af3ed43 100644
--- a/reference/cfloat/decimal_dig.md
+++ b/reference/cfloat/decimal_dig.md
@@ -2,12 +2,16 @@
 * cfloat[meta header]
 * macro[meta id-type]
 * cpp11[meta cpp]
+* cpp26deprecated[meta cpp]
 * [mathjax enable]
 
 ```cpp
 #define DECIMAL_DIG implementation-defined
 ```
 
+このマクロは、C++26で非推奨となった。型ごとの桁数を示す[`FLT_DECIMAL_DIG`](flt_decimal_dig.md)・[`DBL_DECIMAL_DIG`](dbl_decimal_dig.md)・[`LDBL_DECIMAL_DIG`](ldbl_decimal_dig.md)を使用すること。
+
+
 ## 概要
 精度が一番高い浮動小数点型の数値を10進数で正確に表すのに必要な有効数字の桁数を表すマクロ。  
 より正確には、精度が一番高い浮動小数点型のあらゆる数値を、$n$ 桁の10進数に変換し、また元に戻した場合に値が変わらないような最小の整数値 $n$ を表すマクロ。  
@@ -37,6 +41,16 @@ $b$ や $p$ については [`<cfloat>`](../cfloat.md) のモデルも参照。
     - [`LDBL_DECIMAL_DIG`](ldbl_decimal_dig.md)
 
 
+## 非推奨・削除の詳細
+C言語側で対応するマクロが非推奨となったため、C++側でも非推奨とする。
+
+このマクロは、精度が一番高い浮動小数点型のみを対象とする値であり、実質的に[`LDBL_DECIMAL_DIG`](ldbl_decimal_dig.md)と同じものであった。型ごとに必要な桁数は異なるため、すべての浮動小数点型に対して単一の値を使用するこのマクロよりも、型ごとの桁数を表す以下のマクロを使用するほうが正確である：
+
+- [`FLT_DECIMAL_DIG`](flt_decimal_dig.md) (`float`用)
+- [`DBL_DECIMAL_DIG`](dbl_decimal_dig.md) (`double`用)
+- [`LDBL_DECIMAL_DIG`](ldbl_decimal_dig.md) (`long double`用)
+
+
 ## 例
 ```cpp example
 #include <iostream>
@@ -81,3 +95,8 @@ int main()
 - [Visual C++](/implementation.md#visual_cpp): 2013 [mark verified], 2015 [mark verified]
 	- 2013は、正しく実装されていない。C++11での最低値である10と定義されている。しかし、`double`および`long double`がIEEE 754倍精度で実装されているため、少なくとも17以上でなければならない。
 	- 2015は、正しく17と定義されている。
+
+
+## 参照
+- [P3348R4 C++26 should refer to C23 not C17](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3348r4.html)
+    - C++26がC23を参照するようになり、このマクロが非推奨となった

FLT_HAS_SUBNORM -- C++26対応として、C23標準ライブラリを追加 (#1657)

2026-06-08T20:56:08+09:00

diff --git a/reference/cfloat/flt_has_subnorm.md b/reference/cfloat/flt_has_subnorm.md
index bdf471dd3..27ba310a9 100644
--- a/reference/cfloat/flt_has_subnorm.md
+++ b/reference/cfloat/flt_has_subnorm.md
@@ -2,11 +2,15 @@
 * cfloat[meta header]
 * macro[meta id-type]
 * cpp17[meta cpp]
+* cpp26deprecated[meta cpp]
 
 ```cpp
 #define FLT_HAS_SUBNORM implementation-defined
 ```
 
+このマクロは、C++26で廃止予定 (obsolescent) となった。
+
+
 ## 概要
 `FLT_HAS_SUBNORM` は、`float`型における非正規化数のサポート状況を表すマクロである。
 
@@ -27,6 +31,15 @@
 - このマクロは、非正規化数を表現できる場合の、浮動小数点数の正の最小値を表す[`FLT_TRUE_MIN`](flt_true_min.md)のために定義された
 
 
+## 非推奨・削除の詳細
+このマクロはコンパイル時定数として非正規化数のサポート状況を取得するものであったが、これは必ずしもコンパイル時に確定する値ではなく、有用でないため廃止予定 (obsolescent) となった：
+
+- ハードウェアによっては非正規化数をソフトウェアエミュレーションでサポートする場合があり、サポート状況が判定できず`-1` (indeterminable) となることがある
+- ハードウェアサポートがある場合でも、実行時のフラグ切り替えによって非正規化数をゼロにフラッシュ (flush-to-zero) するよう設定できるため、サポート状況がコンパイル時に確定しない場合がある
+
+C++23では、対応する[`std::numeric_limits`](/reference/limits/numeric_limits.md)`<float>::`[`has_denorm`](/reference/limits/numeric_limits/has_denorm.md)が同じ理由ですでに非推奨となっている。
+
+
 ## 例
 ```cpp example
 #include <iostream>
@@ -64,3 +77,5 @@ int main()
 - [WG14/N1378 `xxx_TRUE_MIN` macros for `<float.h>`](http://www.open-std.org/jtc1/sc22/wg14/www/docs/n1378.htm)
 - [P0063R3 C++17 should refer to C11 instead of C99](http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0063r3.html)
 - [P0175R1 Synopses for the C library](http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0175r1.html)
+- [P3348R4 C++26 should refer to C23 not C17](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3348r4.html)
+    - C++26がC23を参照するようになり、このマクロが廃止予定 (obsolescent) となった

FLT_SNAN -- C++26対応として、C23標準ライブラリを追加 (#1657)

2026-06-08T20:56:08+09:00

diff --git a/reference/cfloat/flt_snan.md b/reference/cfloat/flt_snan.md
new file mode 100644
index 000000000..fb10a1589
--- /dev/null
+++ b/reference/cfloat/flt_snan.md
@@ -0,0 +1,61 @@
+# FLT_SNAN
+* cfloat[meta header]
+* macro[meta id-type]
+* cpp26[meta cpp]
+
+```cpp
+#define FLT_SNAN see below
+```
+
+## 概要
+`float`型のシグナルNaN (signaling NaN) を表す定数式マクロ。
+
+[`std::numeric_limits`](/reference/limits/numeric_limits.md)`<float>::`[`signaling_NaN`](/reference/limits/numeric_limits/signaling_nan.md)`()`と等しい。
+
+C23で`<float.h>`に追加されたマクロであり、C++26で`<cfloat>`に取り込まれた。
+
+
+## 備考
+- シグナルNaNがサポートされない場合、このマクロは定義されない
+
+
+## 例
+```cpp example
+#include <iostream>
+#include <cfloat>
+#include <cmath>
+
+int main()
+{
+  float x = FLT_SNAN;
+  std::cout << std::boolalpha << std::isnan(x) << std::endl;
+}
+```
+* FLT_SNAN[color ff0000]
+* std::isnan[link /reference/cmath/isnan.md]
+
+### 出力
+```
+true
+```
+
+
+## バージョン
+### 言語
+- C++26
+
+### 処理系
+- [Clang](/implementation.md#clang): 22 [mark noimpl]
+- [GCC](/implementation.md#gcc): 16.1 [mark noimpl]
+- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl]
+
+
+## 関連項目
+- [`DBL_SNAN`](dbl_snan.md): `double`型のシグナルNaN
+- [`LDBL_SNAN`](ldbl_snan.md): `long double`型のシグナルNaN
+- [`NAN`](/reference/cmath/nan.md): `float`型のquiet NaN
+
+
+## 参照
+- [P3348R4 C++26 should refer to C23 not C17](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3348r4.html)
+    - C++26がC23を参照するようになり、このマクロが`<cfloat>`に追加された

LDBL_HAS_SUBNORM -- C++26対応として、C23標準ライブラリを追加 (#1657)

2026-06-08T20:56:08+09:00

diff --git a/reference/cfloat/ldbl_has_subnorm.md b/reference/cfloat/ldbl_has_subnorm.md
index f837b0694..c71f9de5d 100644
--- a/reference/cfloat/ldbl_has_subnorm.md
+++ b/reference/cfloat/ldbl_has_subnorm.md
@@ -2,11 +2,15 @@
 * cfloat[meta header]
 * macro[meta id-type]
 * cpp17[meta cpp]
+* cpp26deprecated[meta cpp]
 
 ```cpp
 #define LDBL_HAS_SUBNORM implementation-defined
 ```
 
+このマクロは、C++26で廃止予定 (obsolescent) となった。
+
+
 ## 概要
 `LDBL_HAS_SUBNORM` は、`long double`型における非正規化数のサポート状況を表すマクロである。
 
@@ -27,6 +31,15 @@
 - このマクロは、非正規化数を表現できる場合の、浮動小数点数の正の最小値を表す[`LDBL_TRUE_MIN`](ldbl_true_min.md)のために定義された
 
 
+## 非推奨・削除の詳細
+このマクロはコンパイル時定数として非正規化数のサポート状況を取得するものであったが、これは必ずしもコンパイル時に確定する値ではなく、有用でないため廃止予定 (obsolescent) となった：
+
+- ハードウェアによっては非正規化数をソフトウェアエミュレーションでサポートする場合があり、サポート状況が判定できず`-1` (indeterminable) となることがある
+- ハードウェアサポートがある場合でも、実行時のフラグ切り替えによって非正規化数をゼロにフラッシュ (flush-to-zero) するよう設定できるため、サポート状況がコンパイル時に確定しない場合がある
+
+C++23では、対応する[`std::numeric_limits`](/reference/limits/numeric_limits.md)`<long double>::`[`has_denorm`](/reference/limits/numeric_limits/has_denorm.md)が同じ理由ですでに非推奨となっている。
+
+
 ## 例
 ```cpp example
 #include <iostream>
@@ -64,3 +77,5 @@ int main()
 - [WG14/N1378 `xxx_TRUE_MIN` macros for `<float.h>`](http://www.open-std.org/jtc1/sc22/wg14/www/docs/n1378.htm)
 - [P0063R3 C++17 should refer to C11 instead of C99](http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0063r3.html)
 - [P0175R1 Synopses for the C library](http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0175r1.html)
+- [P3348R4 C++26 should refer to C23 not C17](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3348r4.html)
+    - C++26がC23を参照するようになり、このマクロが廃止予定 (obsolescent) となった

LDBL_SNAN -- C++26対応として、C23標準ライブラリを追加 (#1657)

2026-06-08T20:56:08+09:00

diff --git a/reference/cfloat/ldbl_snan.md b/reference/cfloat/ldbl_snan.md
new file mode 100644
index 000000000..0fbddf481
--- /dev/null
+++ b/reference/cfloat/ldbl_snan.md
@@ -0,0 +1,61 @@
+# LDBL_SNAN
+* cfloat[meta header]
+* macro[meta id-type]
+* cpp26[meta cpp]
+
+```cpp
+#define LDBL_SNAN see below
+```
+
+## 概要
+`long double`型のシグナルNaN (signaling NaN) を表す定数式マクロ。
+
+[`std::numeric_limits`](/reference/limits/numeric_limits.md)`<long double>::`[`signaling_NaN`](/reference/limits/numeric_limits/signaling_nan.md)`()`と等しい。
+
+C23で`<float.h>`に追加されたマクロであり、C++26で`<cfloat>`に取り込まれた。
+
+
+## 備考
+- シグナルNaNがサポートされない場合、このマクロは定義されない
+
+
+## 例
+```cpp example
+#include <iostream>
+#include <cfloat>
+#include <cmath>
+
+int main()
+{
+  long double x = LDBL_SNAN;
+  std::cout << std::boolalpha << std::isnan(x) << std::endl;
+}
+```
+* LDBL_SNAN[color ff0000]
+* std::isnan[link /reference/cmath/isnan.md]
+
+### 出力
+```
+true
+```
+
+
+## バージョン
+### 言語
+- C++26
+
+### 処理系
+- [Clang](/implementation.md#clang): 22 [mark noimpl]
+- [GCC](/implementation.md#gcc): 16.1 [mark noimpl]
+- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl]
+
+
+## 関連項目
+- [`FLT_SNAN`](flt_snan.md): `float`型のシグナルNaN
+- [`DBL_SNAN`](dbl_snan.md): `double`型のシグナルNaN
+- [`NAN`](/reference/cmath/nan.md): `float`型のquiet NaN
+
+
+## 参照
+- [P3348R4 C++26 should refer to C23 not C17](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3348r4.html)
+    - C++26がC23を参照するようになり、このマクロが`<cfloat>`に追加された

system_clock -- C++26対応として、C23標準ライブラリを追加 (#1657)

2026-06-08T20:56:08+09:00

diff --git a/reference/chrono/system_clock.md b/reference/chrono/system_clock.md
index ec323b9c0..678c68e3b 100644
--- a/reference/chrono/system_clock.md
+++ b/reference/chrono/system_clock.md
@@ -93,7 +93,7 @@ int main()
 * now()[link system_clock/now.md]
 * to_time_t[link system_clock/to_time_t.md]
 * std::time_t[link /reference/ctime/time_t.md]
-* std::ctime[link /reference/ctime/ctime.md.nolink]
+* std::ctime[link /reference/ctime/ctime.md]
 
 ### 出力例
 ```

from_time_t -- C++26対応として、C23標準ライブラリを追加 (#1657)

2026-06-08T20:56:08+09:00

diff --git a/reference/chrono/system_clock/from_time_t.md b/reference/chrono/system_clock/from_time_t.md
index 9eba06e09..c745e871a 100644
--- a/reference/chrono/system_clock/from_time_t.md
+++ b/reference/chrono/system_clock/from_time_t.md
@@ -48,7 +48,7 @@ int main()
 * to_time_t[link to_time_t.md]
 * std::time_t[link /reference/ctime/time_t.md]
 * std::time[link /reference/ctime/time.md.nolink]
-* std::ctime[link /reference/ctime/ctime.md.nolink]
+* std::ctime[link /reference/ctime/ctime.md]
 
 ### 出力例
 ```

now -- C++26対応として、C23標準ライブラリを追加 (#1657)

2026-06-08T20:56:08+09:00

diff --git a/reference/chrono/system_clock/now.md b/reference/chrono/system_clock/now.md
index fa896060d..5645fe134 100644
--- a/reference/chrono/system_clock/now.md
+++ b/reference/chrono/system_clock/now.md
@@ -41,7 +41,7 @@ int main()
 * system_clock::now()[color ff0000]
 * to_time_t[link to_time_t.md]
 * std::time_t[link /reference/ctime/time_t.md]
-* std::ctime[link /reference/ctime/ctime.md.nolink]
+* std::ctime[link /reference/ctime/ctime.md]
 
 ### 出力例
 ```

to_time_t -- C++26対応として、C23標準ライブラリを追加 (#1657)

2026-06-08T20:56:08+09:00

diff --git a/reference/chrono/system_clock/to_time_t.md b/reference/chrono/system_clock/to_time_t.md
index e8714711f..f2f0968cb 100644
--- a/reference/chrono/system_clock/to_time_t.md
+++ b/reference/chrono/system_clock/to_time_t.md
@@ -44,7 +44,7 @@ int main()
 * system_clock::to_time_t(p)[color ff0000]
 * now()[link now.md]
 * std::time_t[link /reference/ctime/time_t.md]
-* std::ctime[link /reference/ctime/ctime.md.nolink]
+* std::ctime[link /reference/ctime/ctime.md]
 
 ### 出力例
 ```

cinttypes -- C++26対応として、C23標準ライブラリを追加 (#1657)

2026-06-08T20:56:08+09:00

cinttypes(C++11)

<cinttypes>ヘッダでは、<cstdint>の固定幅整数型を<cstdio>のprintf系・scanf系関数で入出力するための書式指定マクロと、最大幅整数型に対する数値変換関数を提供する。これらの機能は、std名前空間に属することを除いてC言語の標準ライブラリ<inttypes.h>ヘッダと同じである。

このヘッダは<cstdint>をインクルードする。

型

名前	説明	対応バージョン
`imaxdiv_t`	`imaxdiv`関数の戻り値型	C++11

関数

名前	説明	対応バージョン
`imaxabs`	`intmax_t`の絶対値を取得する	C++11
`imaxdiv`	`intmax_t`の除算と剰余算を行う	C++11
`strtoimax`	文字列を`intmax_t`に変換する	C++11
`strtoumax`	文字列を`uintmax_t`に変換する	C++11
`wcstoimax`	ワイド文字列を`intmax_t`に変換する	C++11
`wcstoumax`	ワイド文字列を`uintmax_t`に変換する	C++11
`abs`	`intmax_t`の絶対値を取得する (`imaxabs`のオーバーロード、処理系定義)	C++11
`div`	`intmax_t`の除算と剰余算を行う (`imaxdiv`のオーバーロード、処理系定義)	C++11

出力用の書式指定マクロ

printf系関数で固定幅整数型を出力するための変換指定子を表すマクロ。PRIに続けて変換 (d/i/o/u/x/X/b/B) と型の種別を組み合わせる。

名前	説明	対応バージョン
`PRId`N, `PRIi`N, `PRIo`N, `PRIu`N, `PRIx`N, `PRIX`N	`intN_t` / `uintN_t`用	C++11
`PRIb`N, `PRIB`N	`intN_t` / `uintN_t`用 (2進数)	C++26
`PRIdLEAST`N 等, `PRIdFAST`N 等	`int_leastN_t` / `int_fastN_t`系用 (2進数の`b`/`B`はC++26)	C++11
`PRIdMAX` 等, `PRIdPTR` 等	`intmax_t` / `intptr_t`系用 (2進数の`b`/`B`はC++26)	C++11

入力用の書式指定マクロ

scanf系関数で固定幅整数型を入力するための変換指定子を表すマクロ。SCNに続けて変換 (d/i/o/u/x/b) と型の種別を組み合わせる。

名前	説明	対応バージョン
`SCNd`N, `SCNi`N, `SCNo`N, `SCNu`N, `SCNx`N	`intN_t` / `uintN_t`用	C++11
`SCNb`N	`intN_t` / `uintN_t`用 (2進数)	C++26
`SCNdLEAST`N 等, `SCNdFAST`N 等	`int_leastN_t` / `int_fastN_t`系用 (2進数の`b`はC++26)	C++11
`SCNdMAX` 等, `SCNdPTR` 等	`intmax_t` / `intptr_t`系用 (2進数の`b`はC++26)	C++11

バージョン情報マクロ

名前	説明	対応バージョン
`__STDC_VERSION_INTTYPES_H__`	`<cinttypes>`が提供するC標準ライブラリ機能のバージョン (`202311L`)	C++26

バージョン

言語

C++11

参照

N1568 Proposed additions to TR-1 to improve compatibility with C99
P3348R4 C++26 should refer to C23 not C17
- C++26がC23を参照するようになり、2進数用の書式指定マクロ (PRIbN・PRIBN・SCNbN等) と__STDC_VERSION_INTTYPES_H__が追加された

PRIbN, PRIBN -- C++26対応として、C23標準ライブラリを追加 (#1657)

2026-06-08T20:56:08+09:00

diff --git a/reference/cinttypes/prib.md b/reference/cinttypes/prib.md
new file mode 100644
index 000000000..f597f1802
--- /dev/null
+++ b/reference/cinttypes/prib.md
@@ -0,0 +1,76 @@
+# PRIbN, PRIBN
+* cinttypes[meta header]
+* macro[meta id-type]
+* cpp26[meta cpp]
+
+```cpp
+// N はビット幅 (8, 16, 32, 64 など)
+#define PRIbN implementation-defined
+#define PRIBN implementation-defined
+// PRIbLEASTN / PRIbFASTN / PRIbMAX / PRIbPTR とその大文字版も同様
+```
+
+## 概要
+[`<cstdint>`](/reference/cstdint.md)の固定幅整数型を、[`std::printf`](/reference/cstdio/printf.md)系関数で**2進数**として出力するための変換指定子を表すマクロ。`"%" PRIb16` のように文字列リテラルと連結して書式文字列を構成する。
+
+- `PRIb`*N* : `0b`プレフィックス (`#`フラグ使用時) の小文字形式
+- `PRIB`*N* : `0B`プレフィックス (`#`フラグ使用時) の大文字形式
+
+C23で`<inttypes.h>`に追加されたマクロであり、C++26で`<cinttypes>`に取り込まれた。
+
+対象とする整数型に応じて、以下のマクロが定義される (*N*は`8`/`16`/`32`/`64`などのビット幅)。
+
+| マクロ | 対象の型 |
+|--------|----------|
+| `PRIb`*N*, `PRIB`*N*             | `int`*N*`_t` / `uint`*N*`_t` |
+| `PRIbLEAST`*N*, `PRIBLEAST`*N*   | `int_least`*N*`_t` / `uint_least`*N*`_t` |
+| `PRIbFAST`*N*, `PRIBFAST`*N*     | `int_fast`*N*`_t` / `uint_fast`*N*`_t` |
+| `PRIbMAX`, `PRIBMAX`             | `intmax_t` / `uintmax_t` |
+| `PRIbPTR`, `PRIBPTR`             | `intptr_t` / `uintptr_t` |
+
+
+## 例
+```cpp example
+#include <cinttypes>
+#include <cstdint>
+#include <cstdio>
+
+int main()
+{
+  std::uint16_t x = 10;
+
+  // 小文字版: 0b プレフィックス
+  std::printf("%#" PRIb16 "\n", x);
+
+  // 大文字版: 0B プレフィックス
+  std::printf("%#" PRIB16 "\n", x);
+}
+```
+* PRIb16[color ff0000]
+* PRIB16[color ff0000]
+* std::printf[link /reference/cstdio/printf.md]
+
+### 出力
+```
+0b1010
+0B1010
+```
+
+
+## バージョン
+### 言語
+- C++26
+
+### 処理系
+- [Clang](/implementation.md#clang): 22 [mark noimpl]
+- [GCC](/implementation.md#gcc): 16.1 [mark noimpl]
+- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl]
+
+
+## 関連項目
+- [`SCNbN`](scnb.md): 固定幅整数型を2進数として入力するための変換指定子
+
+
+## 参照
+- [P3348R4 C++26 should refer to C23 not C17](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3348r4.html)
+    - C++26がC23を参照するようになり、これらのマクロが`<cinttypes>`に追加された

SCNbN -- C++26対応として、C23標準ライブラリを追加 (#1657)

2026-06-08T20:56:08+09:00

diff --git a/reference/cinttypes/scnb.md b/reference/cinttypes/scnb.md
new file mode 100644
index 000000000..d568dbef7
--- /dev/null
+++ b/reference/cinttypes/scnb.md
@@ -0,0 +1,66 @@
+# SCNbN
+* cinttypes[meta header]
+* macro[meta id-type]
+* cpp26[meta cpp]
+
+```cpp
+// N はビット幅 (8, 16, 32, 64 など)
+#define SCNbN implementation-defined
+```
+
+## 概要
+[`<cstdint>`](/reference/cstdint.md)の固定幅整数型を、[`std::scanf`](/reference/cstdio/scanf.md)系関数で**2進数**として入力するための変換指定子を表すマクロ。`"%" SCNb16` のように文字列リテラルと連結して書式文字列を構成する。
+
+C23で`<inttypes.h>`に追加されたマクロであり、C++26で`<cinttypes>`に取り込まれた。
+
+対象とする整数型に応じて、以下のマクロが定義される (*N*は`8`/`16`/`32`/`64`などのビット幅)。
+
+| マクロ | 対象の型 |
+|--------|----------|
+| `SCNb`*N*       | `int`*N*`_t` / `uint`*N*`_t` |
+| `SCNbLEAST`*N*  | `int_least`*N*`_t` / `uint_least`*N*`_t` |
+| `SCNbFAST`*N*   | `int_fast`*N*`_t` / `uint_fast`*N*`_t` |
+| `SCNbMAX`       | `intmax_t` / `uintmax_t` |
+| `SCNbPTR`       | `intptr_t` / `uintptr_t` |
+
+
+## 例
+```cpp example
+#include <cinttypes>
+#include <cstdint>
+#include <cstdio>
+
+int main()
+{
+  std::uint16_t x = 0;
+  std::sscanf("1101", "%" SCNb16, &x); // "1101"を2進数として解釈する
+  std::printf("%d\n", x);
+}
+```
+* SCNb16[color ff0000]
+* std::sscanf[link /reference/cstdio/sscanf.md.nolink]
+* std::printf[link /reference/cstdio/printf.md]
+
+### 出力
+```
+13
+```
+
+
+## バージョン
+### 言語
+- C++26
+
+### 処理系
+- [Clang](/implementation.md#clang): 22 [mark noimpl]
+- [GCC](/implementation.md#gcc): 16.1 [mark noimpl]
+- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl]
+
+
+## 関連項目
+- [`PRIbN`, `PRIBN`](prib.md): 固定幅整数型を2進数として出力するための変換指定子
+
+
+## 参照
+- [P3348R4 C++26 should refer to C23 not C17](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3348r4.html)
+    - C++26がC23を参照するようになり、これらのマクロが`<cinttypes>`に追加された

climits -- C++26対応として、C23標準ライブラリを追加 (#1657)

2026-06-08T20:56:08+09:00

climits

<climits>ヘッダでは、整数型に関するマクロが定義されている。これは、C言語の標準ライブラリ<limits.h>と同じである。

本ヘッダはフリースタンディング環境でも提供される。

最小値

名前	説明	対応バージョン
`SCHAR_MIN`	`signed char` の最小値
`CHAR_MIN`	`char` の最小値
`SHRT_MIN`	`short` の最小値
`INT_MIN`	`int` の最小値
`LONG_MIN`	`long` の最小値
`LLONG_MIN`	`long long` の最小値	C++11

最大値

名前	説明	対応バージョン
`UCHAR_MAX`	`unsigned char` の最大値
`SCHAR_MAX`	`signed char` の最大値
`CHAR_MAX`	`char` の最大値
`USHRT_MAX`	`unsigned short` の最大値
`SHRT_MAX`	`short` の最大値
`UINT_MAX`	`unsigned` の最大値
`INT_MAX`	`int` の最大値
`ULONG_MAX`	`unsigned long` の最大値
`LONG_MAX`	`long` の最大値
`ULLONG_MAX`	`unsigned long long` の最大値	C++11
`LLONG_MAX`	`long long` の最大値	C++11

幅

名前	説明	対応バージョン
`BOOL_WIDTH`	`bool` の幅 (値ビット数)	C++26
`CHAR_WIDTH`	`char` の幅 (値ビット数)	C++26
`SCHAR_WIDTH`	`signed char` の幅 (値ビット数)	C++26
`UCHAR_WIDTH`	`unsigned char` の幅 (値ビット数)	C++26
`SHRT_WIDTH`	`short` の幅 (値ビット数)	C++26
`USHRT_WIDTH`	`unsigned short` の幅 (値ビット数)	C++26
`INT_WIDTH`	`int` の幅 (値ビット数)	C++26
`UINT_WIDTH`	`unsigned int` の幅 (値ビット数)	C++26
`LONG_WIDTH`	`long` の幅 (値ビット数)	C++26
`ULONG_WIDTH`	`unsigned long` の幅 (値ビット数)	C++26
`LLONG_WIDTH`	`long long` の幅 (値ビット数)	C++26
`ULLONG_WIDTH`	`unsigned long long` の幅 (値ビット数)	C++26

その他

名前	説明	対応バージョン
`CHAR_BIT`	1バイトのビット数
`MB_LEN_MAX`	マルチバイト文字のバイト数

なお、ビット精度整数型の最大幅を表すBITINT_MAXWIDTHは、C++では定義されない。

参照

P3348R4 C++26 should refer to C23 not C17
- C++26がC23を参照するようになり、各整数型の幅を表すマクロが追加された

BOOL_WIDTH -- C++26対応として、C23標準ライブラリを追加 (#1657)

2026-06-08T20:56:08+09:00

diff --git a/reference/climits/bool_width.md b/reference/climits/bool_width.md
new file mode 100644
index 000000000..9b807bd9b
--- /dev/null
+++ b/reference/climits/bool_width.md
@@ -0,0 +1,48 @@
+# BOOL_WIDTH
+* climits[meta header]
+* macro[meta id-type]
+* cpp26[meta cpp]
+
+```cpp
+#define BOOL_WIDTH 1
+```
+
+## 概要
+`bool`型の幅 (値ビット数) を表す。`#if`などのプリプロセッサディレクティブで使用できる。
+
+`bool`型は値として`0`と`1`のみを持つため値ビットは1個であり、このマクロの値は規格によって正確に`1`と定められている (ストレージサイズである`sizeof(bool) * `[`CHAR_BIT`](char_bit.md)とは異なる)。
+
+C23で`<limits.h>`に追加されたマクロであり、C++26で`<climits>`に取り込まれた。
+
+
+## 例
+```cpp example
+#include <climits>
+#include <iostream>
+
+int main()
+{
+  std::cout << BOOL_WIDTH << '\n';
+}
+```
+* BOOL_WIDTH[color ff0000]
+
+### 出力
+```
+1
+```
+
+
+## バージョン
+### 言語
+- C++26
+
+### 処理系
+- [Clang](/implementation.md#clang): 23 [mark verified]
+- [GCC](/implementation.md#gcc): 17 [mark verified]
+- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl]
+
+
+## 参照
+- [P3348R4 C++26 should refer to C23 not C17](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3348r4.html)
+    - C++26がC23を参照するようになり、このマクロが`<climits>`に追加された

CHAR_WIDTH -- C++26対応として、C23標準ライブラリを追加 (#1657)

2026-06-08T20:56:08+09:00

diff --git a/reference/climits/char_width.md b/reference/climits/char_width.md
new file mode 100644
index 000000000..c0da81603
--- /dev/null
+++ b/reference/climits/char_width.md
@@ -0,0 +1,48 @@
+# CHAR_WIDTH
+* climits[meta header]
+* macro[meta id-type]
+* cpp26[meta cpp]
+
+```cpp
+#define CHAR_WIDTH implementation-defined
+```
+
+## 概要
+`char`型の幅 (値ビット数) を表す。[`CHAR_BIT`](char_bit.md)と等しい。`#if`などのプリプロセッサディレクティブで使用できる。
+
+幅 (width) とは、その型が値の表現に使用するビット数であり、符号付き整数型では符号ビットを含む。パディングビットを含むストレージサイズ (`sizeof` × [`CHAR_BIT`](/reference/climits/char_bit.md)) とは異なる場合がある。
+
+C23で`<limits.h>`に追加されたマクロであり、C++26で`<climits>`に取り込まれた。
+
+
+## 例
+```cpp example
+#include <climits>
+#include <iostream>
+
+int main()
+{
+  std::cout << CHAR_WIDTH << '\n';
+}
+```
+* CHAR_WIDTH[color ff0000]
+
+### 出力例
+```
+8
+```
+
+
+## バージョン
+### 言語
+- C++26
+
+### 処理系
+- [Clang](/implementation.md#clang): 23 [mark verified]
+- [GCC](/implementation.md#gcc): 17 [mark verified]
+- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl]
+
+
+## 参照
+- [P3348R4 C++26 should refer to C23 not C17](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3348r4.html)
+    - C++26がC23を参照するようになり、このマクロが`<climits>`に追加された

INT_WIDTH -- C++26対応として、C23標準ライブラリを追加 (#1657)

2026-06-08T20:56:08+09:00

diff --git a/reference/climits/int_width.md b/reference/climits/int_width.md
new file mode 100644
index 000000000..fb1097431
--- /dev/null
+++ b/reference/climits/int_width.md
@@ -0,0 +1,48 @@
+# INT_WIDTH
+* climits[meta header]
+* macro[meta id-type]
+* cpp26[meta cpp]
+
+```cpp
+#define INT_WIDTH implementation-defined
+```
+
+## 概要
+`int`型の幅 (値ビット数) を表す。`#if`などのプリプロセッサディレクティブで使用できる。
+
+幅 (width) とは、その型が値の表現に使用するビット数であり、符号付き整数型では符号ビットを含む。パディングビットを含むストレージサイズ (`sizeof` × [`CHAR_BIT`](/reference/climits/char_bit.md)) とは異なる場合がある。
+
+C23で`<limits.h>`に追加されたマクロであり、C++26で`<climits>`に取り込まれた。
+
+
+## 例
+```cpp example
+#include <climits>
+#include <iostream>
+
+int main()
+{
+  std::cout << INT_WIDTH << '\n';
+}
+```
+* INT_WIDTH[color ff0000]
+
+### 出力例
+```
+32
+```
+
+
+## バージョン
+### 言語
+- C++26
+
+### 処理系
+- [Clang](/implementation.md#clang): 23 [mark verified]
+- [GCC](/implementation.md#gcc): 17 [mark verified]
+- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl]
+
+
+## 参照
+- [P3348R4 C++26 should refer to C23 not C17](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3348r4.html)
+    - C++26がC23を参照するようになり、このマクロが`<climits>`に追加された

LLONG_WIDTH -- C++26対応として、C23標準ライブラリを追加 (#1657)

2026-06-08T20:56:08+09:00

diff --git a/reference/climits/llong_width.md b/reference/climits/llong_width.md
new file mode 100644
index 000000000..7341b0dbf
--- /dev/null
+++ b/reference/climits/llong_width.md
@@ -0,0 +1,48 @@
+# LLONG_WIDTH
+* climits[meta header]
+* macro[meta id-type]
+* cpp26[meta cpp]
+
+```cpp
+#define LLONG_WIDTH implementation-defined
+```
+
+## 概要
+`long long`型の幅 (値ビット数) を表す。`#if`などのプリプロセッサディレクティブで使用できる。
+
+幅 (width) とは、その型が値の表現に使用するビット数であり、符号付き整数型では符号ビットを含む。パディングビットを含むストレージサイズ (`sizeof` × [`CHAR_BIT`](/reference/climits/char_bit.md)) とは異なる場合がある。
+
+C23で`<limits.h>`に追加されたマクロであり、C++26で`<climits>`に取り込まれた。
+
+
+## 例
+```cpp example
+#include <climits>
+#include <iostream>
+
+int main()
+{
+  std::cout << LLONG_WIDTH << '\n';
+}
+```
+* LLONG_WIDTH[color ff0000]
+
+### 出力例
+```
+64
+```
+
+
+## バージョン
+### 言語
+- C++26
+
+### 処理系
+- [Clang](/implementation.md#clang): 23 [mark verified]
+- [GCC](/implementation.md#gcc): 17 [mark verified]
+- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl]
+
+
+## 参照
+- [P3348R4 C++26 should refer to C23 not C17](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3348r4.html)
+    - C++26がC23を参照するようになり、このマクロが`<climits>`に追加された

LONG_WIDTH -- C++26対応として、C23標準ライブラリを追加 (#1657)

2026-06-08T20:56:08+09:00

diff --git a/reference/climits/long_width.md b/reference/climits/long_width.md
new file mode 100644
index 000000000..19b63daf0
--- /dev/null
+++ b/reference/climits/long_width.md
@@ -0,0 +1,48 @@
+# LONG_WIDTH
+* climits[meta header]
+* macro[meta id-type]
+* cpp26[meta cpp]
+
+```cpp
+#define LONG_WIDTH implementation-defined
+```
+
+## 概要
+`long`型の幅 (値ビット数) を表す。`#if`などのプリプロセッサディレクティブで使用できる。
+
+幅 (width) とは、その型が値の表現に使用するビット数であり、符号付き整数型では符号ビットを含む。パディングビットを含むストレージサイズ (`sizeof` × [`CHAR_BIT`](/reference/climits/char_bit.md)) とは異なる場合がある。
+
+C23で`<limits.h>`に追加されたマクロであり、C++26で`<climits>`に取り込まれた。
+
+
+## 例
+```cpp example
+#include <climits>
+#include <iostream>
+
+int main()
+{
+  std::cout << LONG_WIDTH << '\n';
+}
+```
+* LONG_WIDTH[color ff0000]
+
+### 出力例
+```
+64
+```
+
+
+## バージョン
+### 言語
+- C++26
+
+### 処理系
+- [Clang](/implementation.md#clang): 23 [mark verified]
+- [GCC](/implementation.md#gcc): 17 [mark verified]
+- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl]
+
+
+## 参照
+- [P3348R4 C++26 should refer to C23 not C17](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3348r4.html)
+    - C++26がC23を参照するようになり、このマクロが`<climits>`に追加された

SCHAR_WIDTH -- C++26対応として、C23標準ライブラリを追加 (#1657)

2026-06-08T20:56:08+09:00

diff --git a/reference/climits/schar_width.md b/reference/climits/schar_width.md
new file mode 100644
index 000000000..f61d41487
--- /dev/null
+++ b/reference/climits/schar_width.md
@@ -0,0 +1,48 @@
+# SCHAR_WIDTH
+* climits[meta header]
+* macro[meta id-type]
+* cpp26[meta cpp]
+
+```cpp
+#define SCHAR_WIDTH implementation-defined
+```
+
+## 概要
+`signed char`型の幅 (値ビット数) を表す。[`CHAR_BIT`](char_bit.md)と等しい。`#if`などのプリプロセッサディレクティブで使用できる。
+
+幅 (width) とは、その型が値の表現に使用するビット数であり、符号付き整数型では符号ビットを含む。パディングビットを含むストレージサイズ (`sizeof` × [`CHAR_BIT`](/reference/climits/char_bit.md)) とは異なる場合がある。
+
+C23で`<limits.h>`に追加されたマクロであり、C++26で`<climits>`に取り込まれた。
+
+
+## 例
+```cpp example
+#include <climits>
+#include <iostream>
+
+int main()
+{
+  std::cout << SCHAR_WIDTH << '\n';
+}
+```
+* SCHAR_WIDTH[color ff0000]
+
+### 出力例
+```
+8
+```
+
+
+## バージョン
+### 言語
+- C++26
+
+### 処理系
+- [Clang](/implementation.md#clang): 23 [mark verified]
+- [GCC](/implementation.md#gcc): 17 [mark verified]
+- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl]
+
+
+## 参照
+- [P3348R4 C++26 should refer to C23 not C17](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3348r4.html)
+    - C++26がC23を参照するようになり、このマクロが`<climits>`に追加された

SHRT_WIDTH -- C++26対応として、C23標準ライブラリを追加 (#1657)

2026-06-08T20:56:08+09:00

diff --git a/reference/climits/shrt_width.md b/reference/climits/shrt_width.md
new file mode 100644
index 000000000..19810ed89
--- /dev/null
+++ b/reference/climits/shrt_width.md
@@ -0,0 +1,48 @@
+# SHRT_WIDTH
+* climits[meta header]
+* macro[meta id-type]
+* cpp26[meta cpp]
+
+```cpp
+#define SHRT_WIDTH implementation-defined
+```
+
+## 概要
+`short`型の幅 (値ビット数) を表す。`#if`などのプリプロセッサディレクティブで使用できる。
+
+幅 (width) とは、その型が値の表現に使用するビット数であり、符号付き整数型では符号ビットを含む。パディングビットを含むストレージサイズ (`sizeof` × [`CHAR_BIT`](/reference/climits/char_bit.md)) とは異なる場合がある。
+
+C23で`<limits.h>`に追加されたマクロであり、C++26で`<climits>`に取り込まれた。
+
+
+## 例
+```cpp example
+#include <climits>
+#include <iostream>
+
+int main()
+{
+  std::cout << SHRT_WIDTH << '\n';
+}
+```
+* SHRT_WIDTH[color ff0000]
+
+### 出力例
+```
+16
+```
+
+
+## バージョン
+### 言語
+- C++26
+
+### 処理系
+- [Clang](/implementation.md#clang): 23 [mark verified]
+- [GCC](/implementation.md#gcc): 17 [mark verified]
+- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl]
+
+
+## 参照
+- [P3348R4 C++26 should refer to C23 not C17](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3348r4.html)
+    - C++26がC23を参照するようになり、このマクロが`<climits>`に追加された

UCHAR_WIDTH -- C++26対応として、C23標準ライブラリを追加 (#1657)

2026-06-08T20:56:08+09:00

diff --git a/reference/climits/uchar_width.md b/reference/climits/uchar_width.md
new file mode 100644
index 000000000..88fb3a72d
--- /dev/null
+++ b/reference/climits/uchar_width.md
@@ -0,0 +1,48 @@
+# UCHAR_WIDTH
+* climits[meta header]
+* macro[meta id-type]
+* cpp26[meta cpp]
+
+```cpp
+#define UCHAR_WIDTH implementation-defined
+```
+
+## 概要
+`unsigned char`型の幅 (値ビット数) を表す。[`CHAR_BIT`](char_bit.md)と等しい。`#if`などのプリプロセッサディレクティブで使用できる。
+
+幅 (width) とは、その型が値の表現に使用するビット数であり、符号付き整数型では符号ビットを含む。パディングビットを含むストレージサイズ (`sizeof` × [`CHAR_BIT`](/reference/climits/char_bit.md)) とは異なる場合がある。
+
+C23で`<limits.h>`に追加されたマクロであり、C++26で`<climits>`に取り込まれた。
+
+
+## 例
+```cpp example
+#include <climits>
+#include <iostream>
+
+int main()
+{
+  std::cout << UCHAR_WIDTH << '\n';
+}
+```
+* UCHAR_WIDTH[color ff0000]
+
+### 出力例
+```
+8
+```
+
+
+## バージョン
+### 言語
+- C++26
+
+### 処理系
+- [Clang](/implementation.md#clang): 23 [mark verified]
+- [GCC](/implementation.md#gcc): 17 [mark verified]
+- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl]
+
+
+## 参照
+- [P3348R4 C++26 should refer to C23 not C17](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3348r4.html)
+    - C++26がC23を参照するようになり、このマクロが`<climits>`に追加された

UINT_WIDTH -- C++26対応として、C23標準ライブラリを追加 (#1657)

2026-06-08T20:56:08+09:00

diff --git a/reference/climits/uint_width.md b/reference/climits/uint_width.md
new file mode 100644
index 000000000..a4d641768
--- /dev/null
+++ b/reference/climits/uint_width.md
@@ -0,0 +1,48 @@
+# UINT_WIDTH
+* climits[meta header]
+* macro[meta id-type]
+* cpp26[meta cpp]
+
+```cpp
+#define UINT_WIDTH implementation-defined
+```
+
+## 概要
+`unsigned int`型の幅 (値ビット数) を表す。`#if`などのプリプロセッサディレクティブで使用できる。
+
+幅 (width) とは、その型が値の表現に使用するビット数であり、符号付き整数型では符号ビットを含む。パディングビットを含むストレージサイズ (`sizeof` × [`CHAR_BIT`](/reference/climits/char_bit.md)) とは異なる場合がある。
+
+C23で`<limits.h>`に追加されたマクロであり、C++26で`<climits>`に取り込まれた。
+
+
+## 例
+```cpp example
+#include <climits>
+#include <iostream>
+
+int main()
+{
+  std::cout << UINT_WIDTH << '\n';
+}
+```
+* UINT_WIDTH[color ff0000]
+
+### 出力例
+```
+32
+```
+
+
+## バージョン
+### 言語
+- C++26
+
+### 処理系
+- [Clang](/implementation.md#clang): 23 [mark verified]
+- [GCC](/implementation.md#gcc): 17 [mark verified]
+- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl]
+
+
+## 参照
+- [P3348R4 C++26 should refer to C23 not C17](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3348r4.html)
+    - C++26がC23を参照するようになり、このマクロが`<climits>`に追加された

ULLONG_WIDTH -- C++26対応として、C23標準ライブラリを追加 (#1657)

2026-06-08T20:56:08+09:00

diff --git a/reference/climits/ullong_width.md b/reference/climits/ullong_width.md
new file mode 100644
index 000000000..beac60d95
--- /dev/null
+++ b/reference/climits/ullong_width.md
@@ -0,0 +1,48 @@
+# ULLONG_WIDTH
+* climits[meta header]
+* macro[meta id-type]
+* cpp26[meta cpp]
+
+```cpp
+#define ULLONG_WIDTH implementation-defined
+```
+
+## 概要
+`unsigned long long`型の幅 (値ビット数) を表す。`#if`などのプリプロセッサディレクティブで使用できる。
+
+幅 (width) とは、その型が値の表現に使用するビット数であり、符号付き整数型では符号ビットを含む。パディングビットを含むストレージサイズ (`sizeof` × [`CHAR_BIT`](/reference/climits/char_bit.md)) とは異なる場合がある。
+
+C23で`<limits.h>`に追加されたマクロであり、C++26で`<climits>`に取り込まれた。
+
+
+## 例
+```cpp example
+#include <climits>
+#include <iostream>
+
+int main()
+{
+  std::cout << ULLONG_WIDTH << '\n';
+}
+```
+* ULLONG_WIDTH[color ff0000]
+
+### 出力例
+```
+64
+```
+
+
+## バージョン
+### 言語
+- C++26
+
+### 処理系
+- [Clang](/implementation.md#clang): 23 [mark verified]
+- [GCC](/implementation.md#gcc): 17 [mark verified]
+- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl]
+
+
+## 参照
+- [P3348R4 C++26 should refer to C23 not C17](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3348r4.html)
+    - C++26がC23を参照するようになり、このマクロが`<climits>`に追加された

ULONG_WIDTH -- C++26対応として、C23標準ライブラリを追加 (#1657)

2026-06-08T20:56:08+09:00

diff --git a/reference/climits/ulong_width.md b/reference/climits/ulong_width.md
new file mode 100644
index 000000000..0e5186139
--- /dev/null
+++ b/reference/climits/ulong_width.md
@@ -0,0 +1,48 @@
+# ULONG_WIDTH
+* climits[meta header]
+* macro[meta id-type]
+* cpp26[meta cpp]
+
+```cpp
+#define ULONG_WIDTH implementation-defined
+```
+
+## 概要
+`unsigned long`型の幅 (値ビット数) を表す。`#if`などのプリプロセッサディレクティブで使用できる。
+
+幅 (width) とは、その型が値の表現に使用するビット数であり、符号付き整数型では符号ビットを含む。パディングビットを含むストレージサイズ (`sizeof` × [`CHAR_BIT`](/reference/climits/char_bit.md)) とは異なる場合がある。
+
+C23で`<limits.h>`に追加されたマクロであり、C++26で`<climits>`に取り込まれた。
+
+
+## 例
+```cpp example
+#include <climits>
+#include <iostream>
+
+int main()
+{
+  std::cout << ULONG_WIDTH << '\n';
+}
+```
+* ULONG_WIDTH[color ff0000]
+
+### 出力例
+```
+64
+```
+
+
+## バージョン
+### 言語
+- C++26
+
+### 処理系
+- [Clang](/implementation.md#clang): 23 [mark verified]
+- [GCC](/implementation.md#gcc): 17 [mark verified]
+- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl]
+
+
+## 参照
+- [P3348R4 C++26 should refer to C23 not C17](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3348r4.html)
+    - C++26がC23を参照するようになり、このマクロが`<climits>`に追加された

USHRT_WIDTH -- C++26対応として、C23標準ライブラリを追加 (#1657)

2026-06-08T20:56:08+09:00

diff --git a/reference/climits/ushrt_width.md b/reference/climits/ushrt_width.md
new file mode 100644
index 000000000..5a8b42c9a
--- /dev/null
+++ b/reference/climits/ushrt_width.md
@@ -0,0 +1,48 @@
+# USHRT_WIDTH
+* climits[meta header]
+* macro[meta id-type]
+* cpp26[meta cpp]
+
+```cpp
+#define USHRT_WIDTH implementation-defined
+```
+
+## 概要
+`unsigned short`型の幅 (値ビット数) を表す。`#if`などのプリプロセッサディレクティブで使用できる。
+
+幅 (width) とは、その型が値の表現に使用するビット数であり、符号付き整数型では符号ビットを含む。パディングビットを含むストレージサイズ (`sizeof` × [`CHAR_BIT`](/reference/climits/char_bit.md)) とは異なる場合がある。
+
+C23で`<limits.h>`に追加されたマクロであり、C++26で`<climits>`に取り込まれた。
+
+
+## 例
+```cpp example
+#include <climits>
+#include <iostream>
+
+int main()
+{
+  std::cout << USHRT_WIDTH << '\n';
+}
+```
+* USHRT_WIDTH[color ff0000]
+
+### 出力例
+```
+16
+```
+
+
+## バージョン
+### 言語
+- C++26
+
+### 処理系
+- [Clang](/implementation.md#clang): 23 [mark verified]
+- [GCC](/implementation.md#gcc): 17 [mark verified]
+- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl]
+
+
+## 参照
+- [P3348R4 C++26 should refer to C23 not C17](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3348r4.html)
+    - C++26がC23を参照するようになり、このマクロが`<climits>`に追加された

cmath -- C++26対応として、C23標準ライブラリを追加 (#1657)

2026-06-08T20:56:08+09:00

diff --git a/reference/cmath.md b/reference/cmath.md
index 8c440287f..d4df95c00 100644
--- a/reference/cmath.md
+++ b/reference/cmath.md
@@ -391,6 +391,8 @@ NaN を返さなければならないが定義域エラーを報告してはな
 | [`nanl`](cmath/nanf.md)             | 文字列から quiet NaN への変換 | C++11          |
 | [`nextafter`](cmath/nextafter.md)   | 指定方向への次の表現可能な値  | C++11          |
 | [`nexttoward`](cmath/nexttoward.md) | 指定方向への次の表現可能な値  | C++11          |
+| [`nextup`](cmath/nextup.md)         | 正の無限大方向への次の表現可能な値 | C++26          |
+| [`nextdown`](cmath/nextdown.md)     | 負の無限大方向への次の表現可能な値 | C++26          |
 
 
 ## <a id="maximum-minimum-and-positive-difference-functions" href="#maximum-minimum-and-positive-difference-functions">最大値・最小値と正の差</a>

INFINITY -- C++26対応として、C23標準ライブラリを追加 (#1657)

2026-06-08T20:56:08+09:00

diff --git a/reference/cmath/infinity.md b/reference/cmath/infinity.md
index 56f223c8a..c868f8e20 100644
--- a/reference/cmath/infinity.md
+++ b/reference/cmath/infinity.md
@@ -14,6 +14,15 @@
 無限大がサポートされない場合、オーバーフローする `float` 型の式である。
 
 
+## 備考
+- C++26では、C23を参照するようになったことで、このマクロは[`<cfloat>`](/reference/cfloat.md)でも定義されるようになった
+
+
 ## バージョン
 ### 言語
 - C++11
+
+
+## 参照
+- [P3348R4 C++26 should refer to C23 not C17](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3348r4.html)
+    - C++26がC23を参照するようになり、このマクロが[`<cfloat>`](/reference/cfloat.md)でも定義されるようになった

NAN -- C++26対応として、C23標準ライブラリを追加 (#1657)

2026-06-08T20:56:08+09:00

diff --git a/reference/cmath/nan.md b/reference/cmath/nan.md
index c623e65f3..5890678ee 100644
--- a/reference/cmath/nan.md
+++ b/reference/cmath/nan.md
@@ -15,6 +15,15 @@
 `float` の quiet NaN の定数式に展開される。
 
 
+## 備考
+- C++26では、C23を参照するようになったことで、このマクロは[`<cfloat>`](/reference/cfloat.md)でも定義されるようになった
+
+
 ## バージョン
 ### 言語
 - C++11
+
+
+## 参照
+- [P3348R4 C++26 should refer to C23 not C17](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3348r4.html)
+    - C++26がC23を参照するようになり、このマクロが[`<cfloat>`](/reference/cfloat.md)でも定義されるようになった

nextafter -- C++26対応として、C23標準ライブラリを追加 (#1657)

2026-06-08T20:56:08+09:00

diff --git a/reference/cmath/nextafter.md b/reference/cmath/nextafter.md
index 8a5647008..7af0bbfb0 100644
--- a/reference/cmath/nextafter.md
+++ b/reference/cmath/nextafter.md
@@ -111,6 +111,12 @@ int main()
 - [Visual C++](/implementation.md#visual_cpp): ??
 
 
+## 関連項目
+- [`nextup`](nextup.md): 正の無限大方向への次の表現可能な値を取得する
+- [`nextdown`](nextdown.md): 負の無限大方向への次の表現可能な値を取得する
+- [`nexttoward`](nexttoward.md): 指定方向への次の表現可能な値を取得する
+
+
 ## 参照
 - [P0533R9 constexpr for `<cmath>` and `<cstdlib>`](https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2021/p0533r9.pdf)
     - C++23での、一部関数の`constexpr`対応

nextdown -- C++26対応として、C23標準ライブラリを追加 (#1657)

2026-06-08T20:56:08+09:00

diff --git a/reference/cmath/nextdown.md b/reference/cmath/nextdown.md
new file mode 100644
index 000000000..14d88a015
--- /dev/null
+++ b/reference/cmath/nextdown.md
@@ -0,0 +1,84 @@
+# nextdown
+* cmath[meta header]
+* std[meta namespace]
+* function[meta id-type]
+* cpp26[meta cpp]
+
+```cpp
+namespace std {
+  constexpr floating-point-type
+    nextdown(floating-point-type x); // (1) C++26
+
+  constexpr float
+    nextdownf(float x);              // (2) C++26
+
+  constexpr long double
+    nextdownl(long double x);        // (3) C++26
+}
+```
+* floating-point-type[italic]
+
+## 概要
+負の無限大方向への次の表現可能な値を取得する。
+
+C23で`<math.h>`に追加された関数であり、C++26で`<cmath>`に取り込まれた。
+
+- (1) : 浮動小数点数型に対するオーバーロード
+- (2) : `float`型規定
+- (3) : `long double`型規定
+
+
+## 戻り値
+`x`より小さい、表現可能な最大の値を返す。
+
+- `x`が負の有限の最小値の場合、負の無限大を返す
+- `x`が負の無限大の場合、`x`を返す
+- `x`が`±0`の場合、負の絶対値が最小の表現可能な値 (絶対値が最小の負の非正規化数) を返す
+- `x`が正の最小の表現可能な値 (絶対値が最小の正数) の場合、`+0`を返す
+- `x`が`NaN`の場合、`NaN`を返す
+
+
+## 備考
+- この関数は、IEEE 754の`nextDown`演算に対応する
+- [`nextafter()`](nextafter.md)の「移動先の方向 (第2引数)」を負の無限大に固定したものに相当するが、以下の利点がある
+    - 移動方向が固定されているため、目的が明確である
+    - [`nextafter()`](nextafter.md)が、有限の最小値から無限大へ移動する場合にオーバーフロー、結果が非正規化数になる場合にアンダーフローの値域エラーを引き起こしうるのに対し、この関数は値域エラーを引き起こさない
+- 隣接する浮動小数点数を例外なしに取得できるため、計算結果を含む最小の区間を求める区間演算 (interval arithmetic) などで利用される
+
+
+## 例
+```cpp example
+#include <cmath>
+#include <print>
+
+int main()
+{
+  std::println("{}", std::nextdown(1.0f));
+}
+```
+* std::nextdown[color ff0000]
+
+### 出力例
+```
+0.99999994
+```
+
+
+## バージョン
+### 言語
+- C++26
+
+### 処理系
+- [Clang](/implementation.md#clang): 22 [mark noimpl]
+- [GCC](/implementation.md#gcc): 16.1 [mark noimpl]
+- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl]
+
+
+## 関連項目
+- [`nextup`](nextup.md): 正の無限大方向への次の表現可能な値を取得する
+- [`nextafter`](nextafter.md): 指定方向への次の表現可能な値を取得する
+
+
+## 参照
+- [P3348R4 C++26 should refer to C23 not C17](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3348r4.html)
+    - C++26がC23を参照するようになり、この関数が`<cmath>`に追加された

nextup -- C++26対応として、C23標準ライブラリを追加 (#1657)

2026-06-08T20:56:08+09:00

diff --git a/reference/cmath/nextup.md b/reference/cmath/nextup.md
new file mode 100644
index 000000000..80fa0ff1e
--- /dev/null
+++ b/reference/cmath/nextup.md
@@ -0,0 +1,84 @@
+# nextup
+* cmath[meta header]
+* std[meta namespace]
+* function[meta id-type]
+* cpp26[meta cpp]
+
+```cpp
+namespace std {
+  constexpr floating-point-type
+    nextup(floating-point-type x); // (1) C++26
+
+  constexpr float
+    nextupf(float x);              // (2) C++26
+
+  constexpr long double
+    nextupl(long double x);        // (3) C++26
+}
+```
+* floating-point-type[italic]
+
+## 概要
+正の無限大方向への次の表現可能な値を取得する。
+
+C23で`<math.h>`に追加された関数であり、C++26で`<cmath>`に取り込まれた。
+
+- (1) : 浮動小数点数型に対するオーバーロード
+- (2) : `float`型規定
+- (3) : `long double`型規定
+
+
+## 戻り値
+`x`より大きい、表現可能な最小の値を返す。
+
+- `x`が正の有限の最大値の場合、正の無限大を返す
+- `x`が正の無限大の場合、`x`を返す
+- `x`が`±0`の場合、正の最小の表現可能な値 (正の最小の非正規化数) を返す
+- `x`が負の最小の表現可能な値 (絶対値が最小の負数) の場合、`-0`を返す
+- `x`が`NaN`の場合、`NaN`を返す
+
+
+## 備考
+- この関数は、IEEE 754の`nextUp`演算に対応する
+- [`nextafter()`](nextafter.md)の「移動先の方向 (第2引数)」を正の無限大に固定したものに相当するが、以下の利点がある
+    - 移動方向が固定されているため、目的が明確である
+    - [`nextafter()`](nextafter.md)が、有限の最大値から無限大へ移動する場合にオーバーフロー、結果が非正規化数になる場合にアンダーフローの値域エラーを引き起こしうるのに対し、この関数は値域エラーを引き起こさない
+- 隣接する浮動小数点数を例外なしに取得できるため、計算結果を含む最小の区間を求める区間演算 (interval arithmetic) などで利用される
+
+
+## 例
+```cpp example
+#include <cmath>
+#include <print>
+
+int main()
+{
+  std::println("{}", std::nextup(1.0f));
+}
+```
+* std::nextup[color ff0000]
+
+### 出力例
+```
+1.0000001
+```
+
+
+## バージョン
+### 言語
+- C++26
+
+### 処理系
+- [Clang](/implementation.md#clang): 22 [mark noimpl]
+- [GCC](/implementation.md#gcc): 16.1 [mark noimpl]
+- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl]
+
+
+## 関連項目
+- [`nextdown`](nextdown.md): 負の無限大方向への次の表現可能な値を取得する
+- [`nextafter`](nextafter.md): 指定方向への次の表現可能な値を取得する
+
+
+## 参照
+- [P3348R4 C++26 should refer to C23 not C17](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3348r4.html)
+    - C++26がC23を参照するようになり、この関数が`<cmath>`に追加された

cstddef -- C++26対応として、C23標準ライブラリを追加 (#1657)

2026-06-08T20:56:08+09:00

cstddef

<cstddef>ヘッダでは基本的な型、値、マクロを定義する。

本ヘッダはフリースタンディング環境でも提供される。

型

名前	説明	対応バージョン
`ptrdiff_t`	ポインタの差演算の結果
`size_t`	符号なし整数型
`nullptr_t`	`nullptr`の型	C++11
`max_align_t`	最大のアライメントを要求する型	C++11
`byte`	バイトデータを表す型	C++17

関数マクロ

名前	説明	対応バージョン
`offsetof`	メンバへのオフセットを返す

定数

名前	説明	対応バージョン
`NULL`	ヌルポインタ定数に展開されるマクロ

C言語においては、このヘッダはwchar_t型（ワイド文字型）の宣言もインクルードする。C++においてwchar_t型は組み込み型であるため、いかなるヘッダもインクルードする必要がない。

備考

C23の<stddef.h>が定義するunreachableマクロは、<cstddef>では定義されない。C++ではstd::unreachable()を使用する
C23の<stddef.h>が定義するバージョンマクロ__STDC_VERSION_STDDEF_H__は、<cstddef>では意図的に定義されない

参照

P3348R4 C++26 should refer to C23 not C17
- C++26がC23を参照するようになった際、<cstddef>ではunreachableマクロおよび__STDC_VERSION_STDDEF_H__を定義しないことが明記された

cstdint -- C++26対応として、C23標準ライブラリを追加 (#1657)

2026-06-08T20:56:08+09:00

cstdint(C++11)

<cstdint>ヘッダでは、ビット数が規定された整数型の別名、およびマクロを提供する。これらの機能は、std名前空間に属することを除いてC言語の標準ライブラリ<stdint.h>ヘッダと同じである。

本ヘッダはフリースタンディング環境でも提供される。

符号付き整数型

型	説明	対応バージョン
`int8_t`	8ビット幅の符号付き整数(実装するかどうかは処理系定義)	C++11
`int16_t`	16ビット幅の符号付き整数(実装するかどうかは処理系定義)	C++11
`int32_t`	32ビット幅の符号付き整数(実装するかどうかは処理系定義)	C++11
`int64_t`	64ビット幅の符号付き整数(実装するかどうかは処理系定義)	C++11
`int_fast8_t`	少なくても8ビット幅を持ち、演算が高速な符号付き整数	C++11
`int_fast16_t`	少なくても16ビット幅を持ち、演算が高速な符号付き整数	C++11
`int_fast32_t`	少なくても32ビット幅を持ち、演算が高速な符号付き整数	C++11
`int_fast64_t`	少なくても64ビット幅を持ち、演算が高速な符号付き整数	C++11
`int_least8_t`	少なくても8ビット幅を持つ、最小の符号付き整数	C++11
`int_least16_t`	少なくても16ビット幅を持つ、最小の符号付き整数	C++11
`int_least32_t`	少なくても32ビット幅を持つ、最小の符号付き整数	C++11
`int_least64_t`	少なくても64ビット幅を持つ、最小の符号付き整数	C++11
`intmax_t`	最も大きい符号付き整数型	C++11
`intptr_t`	ポインタサイズの符号付き整数型(実装するかどうかは処理系定義)	C++11

符号なし整数型

型	説明	対応バージョン
`uint8_t`	8ビット幅の符号なし整数(実装するかどうかは処理系定義)	C++11
`uint16_t`	16ビット幅の符号なし整数(実装するかどうかは処理系定義)	C++11
`uint32_t`	32ビット幅の符号なし整数(実装するかどうかは処理系定義)	C++11
`uint64_t`	64ビット幅の符号なし整数(実装するかどうかは処理系定義)	C++11
`uint_fast8_t`	少なくても8ビット幅を持ち、演算が高速な符号なし整数	C++11
`uint_fast16_t`	少なくても16ビット幅を持ち、演算が高速な符号なし整数	C++11
`uint_fast32_t`	少なくても32ビット幅を持ち、演算が高速な符号なし整数	C++11
`uint_fast64_t`	少なくても64ビット幅を持ち、演算が高速な符号なし整数	C++11
`uint_least8_t`	少なくても8ビット幅を持つ、最小の符号なし整数	C++11
`uint_least16_t`	少なくても16ビット幅を持つ、最小の符号なし整数	C++11
`uint_least32_t`	少なくても32ビット幅を持つ、最小の符号なし整数	C++11
`uint_least64_t`	少なくても64ビット幅を持つ、最小の符号なし整数	C++11
`uintmax_t`	最も大きい符号なし整数型	C++11
`uintptr_t`	ポインタサイズの符号なし整数型(実装するかどうかは処理系定義)	C++11

以下のマクロは、整数型の限界値を表す。

符号付き整数型用の限界値マクロ

マクロ	説明	対応バージョン
`INT8_MIN`	`int8_t`の最小値(実装するかどうかは処理系定義)	C++11
`INT8_MAX`	`int8_t`の最大値(実装するかどうかは処理系定義)	C++11
`INT16_MIN`	`int16_t`の最小値(実装するかどうかは処理系定義)	C++11
`INT16_MAX`	`int16_t`の最大値(実装するかどうかは処理系定義)	C++11
`INT32_MIN`	`int32_t`の最小値(実装するかどうかは処理系定義)	C++11
`INT32_MAX`	`int32_t`の最大値(実装するかどうかは処理系定義)	C++11
`INT64_MIN`	`int64_t`の最小値(実装するかどうかは処理系定義)	C++11
`INT64_MAX`	`int64_t`の最大値(実装するかどうかは処理系定義)	C++11
`INT_FAST8_MIN`	`int_fast8_t`の最小値	C++11
`INT_FAST8_MAX`	`int_fast8_t`の最大値	C++11
`INT_FAST16_MIN`	`int_fast16_t`の最小値	C++11
`INT_FAST16_MAX`	`int_fast16_t`の最大値	C++11
`INT_FAST32_MIN`	`int_fast32_t`の最小値	C++11
`INT_FAST32_MAX`	`int_fast32_t`の最大値	C++11
`INT_FAST64_MIN`	`int_fast64_t`の最小値	C++11
`INT_FAST64_MAX`	`int_fast64_t`の最大値	C++11
`INT_LEAST8_MIN`	`int_least8_t`の最小値	C++11
`INT_LEAST8_MAX`	`int_least8_t`の最大値	C++11
`INT_LEAST16_MIN`	`int_least16_t`の最小値	C++11
`INT_LEAST16_MAX`	`int_least16_t`の最大値	C++11
`INT_LEAST32_MIN`	`int_least32_t`の最小値	C++11
`INT_LEAST32_MAX`	`int_least32_t`の最大値	C++11
`INT_LEAST64_MIN`	`int_least64_t`の最小値	C++11
`INT_LEAST64_MAX`	`int_least64_t`の最大値	C++11
`INTMAX_MIN`	`intmax_t`の最小値	C++11
`INTMAX_MAX`	`intmax_t`の最大値	C++11
`INTPTR_MIN`	`intptr_t`の最小値(実装するかどうかは処理系定義)	C++11
`INTPTR_MAX`	`intptr_t`の最大値(実装するかどうかは処理系定義)	C++11
`PTRDIFF_MIN`	`ptrdiff_t`の最小値	C++11
`PTRDIFF_MAX`	`ptrdiff_t`の最大値	C++11
`SIG_ATOMIC_MIN`	`sig_atomic_t`の最小値	C++11
`SIG_ATOMIC_MAX`	`sig_atomic_t`の最大値	C++11
`WCHAR_MIN`	`wchar_t`の最小値	C++11
`WCHAR_MAX`	`wchar_t`の最大値	C++11
`WINT_MIN`	`wint_t`の最小値	C++11
`WINT_MAX`	`wint_t`の最大値	C++11

符号なし整数型用の限界値マクロ

マクロ	説明	対応バージョン
`UINT8_MAX`	`uint8_t`の最大値(実装するかどうかは処理系定義)	C++11
`UINT16_MAX`	`uint16_t`の最大値(実装するかどうかは処理系定義)	C++11
`UINT32_MAX`	`uint32_t`の最大値(実装するかどうかは処理系定義)	C++11
`UINT64_MAX`	`uint64_t`の最大値(実装するかどうかは処理系定義)	C++11
`UINT_FAST8_MAX`	`uint_fast8_t`の最大値	C++11
`UINT_FAST16_MAX`	`uint_fast16_t`の最大値	C++11
`UINT_FAST32_MAX`	`uint_fast32_t`の最大値	C++11
`UINT_FAST64_MAX`	`uint_fast64_t`の最大値	C++11
`UINT_LEAST8_MAX`	`uint_least8_t`の最大値	C++11
`UINT_LEAST16_MAX`	`uint_least16_t`の最大値	C++11
`UINT_LEAST32_MAX`	`uint_least32_t`の最大値	C++11
`UINT_LEAST64_MAX`	`uint_least64_t`の最大値	C++11
`UINTMAX_MAX`	`uintmax_t`の最大値	C++11
`UINTPTR_MAX`	`uintptr_t`の最大値(実装するかどうかは処理系定義)	C++11
`SIZE_MAX`	`size_t`の最大値	C++11

幅マクロ

以下のマクロは、各整数型の幅 (値ビット数) を表す。

マクロ	説明	対応バージョン
`INT8_WIDTH`	`int8_t`の幅(実装するかどうかは処理系定義)	C++26
`INT16_WIDTH`	`int16_t`の幅(実装するかどうかは処理系定義)	C++26
`INT32_WIDTH`	`int32_t`の幅(実装するかどうかは処理系定義)	C++26
`INT64_WIDTH`	`int64_t`の幅(実装するかどうかは処理系定義)	C++26
`UINT8_WIDTH`	`uint8_t`の幅(実装するかどうかは処理系定義)	C++26
`UINT16_WIDTH`	`uint16_t`の幅(実装するかどうかは処理系定義)	C++26
`UINT32_WIDTH`	`uint32_t`の幅(実装するかどうかは処理系定義)	C++26
`UINT64_WIDTH`	`uint64_t`の幅(実装するかどうかは処理系定義)	C++26
`INT_FAST8_WIDTH`	`int_fast8_t`の幅	C++26
`INT_FAST16_WIDTH`	`int_fast16_t`の幅	C++26
`INT_FAST32_WIDTH`	`int_fast32_t`の幅	C++26
`INT_FAST64_WIDTH`	`int_fast64_t`の幅	C++26
`UINT_FAST8_WIDTH`	`uint_fast8_t`の幅	C++26
`UINT_FAST16_WIDTH`	`uint_fast16_t`の幅	C++26
`UINT_FAST32_WIDTH`	`uint_fast32_t`の幅	C++26
`UINT_FAST64_WIDTH`	`uint_fast64_t`の幅	C++26
`INT_LEAST8_WIDTH`	`int_least8_t`の幅	C++26
`INT_LEAST16_WIDTH`	`int_least16_t`の幅	C++26
`INT_LEAST32_WIDTH`	`int_least32_t`の幅	C++26
`INT_LEAST64_WIDTH`	`int_least64_t`の幅	C++26
`UINT_LEAST8_WIDTH`	`uint_least8_t`の幅	C++26
`UINT_LEAST16_WIDTH`	`uint_least16_t`の幅	C++26
`UINT_LEAST32_WIDTH`	`uint_least32_t`の幅	C++26
`UINT_LEAST64_WIDTH`	`uint_least64_t`の幅	C++26
`INTMAX_WIDTH`	`intmax_t`の幅	C++26
`UINTMAX_WIDTH`	`uintmax_t`の幅	C++26
`INTPTR_WIDTH`	`intptr_t`の幅(実装するかどうかは処理系定義)	C++26
`UINTPTR_WIDTH`	`uintptr_t`の幅(実装するかどうかは処理系定義)	C++26
`PTRDIFF_WIDTH`	`ptrdiff_t`の幅	C++26
`SIZE_WIDTH`	`size_t`の幅	C++26
`SIG_ATOMIC_WIDTH`	`sig_atomic_t`の幅	C++26
`WCHAR_WIDTH`	`wchar_t`の幅	C++26
`WINT_WIDTH`	`wint_t`の幅	C++26

バージョン情報マクロ

マクロ	説明	対応バージョン
`__STDC_VERSION_STDINT_H__`	`<cstdint>`が提供するC標準ライブラリ機能のバージョン (`202311L`)	C++26

符号付き整数型用の定数値マクロ

以下のマクロは、各整数型の定数値を表す関数マクロである。
例： int8_t x = INT8_C(1);

マクロ	説明	対応バージョン
`INT8_C(n)`	8ビット幅を持つ、符号付き整数型の定数値(実装するかどうかは処理系定義)	C++11
`INT16_C(n)`	16ビット幅を持つ、符号付き整数型の定数値(実装するかどうかは処理系定義)	C++11
`INT32_C(n)`	32ビット幅を持つ、符号付き整数型の定数値(実装するかどうかは処理系定義)	C++11
`INT64_C(n)`	64ビット幅を持つ、符号付き整数型の定数値(実装するかどうかは処理系定義)	C++11
`INTMAX_C(n)`	最も大きい符号付き整数型の定数値	C++11

符号なし整数型用の定数値マクロ

マクロ	説明	対応バージョン
`UINT8_C(n)`	8ビット幅を持つ、符号なし整数型の定数値(実装するかどうかは処理系定義)	C++11
`UINT16_C(n)`	16ビット幅を持つ、符号なし整数型の定数値(実装するかどうかは処理系定義)	C++11
`UINT32_C(n)`	32ビット幅を持つ、符号なし整数型の定数値(実装するかどうかは処理系定義)	C++11
`UINT64_C(n)`	64ビット幅を持つ、符号なし整数型の定数値(実装するかどうかは処理系定義)	C++11
`UINTMAX_C(n)`	最も大きい符号なし整数型の定数値	C++11

備考

`__STDC_LIMIT_MACROS`, `__STDC_CONSTANT_MACROS` マクロについて

C99 の 7.18.3 <stdint.h> についての脚注で、同ヘッダを C++ でコンパイルする場合に限界値マクロ、定数値マクロを得るためにはこれらのマクロを事前に定義する必要があるものとされていた。

Footnote 219, 220: C++ implementations should define these macros only when __STDC_LIMIT_MACROS is defined before <stdint.h> is included.

Footnote 222: C++ implementations should define these macros only when __STDC_CONSTANT_MACROS is defined before <stdint.h> is included.

しかしその後の C 規格改定でこの脚注は削除され、 C11 では触れられていない。 C++11 は（ C++14 も） C99 を参照規格としているが、 18.4.1 [cstdint.syn] p2 に注釈として、これらのマクロは採用されていないことが明記されている。

The macros defined by <cstdint> are provided unconditionally. In particular, the symbols __STDC_LIMIT_MACROS and __STDC_CONSTANT_MACROS (mentioned in footnotes 219, 220, and 222 in the C standard) play no role in C++.

おそらく上記 C99 の脚注のため、 C++ 処理系によってはヘッダ <stdint.h> および <cstdint> での限界値マクロ、定数値マクロの提供にこれらマクロの定義が必要となっているかもしれない。（特に C++03 対応の処理系が拡張として C99 由来のこれらヘッダを提供していた場合など。）

glibc に対するバグ報告（修正は 2013/05/21 ） Bug 15366 – Per C11 and C++11, <stdint.h> should not look at __STDC_LIMIT_MACROS or __STDC_CONSTANT_MACROS
What do __STDC_LIMIT_MACROS and __STDC_CONSTANT_MACROS mean? - Stack Overflow

バージョン

言語

C++11

参照

N1568 Proposed additions to TR-1 to improve compatibility with C99
N1835 <stdint.h> for C++
P3348R4 C++26 should refer to C23 not C17
- C++26がC23を参照するようになり、各整数型の幅を表すマクロと__STDC_VERSION_STDINT_H__が追加された

INT16_WIDTH -- C++26対応として、C23標準ライブラリを追加 (#1657)

2026-06-08T20:56:08+09:00

diff --git a/reference/cstdint/int16_width.md b/reference/cstdint/int16_width.md
new file mode 100644
index 000000000..32a06ceec
--- /dev/null
+++ b/reference/cstdint/int16_width.md
@@ -0,0 +1,48 @@
+# INT16_WIDTH
+* cstdint[meta header]
+* macro[meta id-type]
+* cpp26[meta cpp]
+
+```cpp
+#define INT16_WIDTH implementation-defined
+```
+
+## 概要
+[`int16_t`](int16_t.md)型の幅 (値ビット数) を表す(実装するかどうかは処理系定義)。`#if`などのプリプロセッサディレクティブで使用できる。
+
+幅 (width) とは、その型が値の表現に使用するビット数であり、符号付き整数型では符号ビットを含む。パディングビットを含むストレージサイズ (`sizeof` × [`CHAR_BIT`](/reference/climits/char_bit.md)) とは異なる場合がある。
+
+C23で`<stdint.h>`に追加されたマクロであり、C++26で`<cstdint>`に取り込まれた。
+
+
+## 例
+```cpp example
+#include <cstdint>
+#include <iostream>
+
+int main()
+{
+  std::cout << INT16_WIDTH << '\n';
+}
+```
+* INT16_WIDTH[color ff0000]
+
+### 出力例
+```
+16
+```
+
+
+## バージョン
+### 言語
+- C++26
+
+### 処理系
+- [Clang](/implementation.md#clang): 23 [mark verified]
+- [GCC](/implementation.md#gcc): 17 [mark verified]
+- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl]
+
+
+## 参照
+- [P3348R4 C++26 should refer to C23 not C17](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3348r4.html)
+    - C++26がC23を参照するようになり、このマクロが`<cstdint>`に追加された

INT32_WIDTH -- C++26対応として、C23標準ライブラリを追加 (#1657)

2026-06-08T20:56:08+09:00

diff --git a/reference/cstdint/int32_width.md b/reference/cstdint/int32_width.md
new file mode 100644
index 000000000..063be7d28
--- /dev/null
+++ b/reference/cstdint/int32_width.md
@@ -0,0 +1,48 @@
+# INT32_WIDTH
+* cstdint[meta header]
+* macro[meta id-type]
+* cpp26[meta cpp]
+
+```cpp
+#define INT32_WIDTH implementation-defined
+```
+
+## 概要
+[`int32_t`](int32_t.md)型の幅 (値ビット数) を表す(実装するかどうかは処理系定義)。`#if`などのプリプロセッサディレクティブで使用できる。
+
+幅 (width) とは、その型が値の表現に使用するビット数であり、符号付き整数型では符号ビットを含む。パディングビットを含むストレージサイズ (`sizeof` × [`CHAR_BIT`](/reference/climits/char_bit.md)) とは異なる場合がある。
+
+C23で`<stdint.h>`に追加されたマクロであり、C++26で`<cstdint>`に取り込まれた。
+
+
+## 例
+```cpp example
+#include <cstdint>
+#include <iostream>
+
+int main()
+{
+  std::cout << INT32_WIDTH << '\n';
+}
+```
+* INT32_WIDTH[color ff0000]
+
+### 出力例
+```
+32
+```
+
+
+## バージョン
+### 言語
+- C++26
+
+### 処理系
+- [Clang](/implementation.md#clang): 23 [mark verified]
+- [GCC](/implementation.md#gcc): 17 [mark verified]
+- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl]
+
+
+## 参照
+- [P3348R4 C++26 should refer to C23 not C17](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3348r4.html)
+    - C++26がC23を参照するようになり、このマクロが`<cstdint>`に追加された

INT64_WIDTH -- C++26対応として、C23標準ライブラリを追加 (#1657)

2026-06-08T20:56:08+09:00

diff --git a/reference/cstdint/int64_width.md b/reference/cstdint/int64_width.md
new file mode 100644
index 000000000..f23fc651a
--- /dev/null
+++ b/reference/cstdint/int64_width.md
@@ -0,0 +1,48 @@
+# INT64_WIDTH
+* cstdint[meta header]
+* macro[meta id-type]
+* cpp26[meta cpp]
+
+```cpp
+#define INT64_WIDTH implementation-defined
+```
+
+## 概要
+[`int64_t`](int64_t.md)型の幅 (値ビット数) を表す(実装するかどうかは処理系定義)。`#if`などのプリプロセッサディレクティブで使用できる。
+
+幅 (width) とは、その型が値の表現に使用するビット数であり、符号付き整数型では符号ビットを含む。パディングビットを含むストレージサイズ (`sizeof` × [`CHAR_BIT`](/reference/climits/char_bit.md)) とは異なる場合がある。
+
+C23で`<stdint.h>`に追加されたマクロであり、C++26で`<cstdint>`に取り込まれた。
+
+
+## 例
+```cpp example
+#include <cstdint>
+#include <iostream>
+
+int main()
+{
+  std::cout << INT64_WIDTH << '\n';
+}
+```
+* INT64_WIDTH[color ff0000]
+
+### 出力例
+```
+64
+```
+
+
+## バージョン
+### 言語
+- C++26
+
+### 処理系
+- [Clang](/implementation.md#clang): 23 [mark verified]
+- [GCC](/implementation.md#gcc): 17 [mark verified]
+- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl]
+
+
+## 参照
+- [P3348R4 C++26 should refer to C23 not C17](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3348r4.html)
+    - C++26がC23を参照するようになり、このマクロが`<cstdint>`に追加された

INT8_WIDTH -- C++26対応として、C23標準ライブラリを追加 (#1657)

2026-06-08T20:56:08+09:00

diff --git a/reference/cstdint/int8_width.md b/reference/cstdint/int8_width.md
new file mode 100644
index 000000000..dc59d16e9
--- /dev/null
+++ b/reference/cstdint/int8_width.md
@@ -0,0 +1,48 @@
+# INT8_WIDTH
+* cstdint[meta header]
+* macro[meta id-type]
+* cpp26[meta cpp]
+
+```cpp
+#define INT8_WIDTH implementation-defined
+```
+
+## 概要
+[`int8_t`](int8_t.md)型の幅 (値ビット数) を表す(実装するかどうかは処理系定義)。`#if`などのプリプロセッサディレクティブで使用できる。
+
+幅 (width) とは、その型が値の表現に使用するビット数であり、符号付き整数型では符号ビットを含む。パディングビットを含むストレージサイズ (`sizeof` × [`CHAR_BIT`](/reference/climits/char_bit.md)) とは異なる場合がある。
+
+C23で`<stdint.h>`に追加されたマクロであり、C++26で`<cstdint>`に取り込まれた。
+
+
+## 例
+```cpp example
+#include <cstdint>
+#include <iostream>
+
+int main()
+{
+  std::cout << INT8_WIDTH << '\n';
+}
+```
+* INT8_WIDTH[color ff0000]
+
+### 出力例
+```
+8
+```
+
+
+## バージョン
+### 言語
+- C++26
+
+### 処理系
+- [Clang](/implementation.md#clang): 23 [mark verified]
+- [GCC](/implementation.md#gcc): 17 [mark verified]
+- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl]
+
+
+## 参照
+- [P3348R4 C++26 should refer to C23 not C17](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3348r4.html)
+    - C++26がC23を参照するようになり、このマクロが`<cstdint>`に追加された

INT_FAST16_WIDTH -- C++26対応として、C23標準ライブラリを追加 (#1657)

2026-06-08T20:56:08+09:00

diff --git a/reference/cstdint/int_fast16_width.md b/reference/cstdint/int_fast16_width.md
new file mode 100644
index 000000000..44b52c9c4
--- /dev/null
+++ b/reference/cstdint/int_fast16_width.md
@@ -0,0 +1,48 @@
+# INT_FAST16_WIDTH
+* cstdint[meta header]
+* macro[meta id-type]
+* cpp26[meta cpp]
+
+```cpp
+#define INT_FAST16_WIDTH implementation-defined
+```
+
+## 概要
+[`int_fast16_t`](int_fast16_t.md)型の幅 (値ビット数) を表す。`#if`などのプリプロセッサディレクティブで使用できる。
+
+幅 (width) とは、その型が値の表現に使用するビット数であり、符号付き整数型では符号ビットを含む。パディングビットを含むストレージサイズ (`sizeof` × [`CHAR_BIT`](/reference/climits/char_bit.md)) とは異なる場合がある。
+
+C23で`<stdint.h>`に追加されたマクロであり、C++26で`<cstdint>`に取り込まれた。
+
+
+## 例
+```cpp example
+#include <cstdint>
+#include <iostream>
+
+int main()
+{
+  std::cout << INT_FAST16_WIDTH << '\n';
+}
+```
+* INT_FAST16_WIDTH[color ff0000]
+
+### 出力例
+```
+16
+```
+
+
+## バージョン
+### 言語
+- C++26
+
+### 処理系
+- [Clang](/implementation.md#clang): 23 [mark verified]
+- [GCC](/implementation.md#gcc): 17 [mark verified]
+- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl]
+
+
+## 参照
+- [P3348R4 C++26 should refer to C23 not C17](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3348r4.html)
+    - C++26がC23を参照するようになり、このマクロが`<cstdint>`に追加された

INT_FAST32_WIDTH -- C++26対応として、C23標準ライブラリを追加 (#1657)

2026-06-08T20:56:08+09:00

diff --git a/reference/cstdint/int_fast32_width.md b/reference/cstdint/int_fast32_width.md
new file mode 100644
index 000000000..838349355
--- /dev/null
+++ b/reference/cstdint/int_fast32_width.md
@@ -0,0 +1,48 @@
+# INT_FAST32_WIDTH
+* cstdint[meta header]
+* macro[meta id-type]
+* cpp26[meta cpp]
+
+```cpp
+#define INT_FAST32_WIDTH implementation-defined
+```
+
+## 概要
+[`int_fast32_t`](int_fast32_t.md)型の幅 (値ビット数) を表す。`#if`などのプリプロセッサディレクティブで使用できる。
+
+幅 (width) とは、その型が値の表現に使用するビット数であり、符号付き整数型では符号ビットを含む。パディングビットを含むストレージサイズ (`sizeof` × [`CHAR_BIT`](/reference/climits/char_bit.md)) とは異なる場合がある。
+
+C23で`<stdint.h>`に追加されたマクロであり、C++26で`<cstdint>`に取り込まれた。
+
+
+## 例
+```cpp example
+#include <cstdint>
+#include <iostream>
+
+int main()
+{
+  std::cout << INT_FAST32_WIDTH << '\n';
+}
+```
+* INT_FAST32_WIDTH[color ff0000]
+
+### 出力例
+```
+32
+```
+
+
+## バージョン
+### 言語
+- C++26
+
+### 処理系
+- [Clang](/implementation.md#clang): 23 [mark verified]
+- [GCC](/implementation.md#gcc): 17 [mark verified]
+- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl]
+
+
+## 参照
+- [P3348R4 C++26 should refer to C23 not C17](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3348r4.html)
+    - C++26がC23を参照するようになり、このマクロが`<cstdint>`に追加された

INT_FAST64_WIDTH -- C++26対応として、C23標準ライブラリを追加 (#1657)

2026-06-08T20:56:08+09:00

diff --git a/reference/cstdint/int_fast64_width.md b/reference/cstdint/int_fast64_width.md
new file mode 100644
index 000000000..f31893452
--- /dev/null
+++ b/reference/cstdint/int_fast64_width.md
@@ -0,0 +1,48 @@
+# INT_FAST64_WIDTH
+* cstdint[meta header]
+* macro[meta id-type]
+* cpp26[meta cpp]
+
+```cpp
+#define INT_FAST64_WIDTH implementation-defined
+```
+
+## 概要
+[`int_fast64_t`](int_fast64_t.md)型の幅 (値ビット数) を表す。`#if`などのプリプロセッサディレクティブで使用できる。
+
+幅 (width) とは、その型が値の表現に使用するビット数であり、符号付き整数型では符号ビットを含む。パディングビットを含むストレージサイズ (`sizeof` × [`CHAR_BIT`](/reference/climits/char_bit.md)) とは異なる場合がある。
+
+C23で`<stdint.h>`に追加されたマクロであり、C++26で`<cstdint>`に取り込まれた。
+
+
+## 例
+```cpp example
+#include <cstdint>
+#include <iostream>
+
+int main()
+{
+  std::cout << INT_FAST64_WIDTH << '\n';
+}
+```
+* INT_FAST64_WIDTH[color ff0000]
+
+### 出力例
+```
+64
+```
+
+
+## バージョン
+### 言語
+- C++26
+
+### 処理系
+- [Clang](/implementation.md#clang): 23 [mark verified]
+- [GCC](/implementation.md#gcc): 17 [mark verified]
+- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl]
+
+
+## 参照
+- [P3348R4 C++26 should refer to C23 not C17](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3348r4.html)
+    - C++26がC23を参照するようになり、このマクロが`<cstdint>`に追加された

INT_FAST8_WIDTH -- C++26対応として、C23標準ライブラリを追加 (#1657)

2026-06-08T20:56:08+09:00

diff --git a/reference/cstdint/int_fast8_width.md b/reference/cstdint/int_fast8_width.md
new file mode 100644
index 000000000..ce16a382d
--- /dev/null
+++ b/reference/cstdint/int_fast8_width.md
@@ -0,0 +1,48 @@
+# INT_FAST8_WIDTH
+* cstdint[meta header]
+* macro[meta id-type]
+* cpp26[meta cpp]
+
+```cpp
+#define INT_FAST8_WIDTH implementation-defined
+```
+
+## 概要
+[`int_fast8_t`](int_fast8_t.md)型の幅 (値ビット数) を表す。`#if`などのプリプロセッサディレクティブで使用できる。
+
+幅 (width) とは、その型が値の表現に使用するビット数であり、符号付き整数型では符号ビットを含む。パディングビットを含むストレージサイズ (`sizeof` × [`CHAR_BIT`](/reference/climits/char_bit.md)) とは異なる場合がある。
+
+C23で`<stdint.h>`に追加されたマクロであり、C++26で`<cstdint>`に取り込まれた。
+
+
+## 例
+```cpp example
+#include <cstdint>
+#include <iostream>
+
+int main()
+{
+  std::cout << INT_FAST8_WIDTH << '\n';
+}
+```
+* INT_FAST8_WIDTH[color ff0000]
+
+### 出力例
+```
+8
+```
+
+
+## バージョン
+### 言語
+- C++26
+
+### 処理系
+- [Clang](/implementation.md#clang): 23 [mark verified]
+- [GCC](/implementation.md#gcc): 17 [mark verified]
+- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl]
+
+
+## 参照
+- [P3348R4 C++26 should refer to C23 not C17](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3348r4.html)
+    - C++26がC23を参照するようになり、このマクロが`<cstdint>`に追加された

INT_LEAST16_WIDTH -- C++26対応として、C23標準ライブラリを追加 (#1657)

2026-06-08T20:56:08+09:00

diff --git a/reference/cstdint/int_least16_width.md b/reference/cstdint/int_least16_width.md
new file mode 100644
index 000000000..9e5de3ed1
--- /dev/null
+++ b/reference/cstdint/int_least16_width.md
@@ -0,0 +1,48 @@
+# INT_LEAST16_WIDTH
+* cstdint[meta header]
+* macro[meta id-type]
+* cpp26[meta cpp]
+
+```cpp
+#define INT_LEAST16_WIDTH implementation-defined
+```
+
+## 概要
+[`int_least16_t`](int_least16_t.md)型の幅 (値ビット数) を表す。`#if`などのプリプロセッサディレクティブで使用できる。
+
+幅 (width) とは、その型が値の表現に使用するビット数であり、符号付き整数型では符号ビットを含む。パディングビットを含むストレージサイズ (`sizeof` × [`CHAR_BIT`](/reference/climits/char_bit.md)) とは異なる場合がある。
+
+C23で`<stdint.h>`に追加されたマクロであり、C++26で`<cstdint>`に取り込まれた。
+
+
+## 例
+```cpp example
+#include <cstdint>
+#include <iostream>
+
+int main()
+{
+  std::cout << INT_LEAST16_WIDTH << '\n';
+}
+```
+* INT_LEAST16_WIDTH[color ff0000]
+
+### 出力例
+```
+16
+```
+
+
+## バージョン
+### 言語
+- C++26
+
+### 処理系
+- [Clang](/implementation.md#clang): 23 [mark verified]
+- [GCC](/implementation.md#gcc): 17 [mark verified]
+- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl]
+
+
+## 参照
+- [P3348R4 C++26 should refer to C23 not C17](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3348r4.html)
+    - C++26がC23を参照するようになり、このマクロが`<cstdint>`に追加された

INT_LEAST32_WIDTH -- C++26対応として、C23標準ライブラリを追加 (#1657)

2026-06-08T20:56:08+09:00

diff --git a/reference/cstdint/int_least32_width.md b/reference/cstdint/int_least32_width.md
new file mode 100644
index 000000000..1d0684b84
--- /dev/null
+++ b/reference/cstdint/int_least32_width.md
@@ -0,0 +1,48 @@
+# INT_LEAST32_WIDTH
+* cstdint[meta header]
+* macro[meta id-type]
+* cpp26[meta cpp]
+
+```cpp
+#define INT_LEAST32_WIDTH implementation-defined
+```
+
+## 概要
+[`int_least32_t`](int_least32_t.md)型の幅 (値ビット数) を表す。`#if`などのプリプロセッサディレクティブで使用できる。
+
+幅 (width) とは、その型が値の表現に使用するビット数であり、符号付き整数型では符号ビットを含む。パディングビットを含むストレージサイズ (`sizeof` × [`CHAR_BIT`](/reference/climits/char_bit.md)) とは異なる場合がある。
+
+C23で`<stdint.h>`に追加されたマクロであり、C++26で`<cstdint>`に取り込まれた。
+
+
+## 例
+```cpp example
+#include <cstdint>
+#include <iostream>
+
+int main()
+{
+  std::cout << INT_LEAST32_WIDTH << '\n';
+}
+```
+* INT_LEAST32_WIDTH[color ff0000]
+
+### 出力例
+```
+32
+```
+
+
+## バージョン
+### 言語
+- C++26
+
+### 処理系
+- [Clang](/implementation.md#clang): 23 [mark verified]
+- [GCC](/implementation.md#gcc): 17 [mark verified]
+- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl]
+
+
+## 参照
+- [P3348R4 C++26 should refer to C23 not C17](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3348r4.html)
+    - C++26がC23を参照するようになり、このマクロが`<cstdint>`に追加された

INT_LEAST64_WIDTH -- C++26対応として、C23標準ライブラリを追加 (#1657)

2026-06-08T20:56:08+09:00

diff --git a/reference/cstdint/int_least64_width.md b/reference/cstdint/int_least64_width.md
new file mode 100644
index 000000000..5de8d3e19
--- /dev/null
+++ b/reference/cstdint/int_least64_width.md
@@ -0,0 +1,48 @@
+# INT_LEAST64_WIDTH
+* cstdint[meta header]
+* macro[meta id-type]
+* cpp26[meta cpp]
+
+```cpp
+#define INT_LEAST64_WIDTH implementation-defined
+```
+
+## 概要
+[`int_least64_t`](int_least64_t.md)型の幅 (値ビット数) を表す。`#if`などのプリプロセッサディレクティブで使用できる。
+
+幅 (width) とは、その型が値の表現に使用するビット数であり、符号付き整数型では符号ビットを含む。パディングビットを含むストレージサイズ (`sizeof` × [`CHAR_BIT`](/reference/climits/char_bit.md)) とは異なる場合がある。
+
+C23で`<stdint.h>`に追加されたマクロであり、C++26で`<cstdint>`に取り込まれた。
+
+
+## 例
+```cpp example
+#include <cstdint>
+#include <iostream>
+
+int main()
+{
+  std::cout << INT_LEAST64_WIDTH << '\n';
+}
+```
+* INT_LEAST64_WIDTH[color ff0000]
+
+### 出力例
+```
+64
+```
+
+
+## バージョン
+### 言語
+- C++26
+
+### 処理系
+- [Clang](/implementation.md#clang): 23 [mark verified]
+- [GCC](/implementation.md#gcc): 17 [mark verified]
+- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl]
+
+
+## 参照
+- [P3348R4 C++26 should refer to C23 not C17](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3348r4.html)
+    - C++26がC23を参照するようになり、このマクロが`<cstdint>`に追加された

INT_LEAST8_WIDTH -- C++26対応として、C23標準ライブラリを追加 (#1657)

2026-06-08T20:56:08+09:00

diff --git a/reference/cstdint/int_least8_width.md b/reference/cstdint/int_least8_width.md
new file mode 100644
index 000000000..bfc63a84e
--- /dev/null
+++ b/reference/cstdint/int_least8_width.md
@@ -0,0 +1,48 @@
+# INT_LEAST8_WIDTH
+* cstdint[meta header]
+* macro[meta id-type]
+* cpp26[meta cpp]
+
+```cpp
+#define INT_LEAST8_WIDTH implementation-defined
+```
+
+## 概要
+[`int_least8_t`](int_least8_t.md)型の幅 (値ビット数) を表す。`#if`などのプリプロセッサディレクティブで使用できる。
+
+幅 (width) とは、その型が値の表現に使用するビット数であり、符号付き整数型では符号ビットを含む。パディングビットを含むストレージサイズ (`sizeof` × [`CHAR_BIT`](/reference/climits/char_bit.md)) とは異なる場合がある。
+
+C23で`<stdint.h>`に追加されたマクロであり、C++26で`<cstdint>`に取り込まれた。
+
+
+## 例
+```cpp example
+#include <cstdint>
+#include <iostream>
+
+int main()
+{
+  std::cout << INT_LEAST8_WIDTH << '\n';
+}
+```
+* INT_LEAST8_WIDTH[color ff0000]
+
+### 出力例
+```
+8
+```
+
+
+## バージョン
+### 言語
+- C++26
+
+### 処理系
+- [Clang](/implementation.md#clang): 23 [mark verified]
+- [GCC](/implementation.md#gcc): 17 [mark verified]
+- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl]
+
+
+## 参照
+- [P3348R4 C++26 should refer to C23 not C17](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3348r4.html)
+    - C++26がC23を参照するようになり、このマクロが`<cstdint>`に追加された

INTMAX_WIDTH -- C++26対応として、C23標準ライブラリを追加 (#1657)

2026-06-08T20:56:08+09:00

diff --git a/reference/cstdint/intmax_width.md b/reference/cstdint/intmax_width.md
new file mode 100644
index 000000000..a915baa24
--- /dev/null
+++ b/reference/cstdint/intmax_width.md
@@ -0,0 +1,48 @@
+# INTMAX_WIDTH
+* cstdint[meta header]
+* macro[meta id-type]
+* cpp26[meta cpp]
+
+```cpp
+#define INTMAX_WIDTH implementation-defined
+```
+
+## 概要
+[`intmax_t`](intmax_t.md)型の幅 (値ビット数) を表す。`#if`などのプリプロセッサディレクティブで使用できる。
+
+幅 (width) とは、その型が値の表現に使用するビット数であり、符号付き整数型では符号ビットを含む。パディングビットを含むストレージサイズ (`sizeof` × [`CHAR_BIT`](/reference/climits/char_bit.md)) とは異なる場合がある。
+
+C23で`<stdint.h>`に追加されたマクロであり、C++26で`<cstdint>`に取り込まれた。
+
+
+## 例
+```cpp example
+#include <cstdint>
+#include <iostream>
+
+int main()
+{
+  std::cout << INTMAX_WIDTH << '\n';
+}
+```
+* INTMAX_WIDTH[color ff0000]
+
+### 出力例
+```
+64
+```
+
+
+## バージョン
+### 言語
+- C++26
+
+### 処理系
+- [Clang](/implementation.md#clang): 23 [mark verified]
+- [GCC](/implementation.md#gcc): 17 [mark verified]
+- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl]
+
+
+## 参照
+- [P3348R4 C++26 should refer to C23 not C17](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3348r4.html)
+    - C++26がC23を参照するようになり、このマクロが`<cstdint>`に追加された

INTPTR_WIDTH -- C++26対応として、C23標準ライブラリを追加 (#1657)

2026-06-08T20:56:08+09:00

diff --git a/reference/cstdint/intptr_width.md b/reference/cstdint/intptr_width.md
new file mode 100644
index 000000000..1b41d1ac2
--- /dev/null
+++ b/reference/cstdint/intptr_width.md
@@ -0,0 +1,48 @@
+# INTPTR_WIDTH
+* cstdint[meta header]
+* macro[meta id-type]
+* cpp26[meta cpp]
+
+```cpp
+#define INTPTR_WIDTH implementation-defined
+```
+
+## 概要
+[`intptr_t`](intptr_t.md)型の幅 (値ビット数) を表す(実装するかどうかは処理系定義)。`#if`などのプリプロセッサディレクティブで使用できる。
+
+幅 (width) とは、その型が値の表現に使用するビット数であり、符号付き整数型では符号ビットを含む。パディングビットを含むストレージサイズ (`sizeof` × [`CHAR_BIT`](/reference/climits/char_bit.md)) とは異なる場合がある。
+
+C23で`<stdint.h>`に追加されたマクロであり、C++26で`<cstdint>`に取り込まれた。
+
+
+## 例
+```cpp example
+#include <cstdint>
+#include <iostream>
+
+int main()
+{
+  std::cout << INTPTR_WIDTH << '\n';
+}
+```
+* INTPTR_WIDTH[color ff0000]
+
+### 出力例
+```
+64
+```
+
+
+## バージョン
+### 言語
+- C++26
+
+### 処理系
+- [Clang](/implementation.md#clang): 23 [mark verified]
+- [GCC](/implementation.md#gcc): 17 [mark verified]
+- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl]
+
+
+## 参照
+- [P3348R4 C++26 should refer to C23 not C17](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3348r4.html)
+    - C++26がC23を参照するようになり、このマクロが`<cstdint>`に追加された

PTRDIFF_WIDTH -- C++26対応として、C23標準ライブラリを追加 (#1657)

2026-06-08T20:56:08+09:00

diff --git a/reference/cstdint/ptrdiff_width.md b/reference/cstdint/ptrdiff_width.md
new file mode 100644
index 000000000..9a07303d8
--- /dev/null
+++ b/reference/cstdint/ptrdiff_width.md
@@ -0,0 +1,48 @@
+# PTRDIFF_WIDTH
+* cstdint[meta header]
+* macro[meta id-type]
+* cpp26[meta cpp]
+
+```cpp
+#define PTRDIFF_WIDTH implementation-defined
+```
+
+## 概要
+[`ptrdiff_t`](/reference/cstddef/ptrdiff_t.md)型の幅 (値ビット数) を表す。`#if`などのプリプロセッサディレクティブで使用できる。
+
+幅 (width) とは、その型が値の表現に使用するビット数であり、符号付き整数型では符号ビットを含む。パディングビットを含むストレージサイズ (`sizeof` × [`CHAR_BIT`](/reference/climits/char_bit.md)) とは異なる場合がある。
+
+C23で`<stdint.h>`に追加されたマクロであり、C++26で`<cstdint>`に取り込まれた。
+
+
+## 例
+```cpp example
+#include <cstdint>
+#include <iostream>
+
+int main()
+{
+  std::cout << PTRDIFF_WIDTH << '\n';
+}
+```
+* PTRDIFF_WIDTH[color ff0000]
+
+### 出力例
+```
+64
+```
+
+
+## バージョン
+### 言語
+- C++26
+
+### 処理系
+- [Clang](/implementation.md#clang): 23 [mark verified]
+- [GCC](/implementation.md#gcc): 17 [mark verified]
+- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl]
+
+
+## 参照
+- [P3348R4 C++26 should refer to C23 not C17](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3348r4.html)
+    - C++26がC23を参照するようになり、このマクロが`<cstdint>`に追加された

SIG_ATOMIC_WIDTH -- C++26対応として、C23標準ライブラリを追加 (#1657)

2026-06-08T20:56:08+09:00

diff --git a/reference/cstdint/sig_atomic_width.md b/reference/cstdint/sig_atomic_width.md
new file mode 100644
index 000000000..f2d3d1749
--- /dev/null
+++ b/reference/cstdint/sig_atomic_width.md
@@ -0,0 +1,48 @@
+# SIG_ATOMIC_WIDTH
+* cstdint[meta header]
+* macro[meta id-type]
+* cpp26[meta cpp]
+
+```cpp
+#define SIG_ATOMIC_WIDTH implementation-defined
+```
+
+## 概要
+`sig_atomic_t`型の幅 (値ビット数) を表す。`#if`などのプリプロセッサディレクティブで使用できる。
+
+幅 (width) とは、その型が値の表現に使用するビット数であり、符号付き整数型では符号ビットを含む。パディングビットを含むストレージサイズ (`sizeof` × [`CHAR_BIT`](/reference/climits/char_bit.md)) とは異なる場合がある。
+
+C23で`<stdint.h>`に追加されたマクロであり、C++26で`<cstdint>`に取り込まれた。
+
+
+## 例
+```cpp example
+#include <cstdint>
+#include <iostream>
+
+int main()
+{
+  std::cout << SIG_ATOMIC_WIDTH << '\n';
+}
+```
+* SIG_ATOMIC_WIDTH[color ff0000]
+
+### 出力例
+```
+32
+```
+
+
+## バージョン
+### 言語
+- C++26
+
+### 処理系
+- [Clang](/implementation.md#clang): 23 [mark verified]
+- [GCC](/implementation.md#gcc): 17 [mark verified]
+- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl]
+
+
+## 参照
+- [P3348R4 C++26 should refer to C23 not C17](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3348r4.html)
+    - C++26がC23を参照するようになり、このマクロが`<cstdint>`に追加された

SIZE_WIDTH -- C++26対応として、C23標準ライブラリを追加 (#1657)

2026-06-08T20:56:08+09:00

diff --git a/reference/cstdint/size_width.md b/reference/cstdint/size_width.md
new file mode 100644
index 000000000..b61127fb8
--- /dev/null
+++ b/reference/cstdint/size_width.md
@@ -0,0 +1,48 @@
+# SIZE_WIDTH
+* cstdint[meta header]
+* macro[meta id-type]
+* cpp26[meta cpp]
+
+```cpp
+#define SIZE_WIDTH implementation-defined
+```
+
+## 概要
+[`size_t`](/reference/cstddef/size_t.md)型の幅 (値ビット数) を表す。`#if`などのプリプロセッサディレクティブで使用できる。
+
+幅 (width) とは、その型が値の表現に使用するビット数であり、符号付き整数型では符号ビットを含む。パディングビットを含むストレージサイズ (`sizeof` × [`CHAR_BIT`](/reference/climits/char_bit.md)) とは異なる場合がある。
+
+C23で`<stdint.h>`に追加されたマクロであり、C++26で`<cstdint>`に取り込まれた。
+
+
+## 例
+```cpp example
+#include <cstdint>
+#include <iostream>
+
+int main()
+{
+  std::cout << SIZE_WIDTH << '\n';
+}
+```
+* SIZE_WIDTH[color ff0000]
+
+### 出力例
+```
+64
+```
+
+
+## バージョン
+### 言語
+- C++26
+
+### 処理系
+- [Clang](/implementation.md#clang): 23 [mark verified]
+- [GCC](/implementation.md#gcc): 17 [mark verified]
+- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl]
+
+
+## 参照
+- [P3348R4 C++26 should refer to C23 not C17](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3348r4.html)
+    - C++26がC23を参照するようになり、このマクロが`<cstdint>`に追加された

UINT16_WIDTH -- C++26対応として、C23標準ライブラリを追加 (#1657)

2026-06-08T20:56:08+09:00

diff --git a/reference/cstdint/uint16_width.md b/reference/cstdint/uint16_width.md
new file mode 100644
index 000000000..8c491beaf
--- /dev/null
+++ b/reference/cstdint/uint16_width.md
@@ -0,0 +1,48 @@
+# UINT16_WIDTH
+* cstdint[meta header]
+* macro[meta id-type]
+* cpp26[meta cpp]
+
+```cpp
+#define UINT16_WIDTH implementation-defined
+```
+
+## 概要
+[`uint16_t`](uint16_t.md)型の幅 (値ビット数) を表す(実装するかどうかは処理系定義)。`#if`などのプリプロセッサディレクティブで使用できる。
+
+幅 (width) とは、その型が値の表現に使用するビット数であり、符号付き整数型では符号ビットを含む。パディングビットを含むストレージサイズ (`sizeof` × [`CHAR_BIT`](/reference/climits/char_bit.md)) とは異なる場合がある。
+
+C23で`<stdint.h>`に追加されたマクロであり、C++26で`<cstdint>`に取り込まれた。
+
+
+## 例
+```cpp example
+#include <cstdint>
+#include <iostream>
+
+int main()
+{
+  std::cout << UINT16_WIDTH << '\n';
+}
+```
+* UINT16_WIDTH[color ff0000]
+
+### 出力例
+```
+16
+```
+
+
+## バージョン
+### 言語
+- C++26
+
+### 処理系
+- [Clang](/implementation.md#clang): 23 [mark verified]
+- [GCC](/implementation.md#gcc): 17 [mark verified]
+- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl]
+
+
+## 参照
+- [P3348R4 C++26 should refer to C23 not C17](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3348r4.html)
+    - C++26がC23を参照するようになり、このマクロが`<cstdint>`に追加された

UINT32_WIDTH -- C++26対応として、C23標準ライブラリを追加 (#1657)

2026-06-08T20:56:08+09:00

diff --git a/reference/cstdint/uint32_width.md b/reference/cstdint/uint32_width.md
new file mode 100644
index 000000000..1642cdd05
--- /dev/null
+++ b/reference/cstdint/uint32_width.md
@@ -0,0 +1,48 @@
+# UINT32_WIDTH
+* cstdint[meta header]
+* macro[meta id-type]
+* cpp26[meta cpp]
+
+```cpp
+#define UINT32_WIDTH implementation-defined
+```
+
+## 概要
+[`uint32_t`](uint32_t.md)型の幅 (値ビット数) を表す(実装するかどうかは処理系定義)。`#if`などのプリプロセッサディレクティブで使用できる。
+
+幅 (width) とは、その型が値の表現に使用するビット数であり、符号付き整数型では符号ビットを含む。パディングビットを含むストレージサイズ (`sizeof` × [`CHAR_BIT`](/reference/climits/char_bit.md)) とは異なる場合がある。
+
+C23で`<stdint.h>`に追加されたマクロであり、C++26で`<cstdint>`に取り込まれた。
+
+
+## 例
+```cpp example
+#include <cstdint>
+#include <iostream>
+
+int main()
+{
+  std::cout << UINT32_WIDTH << '\n';
+}
+```
+* UINT32_WIDTH[color ff0000]
+
+### 出力例
+```
+32
+```
+
+
+## バージョン
+### 言語
+- C++26
+
+### 処理系
+- [Clang](/implementation.md#clang): 23 [mark verified]
+- [GCC](/implementation.md#gcc): 17 [mark verified]
+- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl]
+
+
+## 参照
+- [P3348R4 C++26 should refer to C23 not C17](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3348r4.html)
+    - C++26がC23を参照するようになり、このマクロが`<cstdint>`に追加された

UINT64_WIDTH -- C++26対応として、C23標準ライブラリを追加 (#1657)

2026-06-08T20:56:08+09:00

diff --git a/reference/cstdint/uint64_width.md b/reference/cstdint/uint64_width.md
new file mode 100644
index 000000000..35444eaf8
--- /dev/null
+++ b/reference/cstdint/uint64_width.md
@@ -0,0 +1,48 @@
+# UINT64_WIDTH
+* cstdint[meta header]
+* macro[meta id-type]
+* cpp26[meta cpp]
+
+```cpp
+#define UINT64_WIDTH implementation-defined
+```
+
+## 概要
+[`uint64_t`](uint64_t.md)型の幅 (値ビット数) を表す(実装するかどうかは処理系定義)。`#if`などのプリプロセッサディレクティブで使用できる。
+
+幅 (width) とは、その型が値の表現に使用するビット数であり、符号付き整数型では符号ビットを含む。パディングビットを含むストレージサイズ (`sizeof` × [`CHAR_BIT`](/reference/climits/char_bit.md)) とは異なる場合がある。
+
+C23で`<stdint.h>`に追加されたマクロであり、C++26で`<cstdint>`に取り込まれた。
+
+
+## 例
+```cpp example
+#include <cstdint>
+#include <iostream>
+
+int main()
+{
+  std::cout << UINT64_WIDTH << '\n';
+}
+```
+* UINT64_WIDTH[color ff0000]
+
+### 出力例
+```
+64
+```
+
+
+## バージョン
+### 言語
+- C++26
+
+### 処理系
+- [Clang](/implementation.md#clang): 23 [mark verified]
+- [GCC](/implementation.md#gcc): 17 [mark verified]
+- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl]
+
+
+## 参照
+- [P3348R4 C++26 should refer to C23 not C17](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3348r4.html)
+    - C++26がC23を参照するようになり、このマクロが`<cstdint>`に追加された

UINT8_WIDTH -- C++26対応として、C23標準ライブラリを追加 (#1657)

2026-06-08T20:56:08+09:00

diff --git a/reference/cstdint/uint8_width.md b/reference/cstdint/uint8_width.md
new file mode 100644
index 000000000..da758dd7f
--- /dev/null
+++ b/reference/cstdint/uint8_width.md
@@ -0,0 +1,48 @@
+# UINT8_WIDTH
+* cstdint[meta header]
+* macro[meta id-type]
+* cpp26[meta cpp]
+
+```cpp
+#define UINT8_WIDTH implementation-defined
+```
+
+## 概要
+[`uint8_t`](uint8_t.md)型の幅 (値ビット数) を表す(実装するかどうかは処理系定義)。`#if`などのプリプロセッサディレクティブで使用できる。
+
+幅 (width) とは、その型が値の表現に使用するビット数であり、符号付き整数型では符号ビットを含む。パディングビットを含むストレージサイズ (`sizeof` × [`CHAR_BIT`](/reference/climits/char_bit.md)) とは異なる場合がある。
+
+C23で`<stdint.h>`に追加されたマクロであり、C++26で`<cstdint>`に取り込まれた。
+
+
+## 例
+```cpp example
+#include <cstdint>
+#include <iostream>
+
+int main()
+{
+  std::cout << UINT8_WIDTH << '\n';
+}
+```
+* UINT8_WIDTH[color ff0000]
+
+### 出力例
+```
+8
+```
+
+
+## バージョン
+### 言語
+- C++26
+
+### 処理系
+- [Clang](/implementation.md#clang): 23 [mark verified]
+- [GCC](/implementation.md#gcc): 17 [mark verified]
+- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl]
+
+
+## 参照
+- [P3348R4 C++26 should refer to C23 not C17](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3348r4.html)
+    - C++26がC23を参照するようになり、このマクロが`<cstdint>`に追加された

UINT_FAST16_WIDTH -- C++26対応として、C23標準ライブラリを追加 (#1657)

2026-06-08T20:56:08+09:00

diff --git a/reference/cstdint/uint_fast16_width.md b/reference/cstdint/uint_fast16_width.md
new file mode 100644
index 000000000..23a52fa2f
--- /dev/null
+++ b/reference/cstdint/uint_fast16_width.md
@@ -0,0 +1,48 @@
+# UINT_FAST16_WIDTH
+* cstdint[meta header]
+* macro[meta id-type]
+* cpp26[meta cpp]
+
+```cpp
+#define UINT_FAST16_WIDTH implementation-defined
+```
+
+## 概要
+[`uint_fast16_t`](uint_fast16_t.md)型の幅 (値ビット数) を表す。`#if`などのプリプロセッサディレクティブで使用できる。
+
+幅 (width) とは、その型が値の表現に使用するビット数であり、符号付き整数型では符号ビットを含む。パディングビットを含むストレージサイズ (`sizeof` × [`CHAR_BIT`](/reference/climits/char_bit.md)) とは異なる場合がある。
+
+C23で`<stdint.h>`に追加されたマクロであり、C++26で`<cstdint>`に取り込まれた。
+
+
+## 例
+```cpp example
+#include <cstdint>
+#include <iostream>
+
+int main()
+{
+  std::cout << UINT_FAST16_WIDTH << '\n';
+}
+```
+* UINT_FAST16_WIDTH[color ff0000]
+
+### 出力例
+```
+16
+```
+
+
+## バージョン
+### 言語
+- C++26
+
+### 処理系
+- [Clang](/implementation.md#clang): 23 [mark verified]
+- [GCC](/implementation.md#gcc): 17 [mark verified]
+- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl]
+
+
+## 参照
+- [P3348R4 C++26 should refer to C23 not C17](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3348r4.html)
+    - C++26がC23を参照するようになり、このマクロが`<cstdint>`に追加された

UINT_FAST32_WIDTH -- C++26対応として、C23標準ライブラリを追加 (#1657)

2026-06-08T20:56:08+09:00

diff --git a/reference/cstdint/uint_fast32_width.md b/reference/cstdint/uint_fast32_width.md
new file mode 100644
index 000000000..f5e36f756
--- /dev/null
+++ b/reference/cstdint/uint_fast32_width.md
@@ -0,0 +1,48 @@
+# UINT_FAST32_WIDTH
+* cstdint[meta header]
+* macro[meta id-type]
+* cpp26[meta cpp]
+
+```cpp
+#define UINT_FAST32_WIDTH implementation-defined
+```
+
+## 概要
+[`uint_fast32_t`](uint_fast32_t.md)型の幅 (値ビット数) を表す。`#if`などのプリプロセッサディレクティブで使用できる。
+
+幅 (width) とは、その型が値の表現に使用するビット数であり、符号付き整数型では符号ビットを含む。パディングビットを含むストレージサイズ (`sizeof` × [`CHAR_BIT`](/reference/climits/char_bit.md)) とは異なる場合がある。
+
+C23で`<stdint.h>`に追加されたマクロであり、C++26で`<cstdint>`に取り込まれた。
+
+
+## 例
+```cpp example
+#include <cstdint>
+#include <iostream>
+
+int main()
+{
+  std::cout << UINT_FAST32_WIDTH << '\n';
+}
+```
+* UINT_FAST32_WIDTH[color ff0000]
+
+### 出力例
+```
+32
+```
+
+
+## バージョン
+### 言語
+- C++26
+
+### 処理系
+- [Clang](/implementation.md#clang): 23 [mark verified]
+- [GCC](/implementation.md#gcc): 17 [mark verified]
+- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl]
+
+
+## 参照
+- [P3348R4 C++26 should refer to C23 not C17](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3348r4.html)
+    - C++26がC23を参照するようになり、このマクロが`<cstdint>`に追加された

UINT_FAST64_WIDTH -- C++26対応として、C23標準ライブラリを追加 (#1657)

2026-06-08T20:56:08+09:00

diff --git a/reference/cstdint/uint_fast64_width.md b/reference/cstdint/uint_fast64_width.md
new file mode 100644
index 000000000..5c41f0093
--- /dev/null
+++ b/reference/cstdint/uint_fast64_width.md
@@ -0,0 +1,48 @@
+# UINT_FAST64_WIDTH
+* cstdint[meta header]
+* macro[meta id-type]
+* cpp26[meta cpp]
+
+```cpp
+#define UINT_FAST64_WIDTH implementation-defined
+```
+
+## 概要
+[`uint_fast64_t`](uint_fast64_t.md)型の幅 (値ビット数) を表す。`#if`などのプリプロセッサディレクティブで使用できる。
+
+幅 (width) とは、その型が値の表現に使用するビット数であり、符号付き整数型では符号ビットを含む。パディングビットを含むストレージサイズ (`sizeof` × [`CHAR_BIT`](/reference/climits/char_bit.md)) とは異なる場合がある。
+
+C23で`<stdint.h>`に追加されたマクロであり、C++26で`<cstdint>`に取り込まれた。
+
+
+## 例
+```cpp example
+#include <cstdint>
+#include <iostream>
+
+int main()
+{
+  std::cout << UINT_FAST64_WIDTH << '\n';
+}
+```
+* UINT_FAST64_WIDTH[color ff0000]
+
+### 出力例
+```
+64
+```
+
+
+## バージョン
+### 言語
+- C++26
+
+### 処理系
+- [Clang](/implementation.md#clang): 23 [mark verified]
+- [GCC](/implementation.md#gcc): 17 [mark verified]
+- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl]
+
+
+## 参照
+- [P3348R4 C++26 should refer to C23 not C17](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3348r4.html)
+    - C++26がC23を参照するようになり、このマクロが`<cstdint>`に追加された

UINT_FAST8_WIDTH -- C++26対応として、C23標準ライブラリを追加 (#1657)

2026-06-08T20:56:08+09:00

diff --git a/reference/cstdint/uint_fast8_width.md b/reference/cstdint/uint_fast8_width.md
new file mode 100644
index 000000000..2989a7e7c
--- /dev/null
+++ b/reference/cstdint/uint_fast8_width.md
@@ -0,0 +1,48 @@
+# UINT_FAST8_WIDTH
+* cstdint[meta header]
+* macro[meta id-type]
+* cpp26[meta cpp]
+
+```cpp
+#define UINT_FAST8_WIDTH implementation-defined
+```
+
+## 概要
+[`uint_fast8_t`](uint_fast8_t.md)型の幅 (値ビット数) を表す。`#if`などのプリプロセッサディレクティブで使用できる。
+
+幅 (width) とは、その型が値の表現に使用するビット数であり、符号付き整数型では符号ビットを含む。パディングビットを含むストレージサイズ (`sizeof` × [`CHAR_BIT`](/reference/climits/char_bit.md)) とは異なる場合がある。
+
+C23で`<stdint.h>`に追加されたマクロであり、C++26で`<cstdint>`に取り込まれた。
+
+
+## 例
+```cpp example
+#include <cstdint>
+#include <iostream>
+
+int main()
+{
+  std::cout << UINT_FAST8_WIDTH << '\n';
+}
+```
+* UINT_FAST8_WIDTH[color ff0000]
+
+### 出力例
+```
+8
+```
+
+
+## バージョン
+### 言語
+- C++26
+
+### 処理系
+- [Clang](/implementation.md#clang): 23 [mark verified]
+- [GCC](/implementation.md#gcc): 17 [mark verified]
+- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl]
+
+
+## 参照
+- [P3348R4 C++26 should refer to C23 not C17](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3348r4.html)
+    - C++26がC23を参照するようになり、このマクロが`<cstdint>`に追加された

UINT_LEAST16_WIDTH -- C++26対応として、C23標準ライブラリを追加 (#1657)

2026-06-08T20:56:08+09:00

diff --git a/reference/cstdint/uint_least16_width.md b/reference/cstdint/uint_least16_width.md
new file mode 100644
index 000000000..781a9e352
--- /dev/null
+++ b/reference/cstdint/uint_least16_width.md
@@ -0,0 +1,48 @@
+# UINT_LEAST16_WIDTH
+* cstdint[meta header]
+* macro[meta id-type]
+* cpp26[meta cpp]
+
+```cpp
+#define UINT_LEAST16_WIDTH implementation-defined
+```
+
+## 概要
+[`uint_least16_t`](uint_least16_t.md)型の幅 (値ビット数) を表す。`#if`などのプリプロセッサディレクティブで使用できる。
+
+幅 (width) とは、その型が値の表現に使用するビット数であり、符号付き整数型では符号ビットを含む。パディングビットを含むストレージサイズ (`sizeof` × [`CHAR_BIT`](/reference/climits/char_bit.md)) とは異なる場合がある。
+
+C23で`<stdint.h>`に追加されたマクロであり、C++26で`<cstdint>`に取り込まれた。
+
+
+## 例
+```cpp example
+#include <cstdint>
+#include <iostream>
+
+int main()
+{
+  std::cout << UINT_LEAST16_WIDTH << '\n';
+}
+```
+* UINT_LEAST16_WIDTH[color ff0000]
+
+### 出力例
+```
+16
+```
+
+
+## バージョン
+### 言語
+- C++26
+
+### 処理系
+- [Clang](/implementation.md#clang): 23 [mark verified]
+- [GCC](/implementation.md#gcc): 17 [mark verified]
+- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl]
+
+
+## 参照
+- [P3348R4 C++26 should refer to C23 not C17](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3348r4.html)
+    - C++26がC23を参照するようになり、このマクロが`<cstdint>`に追加された

UINT_LEAST32_WIDTH -- C++26対応として、C23標準ライブラリを追加 (#1657)

2026-06-08T20:56:08+09:00

diff --git a/reference/cstdint/uint_least32_width.md b/reference/cstdint/uint_least32_width.md
new file mode 100644
index 000000000..ab2527ccc
--- /dev/null
+++ b/reference/cstdint/uint_least32_width.md
@@ -0,0 +1,48 @@
+# UINT_LEAST32_WIDTH
+* cstdint[meta header]
+* macro[meta id-type]
+* cpp26[meta cpp]
+
+```cpp
+#define UINT_LEAST32_WIDTH implementation-defined
+```
+
+## 概要
+[`uint_least32_t`](uint_least32_t.md)型の幅 (値ビット数) を表す。`#if`などのプリプロセッサディレクティブで使用できる。
+
+幅 (width) とは、その型が値の表現に使用するビット数であり、符号付き整数型では符号ビットを含む。パディングビットを含むストレージサイズ (`sizeof` × [`CHAR_BIT`](/reference/climits/char_bit.md)) とは異なる場合がある。
+
+C23で`<stdint.h>`に追加されたマクロであり、C++26で`<cstdint>`に取り込まれた。
+
+
+## 例
+```cpp example
+#include <cstdint>
+#include <iostream>
+
+int main()
+{
+  std::cout << UINT_LEAST32_WIDTH << '\n';
+}
+```
+* UINT_LEAST32_WIDTH[color ff0000]
+
+### 出力例
+```
+32
+```
+
+
+## バージョン
+### 言語
+- C++26
+
+### 処理系
+- [Clang](/implementation.md#clang): 23 [mark verified]
+- [GCC](/implementation.md#gcc): 17 [mark verified]
+- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl]
+
+
+## 参照
+- [P3348R4 C++26 should refer to C23 not C17](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3348r4.html)
+    - C++26がC23を参照するようになり、このマクロが`<cstdint>`に追加された

UINT_LEAST64_WIDTH -- C++26対応として、C23標準ライブラリを追加 (#1657)

2026-06-08T20:56:08+09:00

diff --git a/reference/cstdint/uint_least64_width.md b/reference/cstdint/uint_least64_width.md
new file mode 100644
index 000000000..45b90d3f4
--- /dev/null
+++ b/reference/cstdint/uint_least64_width.md
@@ -0,0 +1,48 @@
+# UINT_LEAST64_WIDTH
+* cstdint[meta header]
+* macro[meta id-type]
+* cpp26[meta cpp]
+
+```cpp
+#define UINT_LEAST64_WIDTH implementation-defined
+```
+
+## 概要
+[`uint_least64_t`](uint_least64_t.md)型の幅 (値ビット数) を表す。`#if`などのプリプロセッサディレクティブで使用できる。
+
+幅 (width) とは、その型が値の表現に使用するビット数であり、符号付き整数型では符号ビットを含む。パディングビットを含むストレージサイズ (`sizeof` × [`CHAR_BIT`](/reference/climits/char_bit.md)) とは異なる場合がある。
+
+C23で`<stdint.h>`に追加されたマクロであり、C++26で`<cstdint>`に取り込まれた。
+
+
+## 例
+```cpp example
+#include <cstdint>
+#include <iostream>
+
+int main()
+{
+  std::cout << UINT_LEAST64_WIDTH << '\n';
+}
+```
+* UINT_LEAST64_WIDTH[color ff0000]
+
+### 出力例
+```
+64
+```
+
+
+## バージョン
+### 言語
+- C++26
+
+### 処理系
+- [Clang](/implementation.md#clang): 23 [mark verified]
+- [GCC](/implementation.md#gcc): 17 [mark verified]
+- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl]
+
+
+## 参照
+- [P3348R4 C++26 should refer to C23 not C17](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3348r4.html)
+    - C++26がC23を参照するようになり、このマクロが`<cstdint>`に追加された

UINT_LEAST8_WIDTH -- C++26対応として、C23標準ライブラリを追加 (#1657)

2026-06-08T20:56:08+09:00

diff --git a/reference/cstdint/uint_least8_width.md b/reference/cstdint/uint_least8_width.md
new file mode 100644
index 000000000..2a52d809f
--- /dev/null
+++ b/reference/cstdint/uint_least8_width.md
@@ -0,0 +1,48 @@
+# UINT_LEAST8_WIDTH
+* cstdint[meta header]
+* macro[meta id-type]
+* cpp26[meta cpp]
+
+```cpp
+#define UINT_LEAST8_WIDTH implementation-defined
+```
+
+## 概要
+[`uint_least8_t`](uint_least8_t.md)型の幅 (値ビット数) を表す。`#if`などのプリプロセッサディレクティブで使用できる。
+
+幅 (width) とは、その型が値の表現に使用するビット数であり、符号付き整数型では符号ビットを含む。パディングビットを含むストレージサイズ (`sizeof` × [`CHAR_BIT`](/reference/climits/char_bit.md)) とは異なる場合がある。
+
+C23で`<stdint.h>`に追加されたマクロであり、C++26で`<cstdint>`に取り込まれた。
+
+
+## 例
+```cpp example
+#include <cstdint>
+#include <iostream>
+
+int main()
+{
+  std::cout << UINT_LEAST8_WIDTH << '\n';
+}
+```
+* UINT_LEAST8_WIDTH[color ff0000]
+
+### 出力例
+```
+8
+```
+
+
+## バージョン
+### 言語
+- C++26
+
+### 処理系
+- [Clang](/implementation.md#clang): 23 [mark verified]
+- [GCC](/implementation.md#gcc): 17 [mark verified]
+- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl]
+
+
+## 参照
+- [P3348R4 C++26 should refer to C23 not C17](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3348r4.html)
+    - C++26がC23を参照するようになり、このマクロが`<cstdint>`に追加された

UINTMAX_WIDTH -- C++26対応として、C23標準ライブラリを追加 (#1657)

2026-06-08T20:56:08+09:00

diff --git a/reference/cstdint/uintmax_width.md b/reference/cstdint/uintmax_width.md
new file mode 100644
index 000000000..b141bfeda
--- /dev/null
+++ b/reference/cstdint/uintmax_width.md
@@ -0,0 +1,48 @@
+# UINTMAX_WIDTH
+* cstdint[meta header]
+* macro[meta id-type]
+* cpp26[meta cpp]
+
+```cpp
+#define UINTMAX_WIDTH implementation-defined
+```
+
+## 概要
+[`uintmax_t`](uintmax_t.md)型の幅 (値ビット数) を表す。`#if`などのプリプロセッサディレクティブで使用できる。
+
+幅 (width) とは、その型が値の表現に使用するビット数であり、符号付き整数型では符号ビットを含む。パディングビットを含むストレージサイズ (`sizeof` × [`CHAR_BIT`](/reference/climits/char_bit.md)) とは異なる場合がある。
+
+C23で`<stdint.h>`に追加されたマクロであり、C++26で`<cstdint>`に取り込まれた。
+
+
+## 例
+```cpp example
+#include <cstdint>
+#include <iostream>
+
+int main()
+{
+  std::cout << UINTMAX_WIDTH << '\n';
+}
+```
+* UINTMAX_WIDTH[color ff0000]
+
+### 出力例
+```
+64
+```
+
+
+## バージョン
+### 言語
+- C++26
+
+### 処理系
+- [Clang](/implementation.md#clang): 23 [mark verified]
+- [GCC](/implementation.md#gcc): 17 [mark verified]
+- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl]
+
+
+## 参照
+- [P3348R4 C++26 should refer to C23 not C17](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3348r4.html)
+    - C++26がC23を参照するようになり、このマクロが`<cstdint>`に追加された

UINTPTR_WIDTH -- C++26対応として、C23標準ライブラリを追加 (#1657)

2026-06-08T20:56:08+09:00

diff --git a/reference/cstdint/uintptr_width.md b/reference/cstdint/uintptr_width.md
new file mode 100644
index 000000000..c61c211bd
--- /dev/null
+++ b/reference/cstdint/uintptr_width.md
@@ -0,0 +1,48 @@
+# UINTPTR_WIDTH
+* cstdint[meta header]
+* macro[meta id-type]
+* cpp26[meta cpp]
+
+```cpp
+#define UINTPTR_WIDTH implementation-defined
+```
+
+## 概要
+[`uintptr_t`](uintptr_t.md)型の幅 (値ビット数) を表す(実装するかどうかは処理系定義)。`#if`などのプリプロセッサディレクティブで使用できる。
+
+幅 (width) とは、その型が値の表現に使用するビット数であり、符号付き整数型では符号ビットを含む。パディングビットを含むストレージサイズ (`sizeof` × [`CHAR_BIT`](/reference/climits/char_bit.md)) とは異なる場合がある。
+
+C23で`<stdint.h>`に追加されたマクロであり、C++26で`<cstdint>`に取り込まれた。
+
+
+## 例
+```cpp example
+#include <cstdint>
+#include <iostream>
+
+int main()
+{
+  std::cout << UINTPTR_WIDTH << '\n';
+}
+```
+* UINTPTR_WIDTH[color ff0000]
+
+### 出力例
+```
+64
+```
+
+
+## バージョン
+### 言語
+- C++26
+
+### 処理系
+- [Clang](/implementation.md#clang): 23 [mark verified]
+- [GCC](/implementation.md#gcc): 17 [mark verified]
+- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl]
+
+
+## 参照
+- [P3348R4 C++26 should refer to C23 not C17](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3348r4.html)
+    - C++26がC23を参照するようになり、このマクロが`<cstdint>`に追加された

WCHAR_WIDTH -- C++26対応として、C23標準ライブラリを追加 (#1657)

2026-06-08T20:56:08+09:00

diff --git a/reference/cstdint/wchar_width.md b/reference/cstdint/wchar_width.md
new file mode 100644
index 000000000..1ecdabb4c
--- /dev/null
+++ b/reference/cstdint/wchar_width.md
@@ -0,0 +1,48 @@
+# WCHAR_WIDTH
+* cstdint[meta header]
+* macro[meta id-type]
+* cpp26[meta cpp]
+
+```cpp
+#define WCHAR_WIDTH implementation-defined
+```
+
+## 概要
+`wchar_t`型の幅 (値ビット数) を表す。`#if`などのプリプロセッサディレクティブで使用できる。
+
+幅 (width) とは、その型が値の表現に使用するビット数であり、符号付き整数型では符号ビットを含む。パディングビットを含むストレージサイズ (`sizeof` × [`CHAR_BIT`](/reference/climits/char_bit.md)) とは異なる場合がある。
+
+C23で`<stdint.h>`に追加されたマクロであり、C++26で`<cstdint>`に取り込まれた。
+
+
+## 例
+```cpp example
+#include <cstdint>
+#include <iostream>
+
+int main()
+{
+  std::cout << WCHAR_WIDTH << '\n';
+}
+```
+* WCHAR_WIDTH[color ff0000]
+
+### 出力例
+```
+32
+```
+
+
+## バージョン
+### 言語
+- C++26
+
+### 処理系
+- [Clang](/implementation.md#clang): 23 [mark verified]
+- [GCC](/implementation.md#gcc): 17 [mark verified]
+- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl]
+
+
+## 参照
+- [P3348R4 C++26 should refer to C23 not C17](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3348r4.html)
+    - C++26がC23を参照するようになり、このマクロが`<cstdint>`に追加された

WINT_WIDTH -- C++26対応として、C23標準ライブラリを追加 (#1657)

2026-06-08T20:56:08+09:00

diff --git a/reference/cstdint/wint_width.md b/reference/cstdint/wint_width.md
new file mode 100644
index 000000000..dede07a7b
--- /dev/null
+++ b/reference/cstdint/wint_width.md
@@ -0,0 +1,48 @@
+# WINT_WIDTH
+* cstdint[meta header]
+* macro[meta id-type]
+* cpp26[meta cpp]
+
+```cpp
+#define WINT_WIDTH implementation-defined
+```
+
+## 概要
+`wint_t`型の幅 (値ビット数) を表す。`#if`などのプリプロセッサディレクティブで使用できる。
+
+幅 (width) とは、その型が値の表現に使用するビット数であり、符号付き整数型では符号ビットを含む。パディングビットを含むストレージサイズ (`sizeof` × [`CHAR_BIT`](/reference/climits/char_bit.md)) とは異なる場合がある。
+
+C23で`<stdint.h>`に追加されたマクロであり、C++26で`<cstdint>`に取り込まれた。
+
+
+## 例
+```cpp example
+#include <cstdint>
+#include <iostream>
+
+int main()
+{
+  std::cout << WINT_WIDTH << '\n';
+}
+```
+* WINT_WIDTH[color ff0000]
+
+### 出力例
+```
+32
+```
+
+
+## バージョン
+### 言語
+- C++26
+
+### 処理系
+- [Clang](/implementation.md#clang): 23 [mark verified]
+- [GCC](/implementation.md#gcc): 17 [mark verified]
+- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl]
+
+
+## 参照
+- [P3348R4 C++26 should refer to C23 not C17](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3348r4.html)
+    - C++26がC23を参照するようになり、このマクロが`<cstdint>`に追加された

cstdio -- C++26対応として、C23標準ライブラリを追加 (#1657)

2026-06-08T20:56:08+09:00

cstdio

<cstdio>ヘッダでは、標準入出力のための機能を定義する。これらの機能は、std名前空間に属することを除いてC言語の標準ライブラリ<stdio.h>ヘッダと同じである。

型

名前	説明	対応バージョン
`size_t`	符号なし整数型
`FILE`	ストリームの制御に必要な情報を持つオブジェクト型
`fpos_t`	ファイルの全ての位置にアクセスするための配列以外の完全オブジェクト型

マクロ

名前	説明	対応バージョン
`NULL`	ヌルポインタ定数に展開されるマクロ
`_IOFBF`	入出力を完全にバッファリングする指定のための整数定数
`_IOLBF`	入出力を行バッファリングする指定のための整数定数
`_IONBF`	入出力をバッファリングしない指定のための整数定数
`BUFSIZ`	バッファサイズを表す整数定数
`EOF`	ファイルの終端であることを表す`int`型の整数定数
`FOPEN_MAX`	実装によって保証されるファイルを開ける最低限の数を表す整数定数
`FILENAME_MAX`	実装によって保証されるファイル名の最大の長さを表す整数定数
`L_tmpnam`	`tmpnam()`関数によって作られた一時ファイル名を保持する似に必要な長さを表す整数定数
`SEEK_SET`	ファイルの先頭位置を指定するための整数定数
`SEEK_CUR`	ファイルの現在位置を指定するための整数定数
`SEEK_END`	ファイルの終端を指定するための整数定数
`TMP_MAX`	`tmpnam()`関数によって生成できる一時ファイル名の、実装が保証する最低限の数を表す整数定数
`_PRINTF_NAN_LEN_MAX`	`printf`系関数がNaNを出力する際の最大文字数を表す整数定数	C++26
`stderr`	標準エラーを表す`FILE*`型の式
`stdin`	標準入力を表す`FILE*`型の式
`stdout`	標準出力を表す`FILE*`型の式
`__STDC_VERSION_STDIO_H__`	`<cstdio>`が提供するC標準ライブラリ機能のバージョン (`202311L`)	C++26

ファイル操作

名前	説明	対応バージョン
`remove`	ファイルを削除する
`rename`	ファイル名を変更、ファイルを移動する
`tmpfile`	一時ファイルを生成する
`tmpnam`	一時ファイル名を生成する
`fclose`	ファイルを閉じる
`fopen`	ファイルを開く
`fflush`	ファイルをフラッシュする
`fprintf`	書式を指定してファイルに出力する
`fscanf`	書式を指定してファイルから入力する
`vfprintf`	可変引数リスト`va_list`を使用し、書式を指定してファイルに出力する
`vfscanf`	可変引数リスト`va_list`を使用し、書式を指定してファイルから入力する	C++17
`fgetc`	ファイルから1文字入力する
`fgets`	ファイルからN文字入力する
`fputc`	ファイルに1文字出力する
`fputs`	ファイルにN文字出力する
`fread`	ファイルからN文字読み込む
`fwrite`	ファイルにN文字書き込む
`fgetpos`	ファイルの現在位置を取得する
`fseek`	ファイルの現在位置を移動する
`fsetpos`	ファイルの現在位置を設定する
`ftell`	ファイルの現在位置を取得する
`rewind`	ファイルの現在位置を先頭に戻し、エラーや終端判定をクリアする
`clearerr`	エラーをクリアする
`feof`	ファイルが終端に到達したか判定する
`ferror`	ファイルストリームがエラー状態かを判定する
`perror`	システムエラーメッセージを出力する

標準入出力

名前	説明	対応バージョン
`printf`	書式を指定して標準出力に出力する
`scanf`	書式を指定して標準入力から入力する
`vprintf`	可変引数リスト`va_list`を使用し、書式を指定して標準出力に出力する
`vscanf`	可変引数リスト`va_list`を使用し、書式を指定して標準入力から入力する
`getc`	ストリームから1文字入力する
`getchar`	標準入力から1文字入力する
`putc`	ストリームに1文字出力する
`putchar`	標準出力に1文字出力する
`puts`	標準出力に文字列を出力する
`ungetc`	入力ストリームに1文字戻す

文字列入出力

名前	説明	対応バージョン
`snprintf`	書式と文字数を指定して、文字列領域に出力する
`sprintf`	書式を指定して文字列領域に出力する
`sscanf`	書式を指定して文字列領域から入力する
`vsnprintf`	可変引数リスト`va_list`を使用し、書式と文字数を指定して、文字列領域に出力する
`vsprintf`	可変引数リスト`va_list`を使用し、書式を指定して文字列領域に出力する
`vsscanf`	可変引数リスト`va_list`を使用し、書式を指定して文字列領域から入力する

バッファ操作

名前	説明	対応バージョン
`setbuf`	入出力用のバッファを設定する
`setvbuf`	戦略を指定して入出力用のバッファを設定する

参照

P0063R3 C++17 should refer to C11 instead of C99
P0175R1 Synopses for the C library
P3348R4 C++26 should refer to C23 not C17
- C++26がC23を参照するようになり、_PRINTF_NAN_LEN_MAXと__STDC_VERSION_STDIO_H__が追加された

_PRINTF_NAN_LEN_MAX -- C++26対応として、C23標準ライブラリを追加 (#1657)

2026-06-08T20:56:08+09:00

diff --git a/reference/cstdio/printf_nan_len_max.md b/reference/cstdio/printf_nan_len_max.md
new file mode 100644
index 000000000..a552ef067
--- /dev/null
+++ b/reference/cstdio/printf_nan_len_max.md
@@ -0,0 +1,58 @@
+# _PRINTF_NAN_LEN_MAX
+* cstdio[meta header]
+* macro[meta id-type]
+* cpp26[meta cpp]
+
+```cpp
+#define _PRINTF_NAN_LEN_MAX implementation-defined
+```
+
+## 概要
+`printf`系関数がNaN (非数) を出力する際に生成しうる、最大の文字数を表す整数定数。
+
+`%f`・`%e`・`%g`などの浮動小数点変換でNaNを出力する場合、処理系は`nan`や`nan(n-char-sequence)`形式の文字列を生成する。このマクロは、その文字列の最大長を表す。出力先バッファのサイズを決定する際に利用できる。
+
+C23で`<stdio.h>`に追加されたマクロであり、C++26で`<cstdio>`に取り込まれた。
+
+
+## 備考
+- 規格上、値は`3`以上であることが規定されている
+
+
+## 例
+```cpp example
+#include <cstdio>
+#include <cmath>
+
+int main()
+{
+  // NaNを出力するのに十分なバッファを確保する
+  char buf[_PRINTF_NAN_LEN_MAX + 1];
+
+  std::snprintf(buf, sizeof(buf), "%f", NAN);
+  std::printf("%s\n", buf);
+}
+```
+* _PRINTF_NAN_LEN_MAX[color ff0000]
+* std::snprintf[link /reference/cstdio/snprintf.md.nolink]
+* NAN[link /reference/cmath/nan.md]
+
+### 出力例
+```
+nan
+```
+
+
+## バージョン
+### 言語
+- C++26
+
+### 処理系
+- [Clang](/implementation.md#clang): 22 [mark noimpl]
+- [GCC](/implementation.md#gcc): 16.1 [mark noimpl]
+- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl]
+
+
+## 参照
+- [P3348R4 C++26 should refer to C23 not C17](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3348r4.html)
+    - C++26がC23を参照するようになり、このマクロが`<cstdio>`に追加された

cstdlib -- C++26対応として、C23標準ライブラリを追加 (#1657)

2026-06-08T20:56:08+09:00

cstdlib

<cstdlib>ヘッダでは、一般的なユーティリティの関数を定義する。これらの機能は基本的には、std名前空間に属することを除いてC言語の標準ライブラリ<stdlib.h>ヘッダと同じである。

本ヘッダはフリースタンディング環境でも提供される。フリースタンディング環境の場合、少なくともabort, atexit, at_quick_exit, exit, quick_exit関数がサポートされる。

ただし、一部の機能には、[[noreturn]]属性、noexceptキーワード、スレッドローカルストレージのような、C++特有の言語機能に関する規定がある。

数値変換

名前	説明	対応バージョン
`atoi`	文字列を`int`型に変換する (function)
`atol`	文字列を`long`型に変換する (function)
`atoll`	文字列を`long long`型に変換する (function)	C++11
`atof`	文字列を`double`型に変換する (function)
`strtol`	文字列を、基数を指定して`long`型に変換する (function)
`strtoll`	文字列を、基数を指定して`long long`型に変換する (function)	C++11
`strtoul`	文字列を、基数を指定して`unsigned long`型に変換する (function)
`strtoull`	文字列を、基数を指定して`unsigned long long`型に変換する (function)	C++11
`strtof`	文字列を、`float`型に変換する (function)
`strtod`	文字列を、`double`型に変換する (function)
`strtold`	文字列を、`long double`型に変換する (function)	C++11
`strfromf`	`float`型を文字列に変換する (function)	C++26
`strfromd`	`double`型を文字列に変換する (function)	C++26
`strfroml`	`long double`型を文字列に変換する (function)	C++26

擬似乱数

名前	説明	対応バージョン
`RAND_MAX`	`rand`関数によって生成される値域の最大値を表す整数値マクロ (macro)	C++14から非推奨
`srand`	`rand`関数によって生成される擬似乱数のシードを指定する (function)	C++14から非推奨
`rand`	`srand`で指定されたシードを元に、擬似乱数を生成する (function)	C++14から非推奨

メモリ管理

名前	説明	対応バージョン
`aligned_alloc`	指定したアライメントでメモリを確保する (function)	C++17
`malloc`	メモリを確保する (function)
`calloc`	メモリを確保し、領域をゼロ初期化する (function)
`realloc`	メモリを再確保する (function)
`free`	確保したメモリを解放する (function)
`free_sized`	確保時のサイズを指定して、確保したメモリを解放する (function)	C++26
`free_aligned_sized`	アライメントと確保時のサイズを指定して、確保したメモリを解放する (function)	C++26
`memalignment`	ポインタのアライメントを取得する (function)	C++26

プログラムの開始と終了

名前	説明	対応バージョン
`EXIT_FAILURE`	プログラムが異常終了したことを表す整数値マクロ (macro)
`EXIT_SUCCESS`	プログラムが正常終了したことを表す整数値マクロ (macro)
`abort`	プログラムを異常終了させる (function)
`_Exit`	後処理をせずに、プログラムを終了させる (function)	C++11
`exit`	プログラムを終了させる (function)
`atexit`	プログラムが通常の方法で終了するときに呼ばれる関数を登録する (function)
`quick_exit`	後処理をせずに、プログラムを終了させる (function)	C++11
`at_quick_exit`	`quick_exit`関数でプログラムが終了するときに呼ばれる関数を登録する (function)	C++11

環境

名前	説明	対応バージョン
`getenv`	環境変数を取得する (function)
`system`	システムコマンドを実行する (function)

検索と並び替え

名前	説明	対応バージョン
`bsearch`	二分探索を行う (function)	C++26で`const`版オーバーロードを追加
`qsort`	範囲の並べ替えを行う (function)

整数に対する算術関数

名前	説明	対応バージョン
`abs`	`int`の絶対値を取得する (function)
`labs`	`long`の絶対値を取得する (function)
`llabs`	`long long`の絶対値を取得する (function)	C++11
`div_t`	`div`関数の戻り値型 (class)
`div`	`int`の除算と剰余算を行う (function)
`ldiv_t`	`ldiv`関数の戻り値型 (class)
`ldiv`	`long`の除算と剰余算を行う (function)
`lldiv_t`	`lldiv`関数の戻り値型 (class)	C++11
`lldiv`	`long long`の除算と剰余算を行う (function)	C++11

マルチバイト文字とワイド文字の変換

名前	説明	対応バージョン
`MB_CUR_MAX`	マルチバイト文字列の最大サイズを表す整数値マクロ (macro)
`mblen`	マルチバイト文字の長さを取得する (function)
`mbtowc`	マルチバイト文字を、ワイド文字に変換する (function)
`wctomb`	ワイド文字を、マルチバイト文字に変換する (function)
`mbstowcs`	マルチバイト文字列を、ワイド文字列に変換する (function)
`wcstombs`	ワイド文字列を、マルチバイト文字列に変換する (function)

bsearch -- C++26対応として、C23標準ライブラリを追加 (#1657)

2026-06-08T20:56:08+09:00

diff --git a/reference/cstdlib/bsearch.md b/reference/cstdlib/bsearch.md
new file mode 100644
index 000000000..4aa62ba65
--- /dev/null
+++ b/reference/cstdlib/bsearch.md
@@ -0,0 +1,119 @@
+# bsearch
+* cstdlib[meta header]
+* std[meta namespace]
+* function[meta id-type]
+
+```cpp
+namespace std {
+  void*
+    bsearch(const void* key,
+            void* base,
+            size_t nmemb,
+            size_t size,
+            c-compare-pred* compar); // (1)
+  void*
+    bsearch(const void* key,
+            void* base,
+            size_t nmemb,
+            size_t size,
+            compare-pred* compar);   // (2)
+
+  const void*
+    bsearch(const void* key,
+            const void* base,
+            size_t nmemb,
+            size_t size,
+            c-compare-pred* compar); // (3) C++26
+  const void*
+    bsearch(const void* key,
+            const void* base,
+            size_t nmemb,
+            size_t size,
+            compare-pred* compar);   // (4) C++26
+}
+```
+* size_t[link /reference/cstddef/size_t.md]
+* c-compare-pred[italic]
+* compare-pred[italic]
+
+## 概要
+ソート済みの配列に対して二分探索を行う。
+
+`base`が指す`nmemb`個の要素 (各要素のサイズは`size`バイト) からなる配列を、比較関数`compar`を用いて二分探索し、`key`が指す値と一致する要素を検索する。
+
+説明用の型`c-compare-pred`・`compare-pred`は、それぞれ`extern "C"`・`extern "C++"`の言語リンケージを持つ比較関数`int(const void*, const void*)`へのポインタ型である。これにより、いずれの言語リンケージの比較関数も渡せる。
+
+
+## 戻り値
+一致する要素が見つかった場合、その要素へのポインタを返す。一致する要素が複数ある場合、いずれが返されるかは未規定である。
+
+一致する要素が見つからなかった場合、ヌルポインタを返す。
+
+- (1), (2) : `base`が指す配列の要素へのポインタを`void*`型で返す
+- (3), (4) : `base`が指す配列の要素へのポインタを`const void*`型で返す
+
+
+## 比較関数
+`compar`は、第1引数に`key`、第2引数に配列の要素を受け取り、以下を返す関数である。
+
+- `key`が要素より小さい場合 : 負の値
+- `key`が要素と等しい場合 : `0`
+- `key`が要素より大きい場合 : 正の値
+
+配列は、この比較関数の順序に従って昇順にソートされていなければならない。
+
+
+## 備考
+- C++26では、`const`修飾を保持するオーバーロード (3), (4) が追加された。これにより、`const`な配列を探索した結果として`const void*`が返るようになり、`const`な配列の要素を結果経由で書き換えてしまう不適切なコードを防げる
+    - 同時に、非`const`の配列を受け取る(1), (2)は引数`base`が`void*`となり、非`const`なポインタを返す
+
+
+## 例
+```cpp example
+#include <cstdlib>
+#include <iostream>
+
+int compare(const void* a, const void* b)
+{
+  int x = *static_cast<const int*>(a);
+  int y = *static_cast<const int*>(b);
+  return x - y;
+}
+
+int main()
+{
+  const int data[] = {1, 3, 5, 7, 9};
+  int key = 5;
+
+  // constな配列を探索すると、C++26ではconst int*が得られる
+  const int* p = static_cast<const int*>(
+    std::bsearch(&key, data, std::size(data), sizeof(int), compare));
+
+  if (p != nullptr) {
+    std::cout << "found: " << *p << std::endl;
+  }
+}
+```
+* std::bsearch[color ff0000]
+* std::size[link /reference/iterator/size.md]
+
+### 出力
+```
+found: 5
+```
+
+
+## バージョン
+### 言語
+- C++98
+- C++26: `const`を保持するオーバーロード (3), (4) を追加
+
+
+## 関連項目
+- `qsort`: 範囲の並べ替えを行う
+- [`std::lower_bound`](/reference/algorithm/lower_bound.md): ソート済み範囲から二分探索を行う
+
+
+## 参照
+- [P3348R4 C++26 should refer to C23 not C17](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3348r4.html)
+    - C++26で`const`を保持するオーバーロードが追加された

free_aligned_sized -- C++26対応として、C23標準ライブラリを追加 (#1657)

2026-06-08T20:56:08+09:00

diff --git a/reference/cstdlib/free_aligned_sized.md b/reference/cstdlib/free_aligned_sized.md
new file mode 100644
index 000000000..72437a505
--- /dev/null
+++ b/reference/cstdlib/free_aligned_sized.md
@@ -0,0 +1,76 @@
+# free_aligned_sized
+* cstdlib[meta header]
+* std[meta namespace]
+* function[meta id-type]
+* cpp26[meta cpp]
+
+```cpp
+namespace std {
+  void free_aligned_sized(void* ptr, size_t alignment, size_t size);
+}
+```
+* size_t[link /reference/cstddef/size_t.md]
+
+## 概要
+アライメントと確保時のサイズを指定して、確保したメモリを解放する。
+
+C23で`<stdlib.h>`に追加された関数であり、C++26で`<cstdlib>`に取り込まれた。
+
+
+## 事前条件
+- `ptr`がヌルポインタであるか、もしくは[`aligned_alloc()`](aligned_alloc.md)が返したポインタであること
+- `ptr`がヌルポインタでない場合、`alignment`はそのメモリの確保時に指定したアライメントと等しく、`size`は確保時に要求したサイズと等しいこと
+
+
+## 効果
+- `ptr`がヌルポインタの場合、なにもしない
+- そうでない場合、[`free()`](free.md)`(ptr)`と等価である
+
+
+## 戻り値
+なし
+
+
+## 備考
+- この関数はスレッドセーフである
+- アライメントと確保時のサイズを処理系に渡せるため、[`free()`](free.md)よりも効率的に解放できる可能性がある
+
+
+## 例
+```cpp example
+#include <cstdlib>
+
+int main()
+{
+  // 64バイトアライメントで、256バイトの領域を確保する
+  void* p = std::aligned_alloc(64, 256);
+  std::free_aligned_sized(p, 64, 256);
+}
+```
+* std::free_aligned_sized[color ff0000]
+* std::aligned_alloc[link aligned_alloc.md]
+
+### 出力
+```
+```
+
+
+## バージョン
+### 言語
+- C++26
+
+### 処理系
+- [Clang](/implementation.md#clang): 22 [mark noimpl]
+- [GCC](/implementation.md#gcc): 16.1 [mark noimpl]
+- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl]
+
+
+## 関連項目
+- [`free()`](free.md): 確保したメモリを解放する
+- [`free_sized()`](free_sized.md): 確保時のサイズを指定して、確保したメモリを解放する
+- [`aligned_alloc()`](aligned_alloc.md): 指定したアライメントでメモリを確保する
+
+
+## 参照
+- [P3348R4 C++26 should refer to C23 not C17](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3348r4.html)
+    - C++26がC23を参照するようになり、この関数が`<cstdlib>`に追加された

free_sized -- C++26対応として、C23標準ライブラリを追加 (#1657)

2026-06-08T20:56:08+09:00

diff --git a/reference/cstdlib/free_sized.md b/reference/cstdlib/free_sized.md
new file mode 100644
index 000000000..3d38f3b0b
--- /dev/null
+++ b/reference/cstdlib/free_sized.md
@@ -0,0 +1,75 @@
+# free_sized
+* cstdlib[meta header]
+* std[meta namespace]
+* function[meta id-type]
+* cpp26[meta cpp]
+
+```cpp
+namespace std {
+  void free_sized(void* ptr, size_t size);
+}
+```
+* size_t[link /reference/cstddef/size_t.md]
+
+## 概要
+確保時のサイズを指定して、確保したメモリを解放する。
+
+C23で`<stdlib.h>`に追加された関数であり、C++26で`<cstdlib>`に取り込まれた。
+
+
+## 事前条件
+- `ptr`がヌルポインタであるか、もしくは[`malloc()`](malloc.md)・[`calloc()`](calloc.md)・[`realloc()`](realloc.md)などアライメントを指定せずにメモリを確保する関数が返したポインタであること
+- `ptr`がヌルポインタでない場合、`size`はそのメモリの確保時に要求したサイズと等しいこと
+
+
+## 効果
+- `ptr`がヌルポインタの場合、なにもしない
+- そうでない場合、[`free()`](free.md)`(ptr)`と等価である
+
+
+## 戻り値
+なし
+
+
+## 備考
+- この関数はスレッドセーフである
+- 確保時のサイズを処理系に渡せるため、[`free()`](free.md)よりも効率的に解放できる可能性がある
+
+
+## 例
+```cpp example
+#include <cstdlib>
+
+int main()
+{
+  int* p = static_cast<int*>(std::malloc(10 * sizeof(int)));
+  std::free_sized(p, 10 * sizeof(int));
+}
+```
+* std::free_sized[color ff0000]
+* std::malloc[link malloc.md]
+
+### 出力
+```
+```
+
+
+## バージョン
+### 言語
+- C++26
+
+### 処理系
+- [Clang](/implementation.md#clang): 22 [mark noimpl]
+- [GCC](/implementation.md#gcc): 16.1 [mark noimpl]
+- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl]
+
+
+## 関連項目
+- [`free()`](free.md): 確保したメモリを解放する
+- [`free_aligned_sized()`](free_aligned_sized.md): アライメントと確保時のサイズを指定して、確保したメモリを解放する
+- [`malloc()`](malloc.md): メモリを確保する
+
+
+## 参照
+- [P3348R4 C++26 should refer to C23 not C17](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3348r4.html)
+    - C++26がC23を参照するようになり、この関数が`<cstdlib>`に追加された

memalignment -- C++26対応として、C23標準ライブラリを追加 (#1657)

2026-06-08T20:56:08+09:00

diff --git a/reference/cstdlib/memalignment.md b/reference/cstdlib/memalignment.md
new file mode 100644
index 000000000..41b3ddc2c
--- /dev/null
+++ b/reference/cstdlib/memalignment.md
@@ -0,0 +1,65 @@
+# memalignment
+* cstdlib[meta header]
+* std[meta namespace]
+* function[meta id-type]
+* cpp26[meta cpp]
+
+```cpp
+namespace std {
+  size_t memalignment(const void* p);
+}
+```
+* size_t[link /reference/cstddef/size_t.md]
+
+## 概要
+ポインタのアライメントを取得する。
+
+C23で`<stdlib.h>`に追加された関数であり、C++26で`<cstdlib>`に取り込まれた。
+
+この関数はフリースタンディング環境でも提供される。
+
+
+## 戻り値
+- `p`がヌルポインタでない場合、ポインタ値`p`を割り切ることができる最大の2の累乗の値を返す
+- `p`がヌルポインタの場合、`0`を返す
+
+
+## 例
+```cpp example
+#include <cstdlib>
+#include <print>
+
+int main()
+{
+  void* p = std::aligned_alloc(64, 256);
+  std::println("{}", std::memalignment(p));
+  std::free(p);
+}
+```
+* std::memalignment[color ff0000]
+* std::aligned_alloc[link aligned_alloc.md]
+
+### 出力例
+```
+64
+```
+
+
+## バージョン
+### 言語
+- C++26
+
+### 処理系
+- [Clang](/implementation.md#clang): 22 [mark noimpl]
+- [GCC](/implementation.md#gcc): 16.1 [mark noimpl]
+- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl]
+
+
+## 関連項目
+- [`aligned_alloc()`](aligned_alloc.md): 指定したアライメントでメモリを確保する
+- [`free_aligned_sized()`](free_aligned_sized.md): アライメントと確保時のサイズを指定して、確保したメモリを解放する
+
+
+## 参照
+- [P3348R4 C++26 should refer to C23 not C17](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3348r4.html)
+    - C++26がC23を参照するようになり、この関数が`<cstdlib>`に追加された

realloc -- C++26対応として、C23標準ライブラリを追加 (#1657)

2026-06-08T20:56:08+09:00

diff --git a/reference/cstdlib/realloc.md b/reference/cstdlib/realloc.md
index ac4df8fd2..f5d95687a 100644
--- a/reference/cstdlib/realloc.md
+++ b/reference/cstdlib/realloc.md
@@ -35,7 +35,9 @@ namespace std {
 
 
 ## 備考
-- `new_size`が0の場合の動作は未規定。
+- `new_size`が0の場合の動作は以下となる。
+    - C++23まで : 未規定
+    - C++26 : [エラー性動作 (erroneous behavior)](/lang/cpp26/erroneous_behavior_for_uninitialized_reads.md)となる。その効果は処理系定義であり、POSIXの動作も許容される
 - 確保された領域はメモリリークを避けるため、`free`、`realloc`で解放する必要がある。
 
 
@@ -75,3 +77,8 @@ int main() {
 - [`calloc`](calloc.md): メモリを確保する
 - [`malloc`](malloc.md): メモリを確保し、領域をゼロ初期化する
 - [`free`](free.md): 確保したメモリを解放する
+
+
+## 参照
+- [P3348R4 C++26 should refer to C23 not C17](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3348r4.html)
+    - C++26がC23を参照するようになり、`new_size`が0の場合がエラー性動作となった

strfromd -- C++26対応として、C23標準ライブラリを追加 (#1657)

2026-06-08T20:56:08+09:00

diff --git a/reference/cstdlib/strfromd.md b/reference/cstdlib/strfromd.md
new file mode 100644
index 000000000..2dc68bd43
--- /dev/null
+++ b/reference/cstdlib/strfromd.md
@@ -0,0 +1,72 @@
+# strfromd
+* cstdlib[meta header]
+* std[meta namespace]
+* function[meta id-type]
+* cpp26[meta cpp]
+
+```cpp
+namespace std {
+  int strfromd(char* s, size_t n, const char* format, double fp);
+}
+```
+* size_t[link /reference/cstddef/size_t.md]
+
+## 概要
+`double`型の浮動小数点数を文字列に変換する。
+
+C23で`<stdlib.h>`に追加された関数であり、C++26で`<cstdlib>`に取り込まれた。
+
+
+## 事前条件
+`format`は、文字`%`、アスタリスク`*`を含まない精度指定 (省略可)、および変換指定子`a`・`A`・`e`・`E`・`f`・`F`・`g`・`G`のいずれか1つだけで構成されること。
+
+
+## 効果
+[`std::snprintf`](/reference/cstdio/snprintf.md.nolink)`(s, n, format, fp)`と等価である。
+
+
+## 戻り値
+`n`が十分に大きいと仮定した場合に書き込まれる文字数を、終端のヌル文字を除いて返す。
+
+したがって、ヌル終端された出力が完全に書き込まれたのは、戻り値が非負かつ`n`未満である場合に限られる。
+
+
+## 例
+```cpp example
+#include <cstdlib>
+#include <print>
+
+int main()
+{
+  char buf[32];
+  std::strfromd(buf, sizeof(buf), "%.2f", 3.14159);
+  std::println("{}", buf);
+}
+```
+* std::strfromd[color ff0000]
+
+### 出力
+```
+3.14
+```
+
+
+## バージョン
+### 言語
+- C++26
+
+### 処理系
+- [Clang](/implementation.md#clang): 22 [mark noimpl]
+- [GCC](/implementation.md#gcc): 16.1 [mark noimpl]
+- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl]
+
+
+## 関連項目
+- [`strfromf`](strfromf.md): `float`型を文字列に変換する
+- [`strfroml`](strfroml.md): `long double`型を文字列に変換する
+- [`std::to_chars`](/reference/charconv/to_chars.md): 数値を文字列に変換する
+
+
+## 参照
+- [P3348R4 C++26 should refer to C23 not C17](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3348r4.html)
+    - C++26がC23を参照するようになり、この関数が`<cstdlib>`に追加された

strfromf -- C++26対応として、C23標準ライブラリを追加 (#1657)

2026-06-08T20:56:08+09:00

diff --git a/reference/cstdlib/strfromf.md b/reference/cstdlib/strfromf.md
new file mode 100644
index 000000000..79f37e8fb
--- /dev/null
+++ b/reference/cstdlib/strfromf.md
@@ -0,0 +1,72 @@
+# strfromf
+* cstdlib[meta header]
+* std[meta namespace]
+* function[meta id-type]
+* cpp26[meta cpp]
+
+```cpp
+namespace std {
+  int strfromf(char* s, size_t n, const char* format, float fp);
+}
+```
+* size_t[link /reference/cstddef/size_t.md]
+
+## 概要
+`float`型の浮動小数点数を文字列に変換する。
+
+C23で`<stdlib.h>`に追加された関数であり、C++26で`<cstdlib>`に取り込まれた。
+
+
+## 事前条件
+`format`は、文字`%`、アスタリスク`*`を含まない精度指定 (省略可)、および変換指定子`a`・`A`・`e`・`E`・`f`・`F`・`g`・`G`のいずれか1つだけで構成されること。
+
+
+## 効果
+[`std::snprintf`](/reference/cstdio/snprintf.md.nolink)`(s, n, format, fp)`と等価である。
+
+
+## 戻り値
+`n`が十分に大きいと仮定した場合に書き込まれる文字数を、終端のヌル文字を除いて返す。
+
+したがって、ヌル終端された出力が完全に書き込まれたのは、戻り値が非負かつ`n`未満である場合に限られる。
+
+
+## 例
+```cpp example
+#include <cstdlib>
+#include <print>
+
+int main()
+{
+  char buf[32];
+  std::strfromf(buf, sizeof(buf), "%.2f", 3.14159f);
+  std::println("{}", buf);
+}
+```
+* std::strfromf[color ff0000]
+
+### 出力
+```
+3.14
+```
+
+
+## バージョン
+### 言語
+- C++26
+
+### 処理系
+- [Clang](/implementation.md#clang): 22 [mark noimpl]
+- [GCC](/implementation.md#gcc): 16.1 [mark noimpl]
+- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl]
+
+
+## 関連項目
+- [`strfromd`](strfromd.md): `double`型を文字列に変換する
+- [`strfroml`](strfroml.md): `long double`型を文字列に変換する
+- [`std::to_chars`](/reference/charconv/to_chars.md): 数値を文字列に変換する
+
+
+## 参照
+- [P3348R4 C++26 should refer to C23 not C17](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3348r4.html)
+    - C++26がC23を参照するようになり、この関数が`<cstdlib>`に追加された

strfroml -- C++26対応として、C23標準ライブラリを追加 (#1657)

2026-06-08T20:56:08+09:00

diff --git a/reference/cstdlib/strfroml.md b/reference/cstdlib/strfroml.md
new file mode 100644
index 000000000..767e0b851
--- /dev/null
+++ b/reference/cstdlib/strfroml.md
@@ -0,0 +1,72 @@
+# strfroml
+* cstdlib[meta header]
+* std[meta namespace]
+* function[meta id-type]
+* cpp26[meta cpp]
+
+```cpp
+namespace std {
+  int strfroml(char* s, size_t n, const char* format, long double fp);
+}
+```
+* size_t[link /reference/cstddef/size_t.md]
+
+## 概要
+`long double`型の浮動小数点数を文字列に変換する。
+
+C23で`<stdlib.h>`に追加された関数であり、C++26で`<cstdlib>`に取り込まれた。
+
+
+## 事前条件
+`format`は、文字`%`、アスタリスク`*`を含まない精度指定 (省略可)、および変換指定子`a`・`A`・`e`・`E`・`f`・`F`・`g`・`G`のいずれか1つだけで構成されること。
+
+
+## 効果
+[`std::snprintf`](/reference/cstdio/snprintf.md.nolink)`(s, n, format, fp)`と等価である。
+
+
+## 戻り値
+`n`が十分に大きいと仮定した場合に書き込まれる文字数を、終端のヌル文字を除いて返す。
+
+したがって、ヌル終端された出力が完全に書き込まれたのは、戻り値が非負かつ`n`未満である場合に限られる。
+
+
+## 例
+```cpp example
+#include <cstdlib>
+#include <print>
+
+int main()
+{
+  char buf[32];
+  std::strfroml(buf, sizeof(buf), "%.2Lf", 3.14159L);
+  std::println("{}", buf);
+}
+```
+* std::strfroml[color ff0000]
+
+### 出力
+```
+3.14
+```
+
+
+## バージョン
+### 言語
+- C++26
+
+### 処理系
+- [Clang](/implementation.md#clang): 22 [mark noimpl]
+- [GCC](/implementation.md#gcc): 16.1 [mark noimpl]
+- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl]
+
+
+## 関連項目
+- [`strfromd`](strfromd.md): `double`型を文字列に変換する
+- [`strfromf`](strfromf.md): `float`型を文字列に変換する
+- [`std::to_chars`](/reference/charconv/to_chars.md): 数値を文字列に変換する
+
+
+## 参照
+- [P3348R4 C++26 should refer to C23 not C17](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3348r4.html)
+    - C++26がC23を参照するようになり、この関数が`<cstdlib>`に追加された

cstring -- C++26対応として、C23標準ライブラリを追加 (#1657)

2026-06-08T20:56:08+09:00

cstring

<cstring>ヘッダでは、文字列操作関数を定義する。これらの機能は、std名前空間に属することを除いてC言語の標準ライブラリ<string.h>ヘッダと同じである。

型

名前	説明	対応バージョン
`size_t`	符号なし整数型

マクロ

名前	説明	対応バージョン
`NULL`	ヌルポインタ定数に展開されるマクロ

コピー関数

名前	説明	対応バージョン
`memcpy`	メモリデータをコピーする
`memccpy`	メモリデータを指定した文字が現れるまでコピーする	C++26
`memmove`	メモリデータをコピーする（領域重複可）
`strcpy`	文字列をコピーする
`strncpy`	文字列をコピーする（上限サイズ指定）
`strdup`	文字列を複製する	C++26
`strndup`	文字列を複製する（上限サイズ指定）	C++26

結合関数

名前	説明	対応バージョン
`strcat`	文字列を結合する
`strncat`	文字列を結合する（上限サイズ指定）

比較関数

名前	説明	対応バージョン
`memcmp`	メモリデータを比較する
`strcmp`	文字列を比較する
`strcoll`	文字列を比較する（ロケール依存）
`strncmp`	文字列を比較する（上限サイズ指定）
`strxfrm`	ロケールに基づいて文字列を変換する

検索関数

名前	説明	対応バージョン
`memchr`	メモリデータを検索する
`strchr`	文字を検索する
`strcspn`	指定した文字現れるまでの長さを求める
`strpbrk`	指定した文字以外が現れる位置を求める
`strrchr`	文字を後ろから検索する
`strspn`	指定した文字以外が現れるまでの長さを求める
`strstr`	文字列を検索する
`strtok`	文字列をトークンに分割する

その他の関数

名前	説明	対応バージョン
`memset`	メモリデータを指定した値で埋める
`memset_explicit`	メモリデータを指定した値で埋める（最適化によって除去されない）	C++26
`strerror`	エラーの内容を文字列で取得する
`strlen`	文字列の長さを取得する

参照

P0175R1 Synopses for the C library
P3348R4 C++26 should refer to C23 not C17
- C++26がC23を参照するようになり、memccpy・strdup・strndup・memset_explicitが追加された

memccpy -- C++26対応として、C23標準ライブラリを追加 (#1657)

2026-06-08T20:56:08+09:00

diff --git a/reference/cstring/memccpy.md b/reference/cstring/memccpy.md
new file mode 100644
index 000000000..4c5f32470
--- /dev/null
+++ b/reference/cstring/memccpy.md
@@ -0,0 +1,77 @@
+# memccpy
+* cstring[meta header]
+* std[meta namespace]
+* function[meta id-type]
+* cpp26[meta cpp]
+
+```cpp
+namespace std {
+  void* memccpy(void* s1, const void* s2, int c, size_t n);
+}
+```
+* size_t[link /reference/cstddef/size_t.md]
+
+## 概要
+メモリデータを、指定した文字が現れるまでコピーする。
+
+C23で`<string.h>`に追加された関数であり、C++26で`<cstring>`に取り込まれた。
+
+この関数はフリースタンディング環境でも提供される。
+
+
+## 効果
+`s2`が指すオブジェクトから`s1`が指すオブジェクトへ、文字`c` (`unsigned char`に変換される) が最初に現れてコピーされるまで、もしくは`n`バイトをコピーするまで、いずれか早いほうまでバイトをコピーする。
+
+コピー元とコピー先の領域が重なっている場合、動作は未定義である。
+
+
+## 戻り値
+コピー先`s1`において、コピーされた文字`c`の次の位置を指すポインタを返す。
+
+`s2`の先頭`n`バイトに文字`c`が見つからなかった場合、ヌルポインタを返す。
+
+
+## 例
+```cpp example
+#include <cstring>
+#include <iostream>
+
+int main()
+{
+  const char src[] = "abc/def";
+  char dst[8] = {};
+
+  // '/'が現れるまでコピーする
+  char* p = static_cast<char*>(std::memccpy(dst, src, '/', sizeof(dst)));
+
+  std::cout << dst << std::endl;
+  std::cout << (p != nullptr ? "found" : "not found") << std::endl;
+}
+```
+* std::memccpy[color ff0000]
+
+### 出力
+```
+abc/
+found
+```
+
+
+## バージョン
+### 言語
+- C++26
+
+### 処理系
+- [Clang](/implementation.md#clang): 22 [mark noimpl]
+- [GCC](/implementation.md#gcc): 16.1 [mark noimpl]
+- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl]
+
+
+## 関連項目
+- `memcpy`: メモリデータをコピーする
+- `memmove`: メモリデータをコピーする（領域重複可）
+
+
+## 参照
+- [P3348R4 C++26 should refer to C23 not C17](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3348r4.html)
+    - C++26がC23を参照するようになり、この関数が`<cstring>`に追加された

memset_explicit -- C++26対応として、C23標準ライブラリを追加 (#1657)

2026-06-08T20:56:08+09:00

diff --git a/reference/cstring/memset_explicit.md b/reference/cstring/memset_explicit.md
new file mode 100644
index 000000000..2782bcf19
--- /dev/null
+++ b/reference/cstring/memset_explicit.md
@@ -0,0 +1,72 @@
+# memset_explicit
+* cstring[meta header]
+* std[meta namespace]
+* function[meta id-type]
+* cpp26[meta cpp]
+
+```cpp
+namespace std {
+  void* memset_explicit(void* s, int c, size_t n);
+}
+```
+* size_t[link /reference/cstddef/size_t.md]
+
+## 概要
+メモリデータを指定した値で埋める。最適化によって除去されないことが保証される。
+
+C23で`<string.h>`に追加された関数であり、C++26で`<cstring>`に取り込まれた。
+
+この関数はフリースタンディング環境でも提供される。
+
+
+## 効果
+`s`が指すオブジェクトの先頭`n`バイトのそれぞれに、値`c` (`unsigned char`に変換される) を書き込む。
+
+この関数は、オブジェクトに格納された機密情報をアクセス不能にすることを目的とする。
+
+
+## 戻り値
+`s`を返す。
+
+
+## 備考
+- 通常の`memset`は、書き込み後にそのメモリが読み取られない場合、コンパイラの最適化によって書き込み自体が除去されることがある。この関数はそのような最適化による除去がされないことが保証されるため、パスワードや鍵などの機密情報をメモリ上から消去する用途に使用できる
+
+
+## 例
+```cpp example
+#include <cstring>
+
+int main()
+{
+  char password[16];
+  // ... passwordを使用 ...
+
+  // 使用後、メモリ上から確実に消去する
+  std::memset_explicit(password, 0, sizeof(password));
+}
+```
+* std::memset_explicit[color ff0000]
+
+### 出力
+```
+```
+
+
+## バージョン
+### 言語
+- C++26
+
+### 処理系
+- [Clang](/implementation.md#clang): 22 [mark noimpl]
+- [GCC](/implementation.md#gcc): 16.1 [mark noimpl]
+- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl]
+
+
+## 関連項目
+- `memset`: メモリデータを指定した値で埋める
+
+
+## 参照
+- [P3348R4 C++26 should refer to C23 not C17](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3348r4.html)
+    - C++26がC23を参照するようになり、この関数が`<cstring>`に追加された

strdup -- C++26対応として、C23標準ライブラリを追加 (#1657)

2026-06-08T20:56:08+09:00

diff --git a/reference/cstring/strdup.md b/reference/cstring/strdup.md
new file mode 100644
index 000000000..35d9f5eca
--- /dev/null
+++ b/reference/cstring/strdup.md
@@ -0,0 +1,70 @@
+# strdup
+* cstring[meta header]
+* std[meta namespace]
+* function[meta id-type]
+* cpp26[meta cpp]
+
+```cpp
+namespace std {
+  char* strdup(const char* s);
+}
+```
+
+## 概要
+文字列を複製する。
+
+C23で`<string.h>`に追加された関数であり、C++26で`<cstring>`に取り込まれた。
+
+
+## 効果
+[`std::malloc()`](/reference/cstdlib/malloc.md)を呼び出したときと同様に確保した領域に、`s`が指す文字列 (終端のヌル文字を含む) の複製を作成する。
+
+
+## 戻り値
+複製した文字列の先頭文字へのポインタを返す。
+
+返されたポインタは[`std::free()`](/reference/cstdlib/free.md)に渡すことができる。
+
+領域を確保できなかった場合、ヌルポインタを返す。
+
+
+## 例
+```cpp example
+#include <cstring>
+#include <cstdlib>
+#include <iostream>
+
+int main()
+{
+  char* p = std::strdup("hello");
+  std::cout << p << std::endl;
+  std::free(p);
+}
+```
+* std::strdup[color ff0000]
+* std::free[link /reference/cstdlib/free.md]
+
+### 出力
+```
+hello
+```
+
+
+## バージョン
+### 言語
+- C++26
+
+### 処理系
+- [Clang](/implementation.md#clang): 22 [mark noimpl]
+- [GCC](/implementation.md#gcc): 16.1 [mark noimpl]
+- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl]
+
+
+## 関連項目
+- [`strndup`](strndup.md): 文字列を複製する（上限サイズ指定）
+- [`std::free()`](/reference/cstdlib/free.md): 確保したメモリを解放する
+
+
+## 参照
+- [P3348R4 C++26 should refer to C23 not C17](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3348r4.html)
+    - C++26がC23を参照するようになり、この関数が`<cstring>`に追加された

strndup -- C++26対応として、C23標準ライブラリを追加 (#1657)

2026-06-08T20:56:08+09:00

diff --git a/reference/cstring/strndup.md b/reference/cstring/strndup.md
new file mode 100644
index 000000000..95c0c7f9e
--- /dev/null
+++ b/reference/cstring/strndup.md
@@ -0,0 +1,73 @@
+# strndup
+* cstring[meta header]
+* std[meta namespace]
+* function[meta id-type]
+* cpp26[meta cpp]
+
+```cpp
+namespace std {
+  char* strndup(const char* s, size_t size);
+}
+```
+* size_t[link /reference/cstddef/size_t.md]
+
+## 概要
+文字列を、上限サイズを指定して複製する。
+
+C23で`<string.h>`に追加された関数であり、C++26で`<cstring>`に取り込まれた。
+
+
+## 効果
+[`std::malloc()`](/reference/cstdlib/malloc.md)を呼び出したときと同様に確保した領域に、`s`が指す配列の先頭から最大`size`文字、もしくは最初のヌル文字までのいずれか短いほうで初期化した文字列を作成する。
+
+`s`が指す配列の先頭`size`文字にヌル文字が含まれない場合、複製の末尾にヌル文字が付加される。
+
+
+## 戻り値
+作成した文字列の先頭文字へのポインタを返す。
+
+返されたポインタは[`std::free()`](/reference/cstdlib/free.md)に渡すことができる。
+
+領域を確保できなかった場合、ヌルポインタを返す。
+
+
+## 例
+```cpp example
+#include <cstring>
+#include <cstdlib>
+#include <iostream>
+
+int main()
+{
+  char* p = std::strndup("hello world", 5);
+  std::cout << p << std::endl;
+  std::free(p);
+}
+```
+* std::strndup[color ff0000]
+* std::free[link /reference/cstdlib/free.md]
+
+### 出力
+```
+hello
+```
+
+
+## バージョン
+### 言語
+- C++26
+
+### 処理系
+- [Clang](/implementation.md#clang): 22 [mark noimpl]
+- [GCC](/implementation.md#gcc): 16.1 [mark noimpl]
+- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl]
+
+
+## 関連項目
+- [`strdup`](strdup.md): 文字列を複製する
+- [`std::free()`](/reference/cstdlib/free.md): 確保したメモリを解放する
+
+
+## 参照
+- [P3348R4 C++26 should refer to C23 not C17](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3348r4.html)
+    - C++26がC23を参照するようになり、この関数が`<cstring>`に追加された

ctime -- C++26対応として、C23標準ライブラリを追加 (#1657)

2026-06-08T20:56:08+09:00

ctime

<ctime>ヘッダでは、日付と時間に関する機能を定義する。

マクロ

名前	説明	対応バージョン
`NULL`	ヌルポインタ定数
`CLOCKS_PER_SEC`	`clock()`関数によって返される1秒あたりの数値
`TIME_UTC`	UTC時間ベースであることを指定するための0より大きい整数定数値	C++17
`TIME_MONOTONIC`	単調増加時間ベースであることを指定するための整数定数値 (処理系定義)	C++26
`TIME_ACTIVE`	プロセスのCPU時間ベースであることを指定するための整数定数値 (処理系定義)	C++26
`TIME_THREAD_ACTIVE`	スレッドのCPU時間ベースであることを指定するための整数定数値 (処理系定義)	C++26
`__STDC_VERSION_TIME_H__`	`<ctime>`が提供するC標準ライブラリ機能のバージョン (`202311L`)	C++26

型

名前	説明	対応バージョン
`size_t`	符号なし整数型
`clock_t`	`clock()`関数が返すプロセッサ時間を表す型
`time_t`	時間を表す型

構造体

名前	説明	対応バージョン
`timespec`	指定されたベース時間に基づいた、経過秒と経過ナノ秒を保持する型	C++17
`tm`	カレンダー時間を保持する型

関数

名前	説明	対応バージョン
`clock`	プログラム実行開始からの経過時間を取得する
`difftime`	2つの時間の差を計算する
`mktime`	カレンダー時間から経過秒を生成する
`timegm`	UTCのカレンダー時間から経過秒を生成する	C++26
`gmtime`	経過秒からカレンダー時間を生成する
`gmtime_r`	経過秒からカレンダー時間を生成する (利用者が用意したバッファに格納する)	C++26
`localtime`	経過秒からローカル時間のカレンダー時間を生成する
`localtime_r`	経過秒からローカル時間のカレンダー時間を生成する (利用者が用意したバッファに格納する)	C++26
`time`	現在時間までの経過秒を取得する
`timespec_get`	指定したベース時間に基づいた、経過秒と経過ナノ秒を取得する	C++17
`timespec_getres`	指定したベース時間の分解能を取得する	C++26
`asctime`	カレンダー時間を文字列化する	C++26で非推奨
`ctime`	経過秒を日時として文字列化する	C++26で非推奨
`strftime`	指定したフォーマットでカレンダー時間を文字列化する

参照

P3348R4 C++26 should refer to C23 not C17
- C++26がC23を参照するようになり、timegm・gmtime_r・localtime_r・timespec_getresと、TIME_MONOTONIC・TIME_ACTIVE・TIME_THREAD_ACTIVE・__STDC_VERSION_TIME_H__が追加された。またasctime・ctimeが非推奨となった

asctime -- C++26対応として、C23標準ライブラリを追加 (#1657)

2026-06-08T20:56:08+09:00

diff --git a/reference/ctime/asctime.md b/reference/ctime/asctime.md
new file mode 100644
index 000000000..63a78f1f5
--- /dev/null
+++ b/reference/ctime/asctime.md
@@ -0,0 +1,68 @@
+# asctime
+* ctime[meta header]
+* std[meta namespace]
+* function[meta id-type]
+* cpp26deprecated[meta cpp]
+
+```cpp
+namespace std {
+  char* asctime(const tm* timeptr);
+}
+```
+* tm[link tm.md.nolink]
+
+この関数は、C++26で非推奨となった。代わりに`strftime`関数や、[`<chrono>`](/reference/chrono.md)ライブラリの書式化機能を使用すること。
+
+
+## 概要
+カレンダー時間を表す`tm`構造体を、`Www Mmm dd hh:mm:ss yyyy\n`形式 (曜日、月、日、時、分、秒、年) の固定書式の文字列に変換する。
+
+
+## 戻り値
+`Www Mmm dd hh:mm:ss yyyy\n`形式 (曜日、月、日、時、分、秒、年) のヌル終端文字列へのポインタを返す。
+
+戻り値は静的に確保された領域を指すため、`asctime`や`ctime`の呼び出しのたびに上書きされる可能性がある。
+
+
+## 非推奨・削除の詳細
+C++26では、C言語側 (C23) で非推奨となったことにあわせて非推奨となった。この関数には以下の問題がある：
+
+- 結果を静的な内部バッファに書き込んでそのポインタを返すため、スレッドセーフではない
+- 内部バッファは固定長 (26バイト) であり、`timeptr`に範囲外の値 (たとえば桁数の大きい年) が格納されているとバッファオーバーフローを引き起こす危険性がある
+
+これらの代わりに、フォーマットとバッファサイズを指定できる`strftime`関数や、[`<chrono>`](/reference/chrono.md)ライブラリの書式化機能を使用すること。
+
+
+## 例
+```cpp example
+#include <iostream>
+#include <ctime>
+
+int main()
+{
+  std::time_t t = std::time(nullptr);
+  std::tm* lt = std::localtime(&t);
+  std::cout << std::asctime(lt) << std::endl;
+}
+```
+* std::asctime[color ff0000]
+
+### 出力例
+```
+Fri May 29 14:30:00 2026
+```
+
+
+## バージョン
+### 言語
+- C++03
+
+
+## 関連項目
+- [`ctime`](ctime.md): 経過秒を日時として文字列化する
+- [`<chrono>`](/reference/chrono.md)
+
+
+## 参照
+- [P3348R4 C++26 should refer to C23 not C17](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3348r4.html)
+    - C++26がC23を参照するようになり、この関数が非推奨となった

ctime -- C++26対応として、C23標準ライブラリを追加 (#1657)

2026-06-08T20:56:08+09:00

diff --git a/reference/ctime/ctime.md b/reference/ctime/ctime.md
new file mode 100644
index 000000000..51d7a98c5
--- /dev/null
+++ b/reference/ctime/ctime.md
@@ -0,0 +1,69 @@
+# ctime
+* ctime[meta header]
+* std[meta namespace]
+* function[meta id-type]
+* cpp26deprecated[meta cpp]
+
+```cpp
+namespace std {
+  char* ctime(const time_t* timer);
+}
+```
+* time_t[link time_t.md]
+
+この関数は、C++26で非推奨となった。代わりに`strftime`関数や、[`<chrono>`](/reference/chrono.md)ライブラリの書式化機能を使用すること。
+
+
+## 概要
+経過秒を表す[`time_t`](time_t.md)値を、ローカル時間を表す`Www Mmm dd hh:mm:ss yyyy\n`形式 (曜日、月、日、時、分、秒、年) の固定書式の文字列に変換する。
+
+`std::ctime(timer)`は`std::asctime(std::localtime(timer))`と等価である。
+
+
+## 戻り値
+`Www Mmm dd hh:mm:ss yyyy\n`形式 (曜日、月、日、時、分、秒、年) のヌル終端文字列へのポインタを返す。
+
+戻り値は静的に確保された領域を指すため、`asctime`や`ctime`の呼び出しのたびに上書きされる可能性がある。
+
+
+## 非推奨・削除の詳細
+C++26では、C言語側 (C23) で非推奨となったことにあわせて非推奨となった。この関数には以下の問題がある：
+
+- 結果を静的な内部バッファに書き込んでそのポインタを返すため、スレッドセーフではない
+- 内部バッファは固定長 (26バイト) であり、`timer`が範囲外の値 (たとえば桁数の大きい年) を表しているとバッファオーバーフローを引き起こす危険性がある
+
+これらの代わりに、フォーマットとバッファサイズを指定できる`strftime`関数や、[`<chrono>`](/reference/chrono.md)ライブラリの書式化機能を使用すること。
+
+
+## 例
+```cpp example
+#include <iostream>
+#include <ctime>
+
+int main()
+{
+  std::time_t t = std::time(nullptr);
+  std::cout << std::ctime(&t) << std::endl;
+}
+```
+* std::ctime[color ff0000]
+
+### 出力例
+```
+Fri May 29 14:30:00 2026
+```
+
+
+## バージョン
+### 言語
+- C++03
+
+
+## 関連項目
+- [`asctime`](asctime.md): カレンダー時間を文字列化する
+- [`<chrono>`](/reference/chrono.md)
+
+
+## 参照
+- [P3348R4 C++26 should refer to C23 not C17](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3348r4.html)
+    - C++26がC23を参照するようになり、この関数が非推奨となった

gmtime_r -- C++26対応として、C23標準ライブラリを追加 (#1657)

2026-06-08T20:56:08+09:00

diff --git a/reference/ctime/gmtime_r.md b/reference/ctime/gmtime_r.md
new file mode 100644
index 000000000..3cc8ca39b
--- /dev/null
+++ b/reference/ctime/gmtime_r.md
@@ -0,0 +1,73 @@
+# gmtime_r
+* ctime[meta header]
+* std[meta namespace]
+* function[meta id-type]
+* cpp26[meta cpp]
+
+```cpp
+namespace std {
+  tm* gmtime_r(const time_t* timer, tm* buf);
+}
+```
+* time_t[link time_t.md]
+* tm[link tm.md.nolink]
+
+## 概要
+経過秒 ([`time_t`](time_t.md)) を、UTCで表現されたカレンダー時間 (`tm`構造体) に変換する。
+
+[`gmtime`](gmtime.md.nolink)と異なり、結果を利用者が用意したバッファ`buf`に格納するため、スレッドセーフである。
+
+C23で`<time.h>`に追加された関数であり、C++26で`<ctime>`に取り込まれた。
+
+
+## 効果
+`timer`が指すカレンダー時間を、UTCで表現された要素別の時間に変換し、`buf`が指す構造体に格納する。
+
+
+## 戻り値
+変換した要素別の時間 (`buf`) を指すポインタを返す。
+
+指定された時間をUTCに変換できない場合、ヌルポインタを返す。
+
+
+## 例
+```cpp example
+#include <ctime>
+#include <print>
+
+int main()
+{
+  std::time_t t = std::time(nullptr);
+
+  std::tm result;
+  if (std::gmtime_r(&t, &result) != nullptr) {
+    std::println("{}", result.tm_year + 1900);
+  }
+}
+```
+* std::gmtime_r[color ff0000]
+
+### 出力例
+```
+2026
+```
+
+
+## バージョン
+### 言語
+- C++26
+
+### 処理系
+- [Clang](/implementation.md#clang): 22 [mark noimpl]
+- [GCC](/implementation.md#gcc): 16.1 [mark noimpl]
+- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl]
+
+
+## 関連項目
+- [`gmtime`](gmtime.md.nolink): 経過秒からUTCのカレンダー時間を生成する
+- [`localtime_r`](localtime_r.md): 経過秒からローカル時間のカレンダー時間を生成する (バッファ指定)
+
+
+## 参照
+- [P3348R4 C++26 should refer to C23 not C17](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3348r4.html)
+    - C++26がC23を参照するようになり、この関数が`<ctime>`に追加された

localtime_r -- C++26対応として、C23標準ライブラリを追加 (#1657)

2026-06-08T20:56:08+09:00

diff --git a/reference/ctime/localtime_r.md b/reference/ctime/localtime_r.md
new file mode 100644
index 000000000..b514ba3bb
--- /dev/null
+++ b/reference/ctime/localtime_r.md
@@ -0,0 +1,73 @@
+# localtime_r
+* ctime[meta header]
+* std[meta namespace]
+* function[meta id-type]
+* cpp26[meta cpp]
+
+```cpp
+namespace std {
+  tm* localtime_r(const time_t* timer, tm* buf);
+}
+```
+* time_t[link time_t.md]
+* tm[link tm.md.nolink]
+
+## 概要
+経過秒 ([`time_t`](time_t.md)) を、ローカル時間で表現されたカレンダー時間 (`tm`構造体) に変換する。
+
+[`localtime`](localtime.md.nolink)と異なり、結果を利用者が用意したバッファ`buf`に格納するため、スレッドセーフである。
+
+C23で`<time.h>`に追加された関数であり、C++26で`<ctime>`に取り込まれた。
+
+
+## 効果
+`timer`が指すカレンダー時間を、ローカル時間で表現された要素別の時間に変換し、`buf`が指す構造体に格納する。
+
+
+## 戻り値
+変換した要素別の時間 (`buf`) を指すポインタを返す。
+
+指定された時間をローカル時間に変換できない場合、ヌルポインタを返す。
+
+
+## 例
+```cpp example
+#include <ctime>
+#include <print>
+
+int main()
+{
+  std::time_t t = std::time(nullptr);
+
+  std::tm result;
+  if (std::localtime_r(&t, &result) != nullptr) {
+    std::println("{}", result.tm_year + 1900);
+  }
+}
+```
+* std::localtime_r[color ff0000]
+
+### 出力例
+```
+2026
+```
+
+
+## バージョン
+### 言語
+- C++26
+
+### 処理系
+- [Clang](/implementation.md#clang): 22 [mark noimpl]
+- [GCC](/implementation.md#gcc): 16.1 [mark noimpl]
+- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl]
+
+
+## 関連項目
+- [`localtime`](localtime.md.nolink): 経過秒からローカル時間のカレンダー時間を生成する
+- [`gmtime_r`](gmtime_r.md): 経過秒からUTCのカレンダー時間を生成する (バッファ指定)
+
+
+## 参照
+- [P3348R4 C++26 should refer to C23 not C17](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3348r4.html)
+    - C++26がC23を参照するようになり、この関数が`<ctime>`に追加された

TIME_ACTIVE -- C++26対応として、C23標準ライブラリを追加 (#1657)

2026-06-08T20:56:08+09:00

diff --git a/reference/ctime/time_active.md b/reference/ctime/time_active.md
new file mode 100644
index 000000000..65efb1cc6
--- /dev/null
+++ b/reference/ctime/time_active.md
@@ -0,0 +1,76 @@
+# TIME_ACTIVE
+* ctime[meta header]
+* macro[meta id-type]
+* cpp26[meta cpp]
+
+```cpp
+#define TIME_ACTIVE implementation-defined
+```
+
+## 概要
+プログラム全体の処理時間 (CPU時間) ベースであることを指定するための整数定数値。処理系定義のオプションのマクロである。
+
+このベース時間を[`timespec_get()`](timespec_get.md)に指定した場合、プログラム実行全体に関連する処理時間を取得する。
+
+定義される場合、その値は[`TIME_UTC`](time_utc.md)・[`TIME_MONOTONIC`](time_monotonic.md)とは異なり、同一プログラム実行内で変化しない。
+
+C23で`<time.h>`に追加されたマクロであり、C++26で`<ctime>`に取り込まれた。
+
+
+## 備考
+- このベース時間はプログラムが実際にCPUで処理を行った時間 (active processing time) であり、実時間 (wall-clock time) ではない。スリープやI/O待ちなどでブロッキングしている間の時間は計測に含まれない
+
+
+## 例
+```cpp example
+#include <ctime>
+#include <print>
+
+int main()
+{
+  std::timespec t1;
+  std::timespec_get(&t1, TIME_ACTIVE);
+
+  // 実際に計算を行う (スリープでは処理時間は増えない)
+  volatile long sum = 0;
+  for (long i = 0; i < 100'000'000; ++i) {
+    sum += i;
+  }
+
+  std::timespec t2;
+  std::timespec_get(&t2, TIME_ACTIVE);
+
+  // 計算に費やしたCPU処理時間が計測される
+  // (秒の差) + (ナノ秒の差を秒に変換)。1秒は1'000'000'000ナノ秒
+  double sec = (t2.tv_sec - t1.tv_sec) + (t2.tv_nsec - t1.tv_nsec) / 1'000'000'000.0;
+  std::println("{:.3f}", sec);
+}
+```
+* TIME_ACTIVE[color ff0000]
+* std::timespec[link timespec.md]
+* std::timespec_get[link timespec_get.md]
+
+### 出力例
+```
+0.123
+```
+
+
+## バージョン
+### 言語
+- C++26
+
+### 処理系
+- [Clang](/implementation.md#clang): 22 [mark noimpl]
+- [GCC](/implementation.md#gcc): 16.1 [mark noimpl]
+- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl]
+
+
+## 関連項目
+- [`timespec_get()`](timespec_get.md): 指定したベース時間に基づいた、経過秒と経過ナノ秒を取得する
+- [`TIME_THREAD_ACTIVE`](time_thread_active.md): 呼び出しスレッドの処理時間ベースであることを指定する
+
+
+## 参照
+- [P3348R4 C++26 should refer to C23 not C17](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3348r4.html)
+    - C++26がC23を参照するようになり、このマクロが`<ctime>`に追加された

TIME_MONOTONIC -- C++26対応として、C23標準ライブラリを追加 (#1657)

2026-06-08T20:56:08+09:00

diff --git a/reference/ctime/time_monotonic.md b/reference/ctime/time_monotonic.md
new file mode 100644
index 000000000..ce366ec89
--- /dev/null
+++ b/reference/ctime/time_monotonic.md
@@ -0,0 +1,73 @@
+# TIME_MONOTONIC
+* ctime[meta header]
+* macro[meta id-type]
+* cpp26[meta cpp]
+
+```cpp
+#define TIME_MONOTONIC implementation-defined
+```
+
+## 概要
+単調増加の時間ベースであることを指定するための整数定数値。処理系定義のオプションのマクロである。
+
+このベース時間を[`timespec_get()`](timespec_get.md)に指定した場合、処理系定義の基準点からの経過時間を取得する。基準点は処理系定義であり (一般的には実行環境の起動時刻やプログラムの開始時刻)、同一プログラム実行内では、先に発生した呼び出しの結果が後の呼び出しの結果より大きくなることはない (単調増加)。
+
+C23で`<time.h>`に追加されたマクロであり、C++26で`<ctime>`に取り込まれた。
+
+
+## 備考
+- このベース時間は実時間 (wall-clock time) であり、スリープやブロッキングで待機している間の時間も経過に含まれる
+
+
+## 例
+```cpp example
+#include <ctime>
+#include <thread>
+#include <chrono>
+#include <print>
+
+int main()
+{
+  std::timespec t1;
+  std::timespec_get(&t1, TIME_MONOTONIC);
+
+  // 実時間で100ミリ秒待機する
+  std::this_thread::sleep_for(std::chrono::milliseconds(100));
+
+  std::timespec t2;
+  std::timespec_get(&t2, TIME_MONOTONIC);
+
+  // 待機していた実時間が経過として計測される
+  // (秒の差) + (ナノ秒の差を秒に変換)。1秒は1'000'000'000ナノ秒
+  double sec = (t2.tv_sec - t1.tv_sec) + (t2.tv_nsec - t1.tv_nsec) / 1'000'000'000.0;
+  std::println("{:.1f}", sec);
+}
+```
+* TIME_MONOTONIC[color ff0000]
+* std::timespec[link timespec.md]
+* std::timespec_get[link timespec_get.md]
+
+### 出力例
+```
+0.1
+```
+
+
+## バージョン
+### 言語
+- C++26
+
+### 処理系
+- [Clang](/implementation.md#clang): 22 [mark noimpl]
+- [GCC](/implementation.md#gcc): 16.1 [mark noimpl]
+- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl]
+
+
+## 関連項目
+- [`timespec_get()`](timespec_get.md): 指定したベース時間に基づいた、経過秒と経過ナノ秒を取得する
+- [`TIME_UTC`](time_utc.md): UTC時間ベースであることを指定する
+
+
+## 参照
+- [P3348R4 C++26 should refer to C23 not C17](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3348r4.html)
+    - C++26がC23を参照するようになり、このマクロが`<ctime>`に追加された

time_t -- C++26対応として、C23標準ライブラリを追加 (#1657)

2026-06-08T20:56:08+09:00

diff --git a/reference/ctime/time_t.md b/reference/ctime/time_t.md
index e97935058..5af471d7b 100644
--- a/reference/ctime/time_t.md
+++ b/reference/ctime/time_t.md
@@ -46,7 +46,7 @@ int main()
 ```
 * std::time_t[color ff0000]
 * std::time[link time.md.nolink]
-* std::ctime[link ctime.md.nolink]
+* std::ctime[link ctime.md]
 
 ### 出力例
 ```

TIME_THREAD_ACTIVE -- C++26対応として、C23標準ライブラリを追加 (#1657)

2026-06-08T20:56:08+09:00

diff --git a/reference/ctime/time_thread_active.md b/reference/ctime/time_thread_active.md
new file mode 100644
index 000000000..40c0e5dc7
--- /dev/null
+++ b/reference/ctime/time_thread_active.md
@@ -0,0 +1,84 @@
+# TIME_THREAD_ACTIVE
+* ctime[meta header]
+* macro[meta id-type]
+* cpp26[meta cpp]
+
+```cpp
+#define TIME_THREAD_ACTIVE implementation-defined
+```
+
+## 概要
+呼び出しスレッドの処理時間 (CPU時間) ベースであることを指定するための整数定数値。処理系定義のオプションのマクロである。
+
+このベース時間を[`timespec_get()`](timespec_get.md)に指定した場合、呼び出しスレッドに関連する処理時間を取得する。
+
+処理系がスレッドをサポートしない場合、このマクロは定義されない。定義される場合、その値は[`TIME_UTC`](time_utc.md)・[`TIME_MONOTONIC`](time_monotonic.md)・[`TIME_ACTIVE`](time_active.md)とは異なる。
+
+C23で`<time.h>`に追加されたマクロであり、C++26で`<ctime>`に取り込まれた。
+
+
+## 備考
+- このベース時間は呼び出しスレッドが実際にCPUで処理を行った時間 (active processing time) であり、実時間 (wall-clock time) ではない。スリープやブロッキングで待機している間の時間は計測に含まれない
+- スレッドごとに別個の値であり、あるスレッドで取得した値を別のスレッドで[`timespec_get()`](timespec_get.md)・[`timespec_getres()`](timespec_getres.md)のベース引数として使用してはならない
+
+
+## 例
+```cpp example
+#include <ctime>
+#include <thread>
+#include <print>
+
+void worker()
+{
+  std::timespec t1;
+  std::timespec_get(&t1, TIME_THREAD_ACTIVE);
+
+  // このスレッドで実際に計算を行う (スリープでは処理時間は増えない)
+  volatile long sum = 0;
+  for (long i = 0; i < 100'000'000; ++i) {
+    sum += i;
+  }
+
+  std::timespec t2;
+  std::timespec_get(&t2, TIME_THREAD_ACTIVE);
+
+  // このスレッドが計算に費やしたCPU処理時間が計測される
+  // (秒の差) + (ナノ秒の差を秒に変換)。1秒は1'000'000'000ナノ秒
+  double sec = (t2.tv_sec - t1.tv_sec) + (t2.tv_nsec - t1.tv_nsec) / 1'000'000'000.0;
+  std::println("{:.3f}", sec);
+}
+
+int main()
+{
+  std::thread th{worker};
+  th.join();
+}
+```
+* TIME_THREAD_ACTIVE[color ff0000]
+* std::timespec[link timespec.md]
+* std::timespec_get[link timespec_get.md]
+
+### 出力例
+```
+0.123
+```
+
+
+## バージョン
+### 言語
+- C++26
+
+### 処理系
+- [Clang](/implementation.md#clang): 22 [mark noimpl]
+- [GCC](/implementation.md#gcc): 16.1 [mark noimpl]
+- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl]
+
+
+## 関連項目
+- [`timespec_get()`](timespec_get.md): 指定したベース時間に基づいた、経過秒と経過ナノ秒を取得する
+- [`TIME_ACTIVE`](time_active.md): プログラム全体の処理時間ベースであることを指定する
+
+
+## 参照
+- [P3348R4 C++26 should refer to C23 not C17](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3348r4.html)
+    - C++26がC23を参照するようになり、このマクロが`<ctime>`に追加された

timegm -- C++26対応として、C23標準ライブラリを追加 (#1657)

2026-06-08T20:56:08+09:00

diff --git a/reference/ctime/timegm.md b/reference/ctime/timegm.md
new file mode 100644
index 000000000..fa552c652
--- /dev/null
+++ b/reference/ctime/timegm.md
@@ -0,0 +1,76 @@
+# timegm
+* ctime[meta header]
+* std[meta namespace]
+* function[meta id-type]
+* cpp26[meta cpp]
+
+```cpp
+namespace std {
+  time_t timegm(tm* timeptr);
+}
+```
+* time_t[link time_t.md]
+* tm[link tm.md.nolink]
+
+## 概要
+UTCで表現されたカレンダー時間 (`tm`構造体) を、経過秒 ([`time_t`](time_t.md)) に変換する。
+
+[`mktime`](mktime.md.nolink)がローカル時間を解釈するのに対し、この関数は入力をUTCとして解釈する。
+
+C23で`<time.h>`に追加された関数であり、C++26で`<ctime>`に取り込まれた。
+
+
+## 効果
+`timeptr`が指す構造体のカレンダー時間 (UTCとして表現される) を、`time`関数が返す値と同じエンコーディングの経過秒に変換する。
+
+`tm_wday`と`tm_yday`の元の値は無視され、それ以外のメンバは規定の範囲に制限されない。変換に成功した場合、`tm_wday`と`tm_yday`は適切に設定され、その他のメンバは規定の範囲に正規化される。
+
+
+## 戻り値
+指定されたカレンダー時間を[`time_t`](time_t.md)型の値として返す。
+
+カレンダー時間が[`time_t`](time_t.md)で表現できない場合、もしくは`tm_year`が`int`で表現できない場合、`(time_t)(-1)`を返す。
+
+
+## 例
+```cpp example
+#include <ctime>
+#include <print>
+
+int main()
+{
+  std::tm t{};
+  t.tm_year = 2026 - 1900; // 2026年
+  t.tm_mon = 0;            // 1月
+  t.tm_mday = 1;           // 1日
+
+  std::time_t sec = std::timegm(&t);
+  std::println("{}", sec);
+}
+```
+* std::timegm[color ff0000]
+
+### 出力
+```
+1767225600
+```
+
+
+## バージョン
+### 言語
+- C++26
+
+### 処理系
+- [Clang](/implementation.md#clang): 22 [mark noimpl]
+- [GCC](/implementation.md#gcc): 16.1 [mark noimpl]
+- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl]
+
+
+## 関連項目
+- [`mktime`](mktime.md.nolink): ローカル時間のカレンダー時間から経過秒を生成する
+- [`gmtime`](gmtime.md.nolink): 経過秒からUTCのカレンダー時間を生成する
+
+
+## 参照
+- [P3348R4 C++26 should refer to C23 not C17](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3348r4.html)
+    - C++26がC23を参照するようになり、この関数が`<ctime>`に追加された

timespec_getres -- C++26対応として、C23標準ライブラリを追加 (#1657)

2026-06-08T20:56:08+09:00

diff --git a/reference/ctime/timespec_getres.md b/reference/ctime/timespec_getres.md
new file mode 100644
index 000000000..8ea54fc9e
--- /dev/null
+++ b/reference/ctime/timespec_getres.md
@@ -0,0 +1,74 @@
+# timespec_getres
+* ctime[meta header]
+* std[meta namespace]
+* function[meta id-type]
+* cpp26[meta cpp]
+
+```cpp
+namespace std {
+  int timespec_getres(struct timespec* ts, int base);
+}
+```
+* timespec[link timespec.md]
+
+## 概要
+指定したベース時間の分解能を取得する。
+
+C23で`<time.h>`に追加された関数であり、C++26で`<ctime>`に取り込まれた。
+
+
+## 効果
+パラメータ`base`で指定されたベース時間について、[`timespec_get()`](timespec_get.md)が提供する時間の分解能を`ts`に書き込む。
+
+
+## 戻り値
+分解能の取得に成功した場合、非ゼロの値として`base`を返す。失敗した場合はゼロを返す。
+
+
+## 例
+```cpp example
+#include <iostream>
+#include <ctime>
+
+int main()
+{
+  // UTCベース時間の分解能を取得する
+  std::timespec ts;
+  if (std::timespec_getres(&ts, TIME_UTC) == 0) {
+    std::cerr << "分解能の取得に失敗した" << std::endl;
+    return 1;
+  }
+
+  std::cout << "tv_sec:" << ts.tv_sec
+            << " tv_nsec:" << ts.tv_nsec
+            << std::endl;
+}
+```
+* std::timespec_getres[color ff0000]
+* std::timespec[link timespec.md]
+* TIME_UTC[link time_utc.md]
+
+### 出力例
+```
+tv_sec:0 tv_nsec:1
+```
+
+
+## バージョン
+### 言語
+- C++26
+
+### 処理系
+- [Clang](/implementation.md#clang): 22 [mark noimpl]
+- [GCC](/implementation.md#gcc): 16.1 [mark noimpl]
+- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl]
+
+
+## 関連項目
+- [`timespec_get()`](timespec_get.md): 指定したベース時間に基づいた、経過秒と経過ナノ秒を取得する
+- [`timespec`](timespec.md): 経過秒と経過ナノ秒を保持する型
+
+
+## 参照
+- [P3348R4 C++26 should refer to C23 not C17](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3348r4.html)
+    - C++26がC23を参照するようになり、この関数が`<ctime>`に追加された

cuchar -- C++26対応として、C23標準ライブラリを追加 (#1657)

2026-06-08T20:56:08+09:00

cuchar(C++11)

<cuchar>ヘッダでは、マルチバイト文字とUnicode文字 (char8_t、char16_t、char32_t) との変換関数を定義する。これらの機能は、std名前空間に属することを除いてC言語の標準ライブラリ<uchar.h>ヘッダと同じである (ただしchar8_t、char16_t、char32_t型は宣言しない)。

型

名前	説明	対応バージョン
`size_t`	符号なし整数型	C++11
`mbstate_t`	マルチバイト文字とワイド文字の変換状態を保持する型	C++11

変換関数

名前	説明	対応バージョン
`mbrtoc8`	マルチバイト文字を、UTF-8文字 (`char8_t`) に変換する	C++26
`c8rtomb`	UTF-8文字 (`char8_t`) を、マルチバイト文字に変換する	C++26
`mbrtoc16`	マルチバイト文字を、UTF-16文字 (`char16_t`) に変換する	C++11
`c16rtomb`	UTF-16文字 (`char16_t`) を、マルチバイト文字に変換する	C++11
`mbrtoc32`	マルチバイト文字を、UTF-32文字 (`char32_t`) に変換する	C++11
`c32rtomb`	UTF-32文字 (`char32_t`) を、マルチバイト文字に変換する	C++11

バージョン情報マクロ

マクロ	説明	対応バージョン
`__STDC_VERSION_UCHAR_H__`	`<cuchar>`が提供するC標準ライブラリ機能のバージョン (`202311L`)	C++26

バージョン

言語

C++11

参照

P0175R1 Synopses for the C library
P3348R4 C++26 should refer to C23 not C17
- C++26がC23を参照するようになり、mbrtoc8・c8rtomb・__STDC_VERSION_UCHAR_H__が追加された

c8rtomb -- C++26対応として、C23標準ライブラリを追加 (#1657)

2026-06-08T20:56:08+09:00

diff --git a/reference/cuchar/c8rtomb.md b/reference/cuchar/c8rtomb.md
new file mode 100644
index 000000000..4080e137c
--- /dev/null
+++ b/reference/cuchar/c8rtomb.md
@@ -0,0 +1,72 @@
+# c8rtomb
+* cuchar[meta header]
+* std[meta namespace]
+* function[meta id-type]
+* cpp26[meta cpp]
+
+```cpp
+namespace std {
+  size_t c8rtomb(char* s, char8_t c8, mbstate_t* ps);
+}
+```
+* size_t[link /reference/cstddef/size_t.md]
+
+## 概要
+UTF-8文字 (`char8_t`) を、マルチバイト文字に変換する。
+
+C23で`<uchar.h>`に追加された関数であり、C++26で`<cuchar>`に取り込まれた。
+
+
+## 効果
+`s`がヌルポインタの場合、内部バッファを`buf`として`c8rtomb(buf, u8'\0', ps)`の呼び出しと等価である。
+
+`s`がヌルポインタでない場合、`c8`によって与えられた (もしくは完成した) 文字に対応するマルチバイト文字の表現に必要なバイト数を判定し、その表現を`s`が指す配列に格納する。`c8`が完全な文字を表していない場合は何も格納しない。格納されるバイト数は最大で[`MB_CUR_MAX`](/reference/cstdlib/mb_cur_max.md)である。
+
+`c8`がヌル文字の場合、初期シフト状態へ戻すために必要なシフトシーケンスに続けてヌルバイトが格納される。
+
+
+## 戻り値
+配列に格納したバイト数 (シフトシーケンスを含む) を返す。
+
+`c8`が有効な文字でない場合、エンコードエラーとなり、`errno`に`EILSEQ`が格納され`(size_t)(-1)`を返す。このとき変換状態は未規定となる。
+
+
+## 例
+```cpp example
+#include <cuchar>
+#include <print>
+
+int main()
+{
+  char buf[8] = {};
+  std::mbstate_t state{};
+
+  std::size_t r = std::c8rtomb(buf, u8'A', &state);
+  std::println("{} {}", r, buf);
+}
+```
+* std::c8rtomb[color ff0000]
+
+### 出力例
+```
+1 A
+```
+
+
+## バージョン
+### 言語
+- C++26
+
+### 処理系
+- [Clang](/implementation.md#clang): 22 [mark noimpl]
+- [GCC](/implementation.md#gcc): 16.1 [mark noimpl]
+- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl]
+
+
+## 関連項目
+- [`mbrtoc8`](mbrtoc8.md): マルチバイト文字を、UTF-8文字 (`char8_t`) に変換する
+
+
+## 参照
+- [P3348R4 C++26 should refer to C23 not C17](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3348r4.html)
+    - C++26がC23を参照するようになり、この関数が`<cuchar>`に追加された

mbrtoc8 -- C++26対応として、C23標準ライブラリを追加 (#1657)

2026-06-08T20:56:08+09:00

diff --git a/reference/cuchar/mbrtoc8.md b/reference/cuchar/mbrtoc8.md
new file mode 100644
index 000000000..558f85a94
--- /dev/null
+++ b/reference/cuchar/mbrtoc8.md
@@ -0,0 +1,79 @@
+# mbrtoc8
+* cuchar[meta header]
+* std[meta namespace]
+* function[meta id-type]
+* cpp26[meta cpp]
+
+```cpp
+namespace std {
+  size_t mbrtoc8(char8_t* pc8, const char* s, size_t n, mbstate_t* ps);
+}
+```
+* size_t[link /reference/cstddef/size_t.md]
+
+## 概要
+マルチバイト文字を、UTF-8文字 (`char8_t`) に変換する。
+
+C23で`<uchar.h>`に追加された関数であり、C++26で`<cuchar>`に取り込まれた。
+
+
+## 効果
+`s`がヌルポインタの場合、`mbrtoc8(nullptr, "", 1, ps)`の呼び出しと等価である (このとき`pc8`と`n`は無視される)。
+
+`s`がヌルポインタでない場合、`s`が指す位置から最大`n`バイトを検査し、次のマルチバイト文字を完成させるのに必要なバイト数を判定する。次のマルチバイト文字が完全かつ有効であれば、対応する文字の値を決定し、`pc8`がヌルポインタでなければ最初の (もしくは唯一の) 文字を`pc8`が指すオブジェクトに格納する。
+
+1つのマルチバイト文字が複数の`char8_t`に対応する場合、後続の呼び出しでは入力を消費せずに残りの文字を順次格納する。
+
+
+## 戻り値
+変換状態に応じて、以下のうち最初に該当するものを返す。
+
+| 戻り値 | 意味 |
+|--------|------|
+| `0`             | 次の`n`バイト以内で、ヌル文字に対応するマルチバイト文字が完成した |
+| `1`～`n`         | 次の`n`バイト以内で有効なマルチバイト文字が完成した。値はその完成に要したバイト数 |
+| `(size_t)(-3)`  | 前回の呼び出しの結果である次の文字が格納された (入力バイトは消費されない) |
+| `(size_t)(-2)`  | 次の`n`バイトが不完全な (が、潜在的に有効な) マルチバイト文字に寄与し、すべての`n`バイトを処理した (値は格納されない) |
+| `(size_t)(-1)`  | エンコードエラー。`errno`に`EILSEQ`が格納され、変換状態は未規定となる |
+
+
+## 例
+```cpp example
+#include <cuchar>
+#include <print>
+
+int main()
+{
+  const char src[] = "A";
+  char8_t c8;
+  std::mbstate_t state{};
+
+  std::size_t r = std::mbrtoc8(&c8, src, sizeof(src), &state);
+  std::println("{} {}", r, static_cast<int>(c8));
+}
+```
+* std::mbrtoc8[color ff0000]
+
+### 出力例
+```
+1 65
+```
+
+
+## バージョン
+### 言語
+- C++26
+
+### 処理系
+- [Clang](/implementation.md#clang): 22 [mark noimpl]
+- [GCC](/implementation.md#gcc): 16.1 [mark noimpl]
+- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl]
+
+
+## 関連項目
+- [`c8rtomb`](c8rtomb.md): UTF-8文字 (`char8_t`) を、マルチバイト文字に変換する
+
+
+## 参照
+- [P3348R4 C++26 should refer to C23 not C17](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3348r4.html)
+    - C++26がC23を参照するようになり、この関数が`<cuchar>`に追加された

execution -- execution: P4154R0対応(#1652)

2026-06-08T10:24:20+09:00

diff --git a/reference/execution/execution.md b/reference/execution/execution.md
index d941f609b..4d6f0e2d0 100644
--- a/reference/execution/execution.md
+++ b/reference/execution/execution.md
@@ -182,7 +182,7 @@ Senderコンシューマは名前空間 `std::this_thread` および名前空間
 |------|------|----------------|
 | [`execution::parallel_scheduler`](execution/parallel_scheduler.md) | 並列Scheduler (class) | C++26 |
 | [`execution::get_parallel_scheduler`](execution/get_parallel_scheduler.md) | 並列Schedulerを取得 (function) | C++26 |
-| [`execution::system_context_replaceability`](execution/system_context_replaceability.md) | `parallel_scheduler`動作カスタマイズ用の名前空間 (namespace) | C++26 |
+| [`execution::parallel_scheduler_replacement`](execution/parallel_scheduler_replacement.md) | `parallel_scheduler`動作カスタマイズ用の名前空間 (namespace) | C++26 |
 
 
 ## バージョン
@@ -207,3 +207,4 @@ Senderコンシューマは名前空間 `std::this_thread` および名前空間
 - [P3941R4 Scheduler Affinity](https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2026/p3941r4.html)
 - [P4151R1 Rename `affine_on`](https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2026/p4151r1.pdf)
 - [P4159R0 Make `sender_in` and `receiver_of` exposition-only](https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2026/p4159r0.html)
+- [P4154R0 Renaming various execution things](https://open-std.org/jtc1/sc22/wg21/docs/papers/2026/p4154r0.html)

get_parallel_scheduler -- execution: P4154R0対応(#1652)

2026-06-08T10:24:20+09:00

diff --git a/reference/execution/execution/get_parallel_scheduler.md b/reference/execution/execution/get_parallel_scheduler.md
index a29bd63aa..ad6b214c9 100644
--- a/reference/execution/execution/get_parallel_scheduler.md
+++ b/reference/execution/execution/get_parallel_scheduler.md
@@ -12,11 +12,11 @@ namespace std::execution {
 * parallel_scheduler[link parallel_scheduler.md]
 
 ## 概要
-システムの[並列Scheduler](parallel_scheduler.md)を取得する。
+[並列Scheduler](parallel_scheduler.md)を取得する。
 
 
 ## 効果
-説明用の`eb`を[`system_context_replaceability::query_parallel_scheduler_backend()`](system_context_replaceability/query_parallel_scheduler_backend.md)の結果とする。
+説明用の`eb`を[`parallel_scheduler_replacement::query_parallel_scheduler_backend()`](parallel_scheduler_replacement/query_parallel_scheduler_backend.md)の結果とする。
 
 もし`eb == nullptr`ならば、[`terminate`](/reference/exception/terminate.md)を呼び出す。そうでなければ、`eb`に関連付けられた[`parallel_scheduler`](parallel_scheduler.md)オブジェクトを返す。
 
@@ -52,7 +52,7 @@ int main()
 
 ## 関連項目
 - [`execution::parallel_scheduler`](parallel_scheduler.md)
-- [`execution::system_context_replaceability`](system_context_replaceability.md)
+- [`execution::parallel_scheduler_replacement`](parallel_scheduler_replacement.md)
 
 
 ## 参照

parallel_scheduler -- execution: P4154R0対応(#1652)

2026-06-08T10:24:20+09:00

diff --git a/reference/execution/execution/parallel_scheduler.md b/reference/execution/execution/parallel_scheduler.md
index 8c0971575..3331b792c 100644
--- a/reference/execution/execution/parallel_scheduler.md
+++ b/reference/execution/execution/parallel_scheduler.md
@@ -14,7 +14,7 @@ namespace std::execution {
 ## 概要
 `parallel_scheduler`は、実行制御ライブラリ上でタスクの並列実行を可能とする並列[Scheduler](scheduler.md)である。
 
-`parallel_scheduler`はシステムグローバルなスレッドプール（実行リソース）に関連付けられ、[`schedule`](schedule.md)操作により得られる[Sender](sender.md)はスレッドプールに属する任意のスレッド（実行エージェント）上で実行される。
+`parallel_scheduler`はグローバルなスレッドプール（実行リソース）に関連付けられ、[`schedule`](schedule.md)操作により得られる[Sender](sender.md)はスレッドプールに属する任意のスレッド（実行エージェント）上で実行される。
 
 下記のSenderアルゴリズムに対してカスタマイズ実装を提供することで、タスクの一括(bulk)実行をスレッドプールを利用したタスク並列(parallel)実行に変換する。
 
@@ -22,7 +22,7 @@ namespace std::execution {
 - [`execution::bulk_chunked`](bulk_chunked.md) : インデクス範囲をチャンク単位でタスク並列実行
 - [`execution::bulk_unchunked`](bulk_unchunked.md) : インデクス範囲を要素単位でタスク並列実行
 
-[`execution::system_context_replaceability`](system_context_replaceability.md) 名前空間で定義されるインタフェースを介して、スレッドプール実装をユーザ定義の並列Schedulerバックエンドに置き換えることもできる。
+[`execution::parallel_scheduler_replacement`](parallel_scheduler_replacement.md) 名前空間で定義されるインタフェースを介して、スレッドプール実装をユーザ定義の並列Schedulerバックエンドに置き換えることもできる。
 
 
 ## クラス仕様
@@ -79,8 +79,8 @@ auto& [pol, shape, f] = data;
 ### `schedule`アルゴリズム
 説明用の`b`を`BACKEND-OF(sch)`、`sndr`を[`schedule`](schedule.md)`(sch)`が返すオブジェクト、`rcvr`を[Receiver](receiver.md)とする。`rcvr`が`sndr`に[接続(connect)](connect.md)され、結果の[Operation State](operation_state.md)が[開始(start)](start.md)されたとき、
 
-- `sndr`が値完了するならば、[`b.schedule`](system_context_replaceability/parallel_scheduler_backend/schedule.md)`(r, s)`が呼ばれる。このとき、
-    - `r`は基底[`system_context_replaceability::receiver_proxy`](system_context_replaceability/receiver_proxy.md)を持つ`rcvr`のプロキシであり、かつ
+- `sndr`が値完了するならば、[`b.schedule`](parallel_scheduler_replacement/parallel_scheduler_backend/schedule.md)`(r, s)`が呼ばれる。このとき、
+    - `r`は基底[`parallel_scheduler_replacement::receiver_proxy`](parallel_scheduler_replacement/receiver_proxy.md)を持つ`rcvr`のプロキシであり、かつ
     - `s`は`r`に対する事前確保バックエンドストレージである。
 - 他の全ての完了操作は、変更なしに転送される。
 
@@ -88,8 +88,8 @@ auto& [pol, shape, f] = data;
 ### `bulk_chunked`アルゴリズム
 タグ`bulk_chunked`と[Sender](sender.md)を受け付ける`transform_sender`オーバーロードは、[Receiver](receiver.md)`rcvr`と[接続(connect)](connect.md)され結果の[Operation State](operation_state.md)が[開始(start)](start.md)されたとき、下記動作を行うSenderを返す。
 
-- `child`が値`vals`で値完了するならば、`args`を`vals`を指す左辺値式のパックとして、[`b.schedule_bulk_chunked`](system_context_replaceability/parallel_scheduler_backend/schedule_bulk_chunked.md)`(p ? shape : 1, r, s)`が呼ばれる。このとき、
-    - `r`は基底クラス[`system_context_replaceability::bulk_item_receiver_proxy`](system_context_replaceability/bulk_item_receiver_proxy.md)を持つ`rcvr`のプロキシであり、インデックス`i`, `j`に対して`r.execute(i, j)`は`p`が`true`のとき`f(i, j, args...)`、そうでないときは`f(0, shape, args...)`と等価な効果を持つ。かつ
+- `child`が値`vals`で値完了するならば、`args`を`vals`を指す左辺値式のパックとして、[`b.schedule_bulk_chunked`](parallel_scheduler_replacement/parallel_scheduler_backend/schedule_bulk_chunked.md)`(p ? shape : 1, r, s)`が呼ばれる。このとき、
+    - `r`は基底クラス[`parallel_scheduler_replacement::bulk_item_receiver_proxy`](parallel_scheduler_replacement/bulk_item_receiver_proxy.md)を持つ`rcvr`のプロキシであり、インデックス`i`, `j`に対して`r.execute(i, j)`は`p`が`true`のとき`f(i, j, args...)`、そうでないときは`f(0, shape, args...)`と等価な効果を持つ。かつ
     - `s`は`r`に対する事前確保バックエンドストレージである。
 - 他の全ての完了操作は、変更なしに転送される。
 
@@ -97,8 +97,8 @@ auto& [pol, shape, f] = data;
 ### `bulk_unchunked`アルゴリズム
 タグ`bulk_unchunked`と[Sender](sender.md)を受け付ける`transform_sender`オーバーロードは、[Receiver](receiver.md)`rcvr`と[接続(connect)](connect.md)され結果の[Operation State](operation_state.md)が[開始(start)](start.md)されたとき、下記動作を行うSenderを返す。
 
-- `child`が値`vals`で値完了するならば、`args`を`vals`を指す左辺値式のパックとして、[`b.schedule_bulk_unchunked`](system_context_replaceability/parallel_scheduler_backend/schedule_bulk_unchunked.md)`(p ? shape : 1, r, s)`が呼ばれる。このとき、
-    - `r`は基底クラス[`system_context_replaceability::bulk_item_receiver_proxy`](system_context_replaceability/bulk_item_receiver_proxy.md)を持つ`rcvr`のプロキシであり、インデックス`i`に対して`r.execute(i, i + 1)`は`p`が`true`のとき`f(i, args...)`、そうでないときは`for (decltype(shape) i = 0; i < shape; i++) { f(i, args...); }`と等価な効果を持つ。かつ
+- `child`が値`vals`で値完了するならば、`args`を`vals`を指す左辺値式のパックとして、[`b.schedule_bulk_unchunked`](parallel_scheduler_replacement/parallel_scheduler_backend/schedule_bulk_unchunked.md)`(p ? shape : 1, r, s)`が呼ばれる。このとき、
+    - `r`は基底クラス[`parallel_scheduler_replacement::bulk_item_receiver_proxy`](parallel_scheduler_replacement/bulk_item_receiver_proxy.md)を持つ`rcvr`のプロキシであり、インデックス`i`に対して`r.execute(i, i + 1)`は`p`が`true`のとき`f(i, args...)`、そうでないときは`for (decltype(shape) i = 0; i < shape; i++) { f(i, args...); }`と等価な効果を持つ。かつ
     - `s`は`r`に対する事前確保バックエンドストレージである。
 - 他の全ての完了操作は、変更なしに転送される。
 
@@ -137,7 +137,7 @@ int main()
 
 ## 関連項目
 - [`execution::get_parallel_scheduler`](get_parallel_scheduler.md)
-- [`execution::system_context_replaceability`](system_context_replaceability.md)
+- [`execution::parallel_scheduler_replacement`](parallel_scheduler_replacement.md)
 
 
 ## 参照

parallel_scheduler_replacement -- execution: P4154R0対応(#1652)

2026-06-08T10:24:20+09:00

diff --git a/reference/execution/execution/parallel_scheduler_replacement.md b/reference/execution/execution/parallel_scheduler_replacement.md
new file mode 100644
index 000000000..899134a9e
--- /dev/null
+++ b/reference/execution/execution/parallel_scheduler_replacement.md
@@ -0,0 +1,41 @@
+# parallel_scheduler_replacement
+* execution[meta header]
+* std::execution[meta namespace]
+* namespace[meta id-type]
+* cpp26[meta cpp]
+
+名前空間 `std::execution::parallel_scheduler_replacement` では、[並列Scheduler](parallel_scheduler.md)動作をユーザが差し替えるためのインタフェースを定義する。
+
+```cpp
+namespace std::execution::parallel_scheduler_replacement {
+  …
+}
+```
+
+[並列Scheduler](parallel_scheduler.md)をユーザ実装で置き換える場合、下記が必要となる。
+
+- [`parallel_scheduler_replacement::parallel_scheduler_backend`](parallel_scheduler_replacement/parallel_scheduler_backend.md)インターフェースをバックエンドにもつ並列Schedulerを実装する。
+- 処理系の手順に従って、[`parallel_scheduler_replacement::query_parallel_scheduler_backend`](parallel_scheduler_replacement/query_parallel_scheduler_backend.md)シンボルを自前バックエンド実装を返す関数で置き換える。
+
+
+| 名前 | 説明 | 対応バージョン |
+|------|------|----------------|
+| [`receiver_proxy`](parallel_scheduler_replacement/receiver_proxy.md) | バックエンド実装用のReceiverプロキシ (class) | C++26 |
+| [`bulk_item_receiver_proxy`](parallel_scheduler_replacement/bulk_item_receiver_proxy.md) | バックエンド実装用のバルク処理Receiverプロキシ (class) | C++26 |
+| [`parallel_scheduler_backend`](parallel_scheduler_replacement/parallel_scheduler_backend.md) | 並列Schedulerバックエンド (class) | C++26 |
+| [`query_parallel_scheduler_backend`](parallel_scheduler_replacement/query_parallel_scheduler_backend.md) | 並列Schedulerバックエンドを問い合わせ (function) | C++26 |
+
+
+## バージョン
+### 言語
+- C++26
+
+
+## 関連項目
+- [`execution::parallel_scheduler`](parallel_scheduler.md)
+
+
+## 参照
+- [P2300R10 `std::execution`](https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2024/p2300r10.html)
+- [P2079R10 Parallel scheduler](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p2079r10.html)
+- [P4154R0 Renaming various execution things](https://open-std.org/jtc1/sc22/wg21/docs/papers/2026/p4154r0.html)

bulk_item_receiver_proxy -- execution: P4154R0対応(#1652)

2026-06-08T10:24:20+09:00

diff --git a/reference/execution/execution/parallel_scheduler_replacement/bulk_item_receiver_proxy.md b/reference/execution/execution/parallel_scheduler_replacement/bulk_item_receiver_proxy.md
new file mode 100644
index 000000000..027fd7ef6
--- /dev/null
+++ b/reference/execution/execution/parallel_scheduler_replacement/bulk_item_receiver_proxy.md
@@ -0,0 +1,42 @@
+# bulk_item_receiver_proxy
+* execution[meta header]
+* class[meta id-type]
+* std::execution::parallel_scheduler_replacement[meta namespace]
+* cpp26[meta cpp]
+
+```cpp
+namespace std::execution::parallel_scheduler_replacement {
+  struct bulk_item_receiver_proxy : receiver_proxy { see below };
+}
+```
+* receiver_proxy[link receiver_proxy.md]
+
+## 概要
+`bulk_item_receiver_proxy`は、[`receiver_proxy`](receiver_proxy.md)から派生したクラス。
+[`bulk_chunked`](../bulk_chunked.md)および[`bulk_unchunked`](../bulk_unchunked.md)のカスタマイズで用いられ、異なる反復に対応する[`parallel_scheduler_backend`](parallel_scheduler_backend.md)実装から通知も受信する。
+
+
+## メンバ関数
+
+| 名前 | 説明 | 対応バージョン |
+|------|------|----------------|
+| `virtual void execute(size_t, size_t) noexcept = 0;` | 要素範囲の作業ハンドラ | C++26 |
+
+
+## バージョン
+### 言語
+- C++26
+
+### 処理系
+- [Clang](/implementation.md#clang): ??
+- [GCC](/implementation.md#gcc): ??
+- [ICC](/implementation.md#icc): ??
+- [Visual C++](/implementation.md#visual_cpp): ??
+
+
+## 関連項目
+- [`execution::parallel_scheduler`](../parallel_scheduler.md)
+
+
+## 参照
+- [P2079R10 Parallel scheduler](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p2079r10.html)

parallel_scheduler_backend -- execution: P4154R0対応(#1652)

2026-06-08T10:24:20+09:00

diff --git a/reference/execution/execution/parallel_scheduler_replacement/parallel_scheduler_backend.md b/reference/execution/execution/parallel_scheduler_replacement/parallel_scheduler_backend.md
new file mode 100644
index 000000000..d76a1e844
--- /dev/null
+++ b/reference/execution/execution/parallel_scheduler_replacement/parallel_scheduler_backend.md
@@ -0,0 +1,44 @@
+# parallel_scheduler_backend
+* execution[meta header]
+* class[meta id-type]
+* std::execution::parallel_scheduler_replacement[meta namespace]
+* cpp26[meta cpp]
+
+```cpp
+namespace std::execution::parallel_scheduler_replacement {
+  struct parallel_scheduler_backend;
+}
+```
+
+## 概要
+`parallel_scheduler_backend`は、[並列Scheduler](../parallel_scheduler.md)バックエンド実装者向けのインタフェースを定義する。
+
+
+## メンバ関数
+
+| 名前 | 説明 | 対応バージョン |
+|------|------|----------------|
+| [`(destructor)`](parallel_scheduler_backend/op_destructor.md) | デストラクタ | C++26 |
+| [`schedule`](parallel_scheduler_backend/schedule.md) | [`schedule`](../schedule.md)アルゴリズム動作カスタマイズ | C++26 |
+| [`schedule_bulk_chunked`](parallel_scheduler_backend/schedule_bulk_chunked.md) | [`bulk_chunked`](../bulk_chunked.md)アルゴリズム動作カスタマイズ | C++26 |
+| [`schedule_bulk_unchunked`](parallel_scheduler_backend/schedule_bulk_unchunked.md) | [`bulk_unchunked`](../bulk_unchunked.md)アルゴリズム動作カスタマイズ | C++26 |
+
+
+## バージョン
+### 言語
+- C++26
+
+### 処理系
+- [Clang](/implementation.md#clang): ??
+- [GCC](/implementation.md#gcc): ??
+- [ICC](/implementation.md#icc): ??
+- [Visual C++](/implementation.md#visual_cpp): ??
+
+
+## 関連項目
+- [`execution::parallel_scheduler`](../parallel_scheduler.md)
+- [`execution::parallel_scheduler_replacement::query_parallel_scheduler_backend`](query_parallel_scheduler_backend.md)
+
+
+## 参照
+- [P2079R10 Parallel scheduler](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p2079r10.html)

デストラクタ -- execution: P4154R0対応(#1652)

2026-06-08T10:24:20+09:00

diff --git a/reference/execution/execution/parallel_scheduler_replacement/parallel_scheduler_backend/op_destructor.md b/reference/execution/execution/parallel_scheduler_replacement/parallel_scheduler_backend/op_destructor.md
new file mode 100644
index 000000000..5a508bb19
--- /dev/null
+++ b/reference/execution/execution/parallel_scheduler_replacement/parallel_scheduler_backend/op_destructor.md
@@ -0,0 +1,28 @@
+# デストラクタ
+* execution[meta header]
+* std::execution::parallel_scheduler_replacement[meta namespace]
+* parallel_scheduler_backend[meta class]
+* function[meta id-type]
+* cpp26[meta cpp]
+
+```cpp
+virtual ~parallel_scheduler_backend() = default;
+```
+
+## 概要
+`parallel_scheduler_backend`オブジェクトを破棄する。
+
+
+## バージョン
+### 言語
+- C++26
+
+### 処理系
+- [Clang](/implementation.md#clang): ??
+- [GCC](/implementation.md#gcc): ??
+- [ICC](/implementation.md#icc): ??
+- [Visual C++](/implementation.md#visual_cpp): ??
+
+
+## 参照
+- [P2079R10 Parallel scheduler](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p2079r10.html)

schedule -- execution: P4154R0対応(#1652)

2026-06-08T10:24:20+09:00

diff --git a/reference/execution/execution/parallel_scheduler_replacement/parallel_scheduler_backend/schedule.md b/reference/execution/execution/parallel_scheduler_replacement/parallel_scheduler_backend/schedule.md
new file mode 100644
index 000000000..7565aa1b0
--- /dev/null
+++ b/reference/execution/execution/parallel_scheduler_replacement/parallel_scheduler_backend/schedule.md
@@ -0,0 +1,55 @@
+# schedule
+* execution[meta header]
+* std::execution::parallel_scheduler_replacement[meta namespace]
+* parallel_scheduler_backend[meta class]
+* function[meta id-type]
+* cpp26[meta cpp]
+
+```cpp
+virtual void schedule(receiver_proxy& r, span<byte> s) noexcept = 0;
+```
+* receiver_proxy[link ../receiver_proxy.md]
+* span[link /reference/span/span.md]
+* byte[link /reference/cstddef/byte.md]
+
+## 概要
+[`parallel_scheduler`](../../parallel_scheduler.md)による[`schedule`](../../schedule.md)アルゴリズムカスタマイズのバックエンド側を実装する。
+
+
+## 事前条件
+`*this`、`r`が参照するオブジェクト、`s`が参照するストレージの生存期間終了は、`r`に対する[`set_value`](../../set_value.md)／[`set_error`](../../set_error.md)／[`set_stopped`](../../set_stopped.md)いずれかの呼び出しの評価開始よりも後に発生すること。
+
+
+## 効果
+派生クラスでは、この関数を下記のように実装すべきである。
+
+- 下記いずれかの式が評価される
+    - エラーが発生せず作業が成功したとき、[`r.set_value()`](../receiver_proxy.md)
+    - エラーが発生したとき、`eptr`を[`exception_ptr`](/reference/exception/exception_ptr.md)型のオブジェクトとして、[`r.set_error`](../receiver_proxy.md)`(eptr)`
+    - 作業がキャンセルされたとき、[`r.set_stopped()`](../receiver_proxy.md)
+- 任意の`r.set_value()`呼び出しは、`*this`で表される実行コンテキストの実行エージェント上で発生する。
+
+
+## 備考
+`s`が参照するストレージは、この呼び出しによって開始された操作の実行期間中`*this`によって一時的なストレージとして使用される可能性がある。
+
+
+## バージョン
+### 言語
+- C++26
+
+### 処理系
+- [Clang](/implementation.md#clang): ??
+- [GCC](/implementation.md#gcc): ??
+- [ICC](/implementation.md#icc): ??
+- [Visual C++](/implementation.md#visual_cpp): ??
+
+
+## 関連項目
+- [`execution::schedule`](../../schedule.md)
+- [`execution::parallel_scheduler`](../../parallel_scheduler.md)
+
+
+## 参照
+- [P2079R10 Parallel scheduler](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p2079r10.html)
+- [P3914R0 Assorted NB comment resolutions for Kona 2025](https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3914r0.html), US 265-398, 266-399

schedule_bulk_chunked -- execution: P4154R0対応(#1652)

2026-06-08T10:24:20+09:00

diff --git a/reference/execution/execution/parallel_scheduler_replacement/parallel_scheduler_backend/schedule_bulk_chunked.md b/reference/execution/execution/parallel_scheduler_replacement/parallel_scheduler_backend/schedule_bulk_chunked.md
new file mode 100644
index 000000000..3cb5c02eb
--- /dev/null
+++ b/reference/execution/execution/parallel_scheduler_replacement/parallel_scheduler_backend/schedule_bulk_chunked.md
@@ -0,0 +1,61 @@
+# schedule_bulk_chunked
+* execution[meta header]
+* std::execution::parallel_scheduler_replacement[meta namespace]
+* parallel_scheduler_backend[meta class]
+* function[meta id-type]
+* cpp26[meta cpp]
+
+```cpp
+virtual void schedule_bulk_chunked(size_t n,
+                                   bulk_item_receiver_proxy& r,
+                                   span<byte> s) noexcept = 0;
+```
+* bulk_item_receiver_proxy[link ../bulk_item_receiver_proxy.md]
+* span[link /reference/span/span.md]
+* byte[link /reference/cstddef/byte.md]
+
+## 概要
+[`parallel_scheduler`](../../parallel_scheduler.md)による[`bulk_chunked`](../../bulk_chunked.md)アルゴリズムカスタマイズのバックエンド側を実装する。
+
+
+## 事前条件
+`*this`、`r`が参照するオブジェクト、`s`が参照するストレージの生存期間終了は、`r`に対する[`set_value`](../../set_value.md)／[`set_error`](../../set_error.md)／[`set_stopped`](../../set_stopped.md)いずれかの呼び出しの評価開始よりも後に発生すること。
+
+
+## 効果
+派生クラスでは、この関数を下記のように実装すべきである。
+
+- 下記いずれかの式が評価される
+    - エラーが発生せず作業が成功したとき、[`r.set_value()`](../receiver_proxy.md)
+    - エラーが発生したとき、`eptr`を[`exception_ptr`](/reference/exception/exception_ptr.md)型のオブジェクトとして、[`r.set_error`](../receiver_proxy.md)`(eptr)`
+    - 作業がキャンセルされたとき、[`r.set_stopped()`](../receiver_proxy.md)
+- [`r.execute`](../bulk_item_receiver_proxy.md)`(b, e)`が呼ばれたとき、`b`と`e`は範囲`[0, n)`内かつ`b < e`である
+- 範囲`[0, n)`の各`i`について、`i`が`[b, e)`の範囲内にある[`r.execute`](../bulk_item_receiver_proxy.md)`(b, e)`の呼び出しが最大で1つだけ存在する。
+- `r.set_value()`が呼び出されたとき、`[0, n)`の各`i`に対して、`i`が`[b, e)`の範囲内となる[`r.execute`](../bulk_item_receiver_proxy.md)`(b, e)`の呼び出しが正確に1つだけ存在する。
+- `r`上での全ての`execute`呼び出しは、`r`上での`set_value`／`set_error`／`set_stopped`いずれかの呼び出しよりも前に発生する。
+- `r`上での全ての`execute`および`set_value`呼び出しは、`*this`で表される実行コンテキストの実行エージェント上で行われる。
+
+
+## 備考
+`s`が参照するストレージは、この呼び出しによって開始された操作の実行期間中`*this`によって一時的なストレージとして使用される可能性がある。
+
+
+## バージョン
+### 言語
+- C++26
+
+### 処理系
+- [Clang](/implementation.md#clang): ??
+- [GCC](/implementation.md#gcc): ??
+- [ICC](/implementation.md#icc): ??
+- [Visual C++](/implementation.md#visual_cpp): ??
+
+
+## 関連項目
+- [`execution::bulk_chunked`](../../bulk_chunked.md)
+- [`execution::parallel_scheduler`](../../parallel_scheduler.md)
+
+
+## 参照
+- [P2079R10 Parallel scheduler](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p2079r10.html)
+- [P3914R0 Assorted NB comment resolutions for Kona 2025](https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3914r0.html), US 265-398, 266-399

schedule_bulk_unchunked -- execution: P4154R0対応(#1652)

2026-06-08T10:24:20+09:00

diff --git a/reference/execution/execution/parallel_scheduler_replacement/parallel_scheduler_backend/schedule_bulk_unchunked.md b/reference/execution/execution/parallel_scheduler_replacement/parallel_scheduler_backend/schedule_bulk_unchunked.md
new file mode 100644
index 000000000..6cbbbb7b7
--- /dev/null
+++ b/reference/execution/execution/parallel_scheduler_replacement/parallel_scheduler_backend/schedule_bulk_unchunked.md
@@ -0,0 +1,60 @@
+# schedule_bulk_unchunked
+* execution[meta header]
+* std::execution::parallel_scheduler_replacement[meta namespace]
+* parallel_scheduler_backend[meta class]
+* function[meta id-type]
+* cpp26[meta cpp]
+
+```cpp
+virtual void schedule_bulk_unchunked(size_t n,
+                                     bulk_item_receiver_proxy& r,
+                                     span<byte> s) noexcept = 0;
+```
+* bulk_item_receiver_proxy[link ../bulk_item_receiver_proxy.md]
+* span[link /reference/span/span.md]
+* byte[link /reference/cstddef/byte.md]
+
+## 概要
+[`parallel_scheduler`](../../parallel_scheduler.md)による[`bulk_unchunked`](../../bulk_unchunked.md)アルゴリズムカスタマイズのバックエンド側を実装する。
+
+
+## 事前条件
+`*this`、`r`が参照するオブジェクト、`s`が参照するストレージの生存期間終了は、`r`に対する[`set_value`](../../set_value.md)／[`set_error`](../../set_error.md)／[`set_stopped`](../../set_stopped.md)いずれかの呼び出しの評価開始よりも後に発生すること。
+
+
+## 効果
+派生クラスでは、この関数を下記のように実装すべきである。
+
+- 下記いずれかの式が評価される
+    - エラーが発生せず作業が成功したとき、[`r.set_value()`](../receiver_proxy.md)
+    - エラーが発生したとき、`eptr`を[`exception_ptr`](/reference/exception/exception_ptr.md)型のオブジェクトとして、[`r.set_error`](../receiver_proxy.md)`(eptr)`
+    - 作業がキャンセルされたとき、[`r.set_stopped()`](../receiver_proxy.md)
+- [`r.execute`](../bulk_item_receiver_proxy.md)`(b, e)`が呼ばれたとき、`b`は範囲`[0, n)`内かつ`e`は`b + 1`に等しい。`[0, n)`の各`i`について、[`r.execute`](../bulk_item_receiver_proxy.md)`(i, i + 1)`の呼び出しが最大で1つだけ存在する。
+- `r.set_value()`が呼び出されたとき、`[0, n)`の各`i`に対して、[`r.execute`](../bulk_item_receiver_proxy.md)`(i, i + 1)`の呼び出しが正確に1つだけ存在する。
+- `r`上での全ての`execute`呼び出しは、`r`上での`set_value`／`set_error`／`set_stopped`いずれかの呼び出しよりも前に発生する。
+- `r`上での全ての`execute`および`set_value`呼び出しは、`*this`で表される実行コンテキストの実行エージェント上で行われる。
+
+
+## 備考
+`s`が参照するストレージは、この呼び出しによって開始された操作の実行期間中`*this`によって一時的なストレージとして使用される可能性がある。
+
+
+## バージョン
+### 言語
+- C++26
+
+### 処理系
+- [Clang](/implementation.md#clang): ??
+- [GCC](/implementation.md#gcc): ??
+- [ICC](/implementation.md#icc): ??
+- [Visual C++](/implementation.md#visual_cpp): ??
+
+
+## 関連項目
+- [`execution::bulk_unchunked`](../../bulk_unchunked.md)
+- [`execution::parallel_scheduler`](../../parallel_scheduler.md)
+
+
+## 参照
+- [P2079R10 Parallel scheduler](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p2079r10.html)
+- [P3914R0 Assorted NB comment resolutions for Kona 2025](https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3914r0.html), US 265-398, 266-399

query_parallel_scheduler_backend -- execution: P4154R0対応(#1652)

2026-06-08T10:24:20+09:00

diff --git a/reference/execution/execution/parallel_scheduler_replacement/query_parallel_scheduler_backend.md b/reference/execution/execution/parallel_scheduler_replacement/query_parallel_scheduler_backend.md
new file mode 100644
index 000000000..273bbeb74
--- /dev/null
+++ b/reference/execution/execution/parallel_scheduler_replacement/query_parallel_scheduler_backend.md
@@ -0,0 +1,45 @@
+# query_parallel_scheduler_backend
+* execution[meta header]
+* function[meta id-type]
+* std::execution::parallel_scheduler_replacement[meta namespace]
+* cpp26[meta cpp]
+
+```cpp
+namespace std::execution::parallel_scheduler_replacement {
+  shared_ptr<parallel_scheduler_backend> query_parallel_scheduler_backend();
+}
+```
+* parallel_scheduler_backend[link parallel_scheduler_backend.md]
+
+## 概要
+[並列Scheduler](../parallel_scheduler.md)の実装オブジェクトを返す。
+
+
+## 効果
+オブジェクト`p`は、`p.get()`がその生存期間内に最派生オブジェクト`o`基底クラスの部分オブジェクトである[`parallel_scheduler_backend`](parallel_scheduler_backend.md)オブジェクトを指すものとする。
+その存続期間内に`q.`[`owner_equal`](/reference/memory/shared_ptr/owner_equal.md)`(p)`が`true`となる[`shared_ptr`](/reference/memory/shared_ptr.md)オブジェクト`q`が存在する限り、`o`の存続期間は終了しない。
+
+
+## 備考
+この関数は置換可能(replaceable)である。
+
+
+## バージョン
+### 言語
+- C++26
+
+### 処理系
+- [Clang](/implementation.md#clang): ??
+- [GCC](/implementation.md#gcc): ??
+- [ICC](/implementation.md#icc): ??
+- [Visual C++](/implementation.md#visual_cpp): ??
+
+
+## 関連項目
+- [`execution::parallel_scheduler`](../parallel_scheduler.md)
+- [`execution::parallel_scheduler_replacement::parallel_scheduler_backend`](parallel_scheduler_backend.md)
+
+
+## 参照
+- [P2079R10 Parallel scheduler](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p2079r10.html)
+- [P3914R0 Assorted NB comment resolutions for Kona 2025](https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3914r0.html), US 263-396

receiver_proxy -- execution: P4154R0対応(#1652)

2026-06-08T10:24:20+09:00

diff --git a/reference/execution/execution/parallel_scheduler_replacement/receiver_proxy.md b/reference/execution/execution/parallel_scheduler_replacement/receiver_proxy.md
new file mode 100644
index 000000000..d3b414b8c
--- /dev/null
+++ b/reference/execution/execution/parallel_scheduler_replacement/receiver_proxy.md
@@ -0,0 +1,44 @@
+# receiver_proxy
+* execution[meta header]
+* class[meta id-type]
+* std::execution::parallel_scheduler_replacement[meta namespace]
+* cpp26[meta cpp]
+
+```cpp
+namespace std::execution::parallel_scheduler_replacement {
+  struct receiver_proxy;
+}
+```
+
+## 概要
+`receiver_proxy`は、[`parallel_scheduler_backend`](parallel_scheduler_backend.md)実装から完了操作のトリガー通知を受け取る[`Receiver`](../receiver.md)を表現する。
+
+
+## メンバ関数
+
+| 名前 | 説明 | 対応バージョン |
+|------|------|----------------|
+| `virtual void set_value() noexcept = 0;` | 値完了ハンドラ | C++26 |
+| `virtual void set_error(exception_ptr) noexcept = 0;` | エラー完了ハンドラ | C++26 |
+| `virtual void set_stopped() noexcept = 0;` | 停止完了ハンドラ | C++26 |
+| [`try_query`](receiver_proxy/try_query.md) | クエリオブジェクト問い合わせ | C++26 |
+
+
+## バージョン
+### 言語
+- C++26
+
+### 処理系
+- [Clang](/implementation.md#clang): ??
+- [GCC](/implementation.md#gcc): ??
+- [ICC](/implementation.md#icc): ??
+- [Visual C++](/implementation.md#visual_cpp): ??
+
+
+## 関連項目
+- [`execution::parallel_scheduler`](../parallel_scheduler.md)
+
+
+## 参照
+- [P2079R10 Parallel scheduler](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p2079r10.html)
+- [P3804R2 Iterating on `parallel_scheduler`](https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2026/p3804r2.html)

try_query -- execution: P4154R0対応(#1652)

2026-06-08T10:24:20+09:00

diff --git a/reference/execution/execution/parallel_scheduler_replacement/receiver_proxy/try_query.md b/reference/execution/execution/parallel_scheduler_replacement/receiver_proxy/try_query.md
new file mode 100644
index 000000000..6e1cece4e
--- /dev/null
+++ b/reference/execution/execution/parallel_scheduler_replacement/receiver_proxy/try_query.md
@@ -0,0 +1,62 @@
+# try_query
+* execution[meta header]
+* std::execution::parallel_scheduler_replacement[meta namespace]
+* receiver_proxy[meta class]
+* function template[meta id-type]
+* cpp26[meta cpp]
+
+```cpp
+template<class P, class-type Query>
+optional<P> try_query(Query q) const noexcept;
+```
+* class-type[link ../../../class-type.md]
+* optional[link /reference/optional/optional.md]
+
+## 概要
+[`parallel_scheduler`](../../parallel_scheduler.md)バックエンド実装側から[Receiver](../../receiver.md)環境にアクセスするための補助関数。
+
+
+## 適格要件
+`P`はcv修飾された非配列オブジェクト型。
+
+
+## 戻り値
+説明用の`env`を`*this`が表現する[Receiver](../../receiver.md)の環境とする。
+下記を満たす場合は[`nullopt`](/reference/optional/nullopt_t.md)を返す。
+
+- `Query`が実装定義でサポートされるクエリ集合のメンバではない、または
+- `P`が実装定義でサポートされる`Query`の結果型集合のメンバではない、または
+- 式`q(env)`が適格でない。
+
+そうではなく、`q(env)`がCV修飾された`P`型を持つときは`q(env)`を返す。そうでなければ、[`optional`](/reference/optional/optional.md)`<P>`型の実装定義の値を返す。
+
+
+## 例外
+投げない
+
+
+## 備考
+[`get_stop_token_t`](../../../get_stop_token.md)は実装定義でサポートするクエリ集合に含まれ、[`inplace_stop_token`](/reference/stop_token/inplace_stop_token.md)は`get_stop_token_t`の実装定義でサポートされる結果型集合のメンバである。
+
+推奨実装：`P`が[`inplace_stop_token`](/reference/stop_token/inplace_stop_token.md)であり型`T`が[`stoppable_token`](/reference/stop_token/stoppable_token.md)をモデル化する`inplace_stop_token`以外の型である場合、`try_query`は、`*this`に対して`set_value`／`set_error`／`set_stopped`のいずれかが呼び出されるまで全ての`try_query`呼び出しが`inplace_stop_token`オブジェクトと等価なオブジェクトを返す、`inplace_stop_token`型のオブジェクトを返すべき。
+
+
+## バージョン
+### 言語
+- C++26
+
+### 処理系
+- [Clang](/implementation.md#clang): ??
+- [GCC](/implementation.md#gcc): ??
+- [ICC](/implementation.md#icc): ??
+- [Visual C++](/implementation.md#visual_cpp): ??
+
+
+## 関連項目
+- [`execution::parallel_scheduler`](../../parallel_scheduler.md)
+- [`execution::parallel_scheduler_replacement::parallel_scheduler_backend`](../parallel_scheduler_backend.md)
+
+
+## 参照
+- [P2079R10 Parallel scheduler](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p2079r10.html)
+- [P3804R2 Iterating on `parallel_scheduler`](https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2026/p3804r2.html)

spawn -- execution: P4154R0対応(#1652)

2026-06-08T10:24:20+09:00

diff --git a/reference/execution/execution/spawn.md b/reference/execution/execution/spawn.md
index cca947847..535b5b1c8 100644
--- a/reference/execution/execution/spawn.md
+++ b/reference/execution/execution/spawn.md
@@ -145,7 +145,7 @@ namespace ex = std::execution;
 
 int main()
 {
-  // システムスレッドプール上の実行タスクを定義
+  // スレッドプール上の実行タスクを定義
   ex::scheduler auto sch = ex::get_parallel_scheduler();
   ex::sender auto sndr =
     ex::schedule(sch)

spawn_future -- execution: P4154R0対応(#1652)

2026-06-08T10:24:20+09:00

diff --git a/reference/execution/execution/spawn_future.md b/reference/execution/execution/spawn_future.md
index 4a7e5d209..7b6726a2b 100644
--- a/reference/execution/execution/spawn_future.md
+++ b/reference/execution/execution/spawn_future.md
@@ -421,7 +421,7 @@ namespace ex = std::execution;
 
 int main()
 {
-  // システムスレッドプール上の実行タスクを定義
+  // スレッドプール上の実行タスクを定義
   ex::scheduler auto sch = ex::get_parallel_scheduler();
   ex::sender auto snd0 =
     ex::schedule(sch)

system_context_replaceability.md -- execution: P4154R0対応(#1652)

2026-06-08T10:24:20+09:00

diff --git a/reference/execution/execution/system_context_replaceability.md b/reference/execution/execution/system_context_replaceability.md
deleted file mode 100644
index c52b84ff4..000000000
--- a/reference/execution/execution/system_context_replaceability.md
+++ /dev/null
@@ -1,40 +0,0 @@
-# system_context_replaceability
-* execution[meta header]
-* std::execution[meta namespace]
-* namespace[meta id-type]
-* cpp26[meta cpp]
-
-名前空間 `std::execution::system_context_replaceability` では、[並列Scheduler](parallel_scheduler.md)動作をユーザが差し替えるためのインタフェースを定義する。
-
-```cpp
-namespace std::execution::system_context_replaceability {
-  …
-}
-```
-
-[並列Scheduler](parallel_scheduler.md)をユーザ実装で置き換える場合、下記が必要となる。
-
-- [`system_context_replaceability::parallel_scheduler_backend`](system_context_replaceability/parallel_scheduler_backend.md)インターフェースをバックエンドにもつ並列Schedulerを実装する。
-- 処理系の手順に従って、[`system_context_replaceability::query_parallel_scheduler_backend`](system_context_replaceability/query_parallel_scheduler_backend.md)シンボルを自前バックエンド実装を返す関数で置き換える。
-
-
-| 名前 | 説明 | 対応バージョン |
-|------|------|----------------|
-| [`receiver_proxy`](system_context_replaceability/receiver_proxy.md) | バックエンド実装用のReceiverプロキシ (class) | C++26 |
-| [`bulk_item_receiver_proxy`](system_context_replaceability/bulk_item_receiver_proxy.md) | バックエンド実装用のバルク処理Receiverプロキシ (class) | C++26 |
-| [`parallel_scheduler_backend`](system_context_replaceability/parallel_scheduler_backend.md) | 並列Schedulerバックエンド (class) | C++26 |
-| [`query_parallel_scheduler_backend`](system_context_replaceability/query_parallel_scheduler_backend.md) | 並列Schedulerバックエンドを問い合わせ (function) | C++26 |
-
-
-## バージョン
-### 言語
-- C++26
-
-
-## 関連項目
-- [`execution::parallel_scheduler`](parallel_scheduler.md)
-
-
-## 参照
-- [P2300R10 `std::execution`](https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2024/p2300r10.html)
-- [P2079R10 Parallel scheduler](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p2079r10.html)

task_scheduler -- execution: P4154R0対応(#1652)

2026-06-08T10:24:20+09:00

diff --git a/reference/execution/execution/task_scheduler.md b/reference/execution/execution/task_scheduler.md
index 0834a9449..0c1bf4c10 100644
--- a/reference/execution/execution/task_scheduler.md
+++ b/reference/execution/execution/task_scheduler.md
@@ -21,7 +21,7 @@ namespace std::execution {
 
 `task_scheduler`クラスは、下記の説明専用メンバ変数を持つ。
 
-- `sch_` : [`shared_ptr`](/reference/memory/shared_ptr.md)`<`[`system_context_replaceability::parallel_scheduler_backend`](system_context_replaceability/parallel_scheduler_backend.md)`>`型
+- `sch_` : [`shared_ptr`](/reference/memory/shared_ptr.md)`<`[`parallel_scheduler_replacement::parallel_scheduler_backend`](parallel_scheduler_replacement/parallel_scheduler_backend.md)`>`型
 
 
 ## メンバ関数

schedule -- execution: P4154R0対応(#1652)

2026-06-08T10:24:20+09:00

diff --git a/reference/execution/execution/task_scheduler/schedule.md b/reference/execution/execution/task_scheduler/schedule.md
index 601a7302e..f1fa0312a 100644
--- a/reference/execution/execution/task_scheduler/schedule.md
+++ b/reference/execution/execution/task_scheduler/schedule.md
@@ -19,21 +19,21 @@ see below schedule();
 - [`get_completion_scheduler`](../get_completion_scheduler.md)`<`[`set_value_t`](../set_value.md)`>(`[`get_env`](../get_env.md)`(ts-sndr))`が`*this`と等しい。
 - [`get_completion_domain`](../get_completion_domain.md)`<`[`set_value_t`](../set_value.md)`>(`[`get_env`](../get_env.md)`(ts-sndr))`が`ts-domain()`と等価な式。
 - [Receiver](../receiver.md)`rcvr`が`ts-sndr`に接続され、結果の[Opearation State](../operation_state.md)が開始されるとき、次の値で`sch_->schedule(r, s)`を呼び出す。
-    - `r`は基底[`system_context_replaceability::receiver_proxy`](../system_context_replaceability/receiver_proxy.md)を持つ`rcvr`のプロキシであり、かつ
+    - `r`は基底[`parallel_scheduler_replacement::receiver_proxy`](../parallel_scheduler_replacement/receiver_proxy.md)を持つ`rcvr`のプロキシであり、かつ
     - `s`は`r`に対する事前確保バックエンドストレージである。
 - 任意の型`E`に対して、[`unstoppable_token`](/reference/stop_token/unstoppable_token.md)`<`[`stop_token_of_t`](../../stop_token_of_t.md)`<E>>`が`true`のとき、[`completion_signatures_of_t`](../completion_signatures_of_t.md)`<decltype(ts-sndr)>, E>`は[`completion_signatures`](../completion_signatures.md)`<`[`set_value_t`](../set_value.md)`()>`を表す。そうでなければ、[`completion_signatures`](../completion_signatures.md)`<`[`set_value_t`](../set_value.md)`(),` [`set_stopped_t`](../set_stopped.md)`()>`を表す。
 
 
 ## 説明専用エンティティ
 ### 式`WARP-RCVR`
-[`receiver_proxy`](../system_context_replaceability/receiver_proxy.md)から派生した型の左辺値`r`に対して、`WARP-RCVR(r)`を[`receiver`](../receiver.md)のモデルであり、その完了ハンドラが`r`の対応する完了ハンドラを呼び出すような型のオブジェクトとする。
+[`receiver_proxy`](../parallel_scheduler_replacement/receiver_proxy.md)から派生した型の左辺値`r`に対して、`WARP-RCVR(r)`を[`receiver`](../receiver.md)のモデルであり、その完了ハンドラが`r`の対応する完了ハンドラを呼び出すような型のオブジェクトとする。
 
 ### クラステンプレート`backend-for`
 ```cpp
 namespace std::execution {
   template<scheduler Sch>
   class task_scheduler::backend-for
-    : public system_context_replaceability::parallel_scheduler_backend {  // exposition only
+    : public parallel_scheduler_replacement::parallel_scheduler_backend {  // exposition only
   public:
     explicit backend-for(Sch sch) : sched_(std::move(sch)) {}
 
@@ -49,16 +49,16 @@ namespace std::execution {
 }
 ```
 * scheduler[link ../scheduler.md]
-* system_context_replaceability::parallel_scheduler_backend[link ../system_context_replaceability/parallel_scheduler_backend.md]
-* receiver_proxy[link ../system_context_replaceability/receiver_proxy.md]
-* bulk_item_receiver_proxy[link ../system_context_replaceability/bulk_item_receiver_proxy.md]
+* parallel_scheduler_replacement::parallel_scheduler_backend[link ../parallel_scheduler_replacement/parallel_scheduler_backend.md]
+* receiver_proxy[link ../parallel_scheduler_replacement/receiver_proxy.md]
+* bulk_item_receiver_proxy[link ../parallel_scheduler_replacement/bulk_item_receiver_proxy.md]
 
 `env`を部分式のパックとしたとき、値完了シグネチャ[`set_value_t`](../set_value.md)`()`のみを持ち式[`get_completion_scheduler`](../get_completion_scheduler.md)`<set_value_t>(`[`get_env`](../get_env.md)`(just-sndr-like), env...)`が[`get_completion_scheduler`](../get_completion_scheduler.md)`<set_value_t>(sched_, env...)`と等価な式であるような[`Sender`](../sender.md)を`just-sndr-like`とする。
 
 ```cpp
 void schedule(receiver_proxy& r, span<byte> s) noexcept override;
 ```
-* receiver_proxy[link ../system_context_replaceability/receiver_proxy.md]
+* receiver_proxy[link ../parallel_scheduler_replacement/receiver_proxy.md]
 
 - 効果 : [`connect`](../connect.md)`(`[`schedule`](../schedule.md)`(sched_), WRAP-RCVR(r))`で[Operation State](../operation_state.md)`os`を構築し、[`start`](../start.md)`(os)`を呼び出す。
 
@@ -66,7 +66,7 @@ void schedule(receiver_proxy& r, span<byte> s) noexcept override;
 void schedule_bulk_chunked(size_t shape, bulk_item_receiver_proxy& r,
                            span<byte> s) noexcept override;
 ```
-* bulk_item_receiver_proxy[link ../system_context_replaceability/bulk_item_receiver_proxy.md]
+* bulk_item_receiver_proxy[link ../parallel_scheduler_replacement/bulk_item_receiver_proxy.md]
 
 - 効果 : 説明用の`chunk_size`を`shape`以下の整数、`chunk_num`を`(shape + chunk_size - 1) / chunk_size`、`m`を`(i + 1) * chunk_size`と`shape`のうち小さい方として、整数`i`に対して`fn(i)`が`r.execute(i * chunk_sie, m)`を呼び出す関数オブジェクト`fn`とする。下記の式によって[Operation State](../operation_state.md)`os`を構築し、[`start`](../start.md)`(os)`を呼び出す。
 
@@ -81,7 +81,7 @@ void schedule_bulk_chunked(size_t shape, bulk_item_receiver_proxy& r,
 void schedule_bulk_unchunked(size_t shape, bulk_item_receiver_proxy& r,
                              span<byte> s) noexcept override;
 ```
-* bulk_item_receiver_proxy[link ../system_context_replaceability/bulk_item_receiver_proxy.md]
+* bulk_item_receiver_proxy[link ../parallel_scheduler_replacement/bulk_item_receiver_proxy.md]
 
 - 効果 : 整数`i`に対して`fn(i)`が`r.execute(i, i + 1)`を呼び出す関数オブジェクト`fn`とする。下記の式によって[Operation State](../operation_state.md)`os`を構築し、[`start`](../start.md)`(os)`を呼び出す。
 
@@ -140,8 +140,8 @@ static constexpr auto transform_sender(BulkSndr&& bulk_sndr, const Env& env)
 
     `child`が[エラー完了](../set_error.md)もしくは[停止完了](../set_stopped.md)するとき、完了操作は変更されずに`rcvr`に転送される。そうでなければ、値完了結果からdecayコピーされたオブジェクトを指す左辺値式のパック`args`として、
 
-    - `bulk_sndr`が[`bulk_chunked`](../bulk_chunked.md)`(child, policy, shape, fn)`と等価な式またはそのコピーの評価の結果であるとき、`r`を呼び出し可能オブジェクト`fn`と引数`args`を持つ`rcvr`に対するbulk chunkedプロキシ、`s`を`r`の事前確保バックエンドストレージとして、`sch_->`[`schedule_bulk_chunked`](../system_context_replaceability/parallel_scheduler_backend/schedule_bulk_chunked.md)`(shape, r, s)`が呼び出される。
-    - そうでなければ、`r`を呼び出し可能オブジェクト`fn`と引数`args`を持つ`rcvr`に対するbulk unchunkedプロキシ、`s`を`r`の事前確保バックエンドストレージとして、`sch_->`[`schedule_bulk_unchunked`](../system_context_replaceability/parallel_scheduler_backend/schedule_bulk_unchunked.md)`(shape, r, s)`が呼び出される。
+    - `bulk_sndr`が[`bulk_chunked`](../bulk_chunked.md)`(child, policy, shape, fn)`と等価な式またはそのコピーの評価の結果であるとき、`r`を呼び出し可能オブジェクト`fn`と引数`args`を持つ`rcvr`に対するbulk chunkedプロキシ、`s`を`r`の事前確保バックエンドストレージとして、`sch_->`[`schedule_bulk_chunked`](../parallel_scheduler_replacement/parallel_scheduler_backend/schedule_bulk_chunked.md)`(shape, r, s)`が呼び出される。
+    - そうでなければ、`r`を呼び出し可能オブジェクト`fn`と引数`args`を持つ`rcvr`に対するbulk unchunkedプロキシ、`s`を`r`の事前確保バックエンドストレージとして、`sch_->`[`schedule_bulk_unchunked`](../parallel_scheduler_replacement/parallel_scheduler_backend/schedule_bulk_unchunked.md)`(shape, r, s)`が呼び出される。
    
 
 ## バージョン

as_awaitable -- execution: P4154R0対応(#1652)

2026-06-08T10:13:52+09:00

diff --git a/reference/execution/execution/as_awaitable.md b/reference/execution/execution/as_awaitable.md
index 72bbea58a..ec13e819f 100644
--- a/reference/execution/execution/as_awaitable.md
+++ b/reference/execution/execution/as_awaitable.md
@@ -137,13 +137,13 @@ namespace std::execution {
 
 ```cpp
 struct awaitable-receiver {
-  using receiver_concept = receiver_t;
+  using receiver_concept = receiver_tag;
   variant<monostate, result-type, exception_ptr>* result-ptr;  // exposition only
   coroutine_handle<Promise> continuation;                      // exposition only
   // see below
 };
 ```
-* receiver_t[link receiver.md]
+* receiver_tag[link receiver.md]
 * variant[link /reference/variant/variant.md]
 * monostate[link /reference/variant/monostate.md]
 * exception_ptr[link /reference/exception/exception_ptr.md]

basic-operation -- execution: P4154R0対応(#1652)

2026-06-08T10:13:52+09:00

diff --git a/reference/execution/execution/basic-operation.md b/reference/execution/execution/basic-operation.md
index 0f7c1038a..af1397da2 100644
--- a/reference/execution/execution/basic-operation.md
+++ b/reference/execution/execution/basic-operation.md
@@ -11,7 +11,7 @@ namespace std::execution {
     requires valid-specialization<state-type, Sndr, Rcvr> &&
              valid-specialization<connect-all-result, Sndr, Rcvr>
   struct basic-operation : basic-state<Sndr, Rcvr> {  // exposition only
-    using operation_state_concept = operation_state_t;
+    using operation_state_concept = operation_state_tag;
     using tag-t = tag_of_t<Sndr>;                     // exposition only
 
     connect-all-result<Sndr, Rcvr> inner-ops;         // exposition only
@@ -38,7 +38,7 @@ namespace std::execution {
   };
 }
 ```
-* operation_state_t[link operation_state.md]
+* operation_state_tag[link operation_state.md]
 * tag_of_t[link tag_of_t.md]
 * indices-for[link basic-sender.md]
 * impls-for[link impls-for.md]

basic-receiver -- execution: P4154R0対応(#1652)

2026-06-08T10:13:52+09:00

diff --git a/reference/execution/execution/basic-receiver.md b/reference/execution/execution/basic-receiver.md
index 19e6527a9..0426b3fc2 100644
--- a/reference/execution/execution/basic-receiver.md
+++ b/reference/execution/execution/basic-receiver.md
@@ -10,7 +10,7 @@ namespace std::execution {
   template<class Sndr, class Rcvr, class Index>
     requires valid-specialization<env-type, Index, Sndr, Rcvr>
   struct basic-receiver {                    // exposition only
-    using receiver_concept = receiver_t;
+    using receiver_concept = receiver_tag;
 
     using tag-t = tag_of_t<Sndr>;            // exposition only
     using state-t = state-type<Sndr, Rcvr>;  // exposition only
@@ -38,7 +38,7 @@ namespace std::execution {
   };
 }
 ```
-* receiver_t[link receiver.md]
+* receiver_tag[link receiver.md]
 * tag_of_t[link tag_of_t.md]
 * state-type[link basic-operation.md]
 * impls-for[link impls-for.md]

basic-sender -- execution: P4154R0対応(#1652)

2026-06-08T10:13:52+09:00

diff --git a/reference/execution/execution/basic-sender.md b/reference/execution/execution/basic-sender.md
index 247924c43..32ef579e1 100644
--- a/reference/execution/execution/basic-sender.md
+++ b/reference/execution/execution/basic-sender.md
@@ -9,7 +9,7 @@
 namespace std::execution {
   template<class Tag, class Data, class... Child>
   struct basic-sender : product-type<Tag, Data, Child...> {  // exposition only
-    using sender_concept = sender_t;
+    using sender_concept = sender_tag;
     using indices-for = index_sequence_for<Child...>;        // exposition only
 
     decltype(auto) get_env() const noexcept {
@@ -29,7 +29,7 @@ namespace std::execution {
 }
 ```
 * product-type[link product-type.md]
-* sender_t[link sender.md]
+* sender_tag[link sender.md]
 * index_sequence_for[link /reference/utility/index_sequence_for.md]
 * impls-for[link impls-for.md]
 * decays-to[link ../decays-to.md]

connect -- execution: P4154R0対応(#1652)

2026-06-08T10:13:52+09:00

diff --git a/reference/execution/execution/connect.md b/reference/execution/execution/connect.md
index 36bb6585b..32c9308f1 100644
--- a/reference/execution/execution/connect.md
+++ b/reference/execution/execution/connect.md
@@ -99,7 +99,7 @@ namespace std::execution {
 ```cpp
 namespace std::execution {
   struct operation-state-task {  // exposition only
-    using operation_state_concept = operation_state_t;
+    using operation_state_concept = operation_state_tag;
     using promise_type = connect-awaitable-promise;
 
     explicit operation-state-task(coroutine_handle<> h) noexcept : coro(h) {}
@@ -115,7 +115,7 @@ namespace std::execution {
   };
 }
 ```
-* operation_state_t[link operation_state.md]
+* operation_state_tag[link operation_state.md]
 * promise_type[link /lang/cpp20/coroutines.md]
 * coroutine_handle<>[link /reference/coroutine/coroutine_handle.md]
 * destroy()[link /reference/coroutine/coroutine_handle/destroy.md]
@@ -197,7 +197,7 @@ Sender`sndr`[変換後](transform_sender.md)の`new_sndr`に対して、式`new_
 namespace ex = std::execution;
 
 struct ValueReceiver {
-  using receiver_concept = ex::receiver_t;
+  using receiver_concept = ex::receiver_tag;
 
   void set_value(int v) && noexcept
   {
@@ -219,7 +219,7 @@ int main()
 }
 ```
 * ex::connect[color ff0000]
-* ex::receiver_t[link receiver.md]
+* ex::receiver_tag[link receiver.md]
 * ex::sender[link sender.md]
 * ex::just[link just.md]
 * ex::operation_state[link operation_state.md]

continues_on -- execution: P4154R0対応(#1652)

2026-06-08T10:13:52+09:00

diff --git a/reference/execution/execution/continues_on.md b/reference/execution/execution/continues_on.md
index eaa9ab674..4728713af 100644
--- a/reference/execution/execution/continues_on.md
+++ b/reference/execution/execution/continues_on.md
@@ -55,9 +55,9 @@ namespace std::execution {
 
   using sched_t = decltype(auto(sch));
   using variant_t = see below;
-  using receiver_t = see below;
-  using operation_t = connect_result_t<schedule_result_t<sched_t>, receiver_t>;
-  constexpr bool nothrow = noexcept(connect(schedule(sch), receiver_t{nullptr}));
+  using receiver_tag = see below;
+  using operation_t = connect_result_t<schedule_result_t<sched_t>, receiver_tag>;
+  constexpr bool nothrow = noexcept(connect(schedule(sch), receiver_tag{nullptr}));
 
   struct state-type {
     Rcvr& rcvr;                 // exposition only
@@ -65,7 +65,7 @@ namespace std::execution {
     operation_t op-state;       // exposition only
 
     explicit state-type(sched_t sch, Rcvr& rcvr) noexcept(nothrow)
-      : rcvr(rcvr), op-state(connect(schedule(sch), receiver_t{this})) {}
+      : rcvr(rcvr), op-state(connect(schedule(sch), receiver_tag{this})) {}
   };
 
   return state-type{sch, rcvr};
@@ -89,7 +89,7 @@ namespace std::execution {
     * variant[link /reference/variant/variant.md]
     * monostate[link /reference/variant/monostate.md]
 
-- `receiver_t`は説明専用クラス`receiver-type`のエイリアスとする。
+- `receiver_tag`は説明専用クラス`receiver-type`のエイリアスとする。
 
 `impls-for<continues_on_t>::complete`メンバは、下記ラムダ式と等価な関数呼び出し可能なオブジェクトで初期化される。
 
@@ -137,7 +137,7 @@ decay-copyable-result-datums(cs);
 ```cpp
 namespace std::execution {
   struct receiver-type {
-    using receiver_concept = receiver_t;
+    using receiver_concept = receiver_tag;
     state-type* state;  // exposition only
 
     void set_value() && noexcept {
@@ -166,7 +166,7 @@ namespace std::execution {
   };
 }
 ```
-* receiver_t[link receiver.md]
+* receiver_tag[link receiver.md]
 * execution::set_error[link set_error.md]
 * execution::set_stopped[link set_stopped.md]
 * execution::get_env[link get_env.md]

inline_scheduler -- execution: P4154R0対応(#1652)

2026-06-08T10:13:52+09:00

diff --git a/reference/execution/execution/inline_scheduler.md b/reference/execution/execution/inline_scheduler.md
index bf38adbb6..a952af0d2 100644
--- a/reference/execution/execution/inline_scheduler.md
+++ b/reference/execution/execution/inline_scheduler.md
@@ -12,14 +12,14 @@ namespace std::execution {
     class inline-state;  // exposition only
 
   public:
-    using scheduler_concept = scheduler_t;
+    using scheduler_concept = scheduler_tag;
 
     constexpr inline-sender schedule() noexcept { return {}; }
     constexpr bool operator==(const inline_scheduler&) const noexcept = default;
   };
 }
 ```
-* scheduler_t[link scheduler.md]
+* scheduler_tag[link scheduler.md]
 * receiver[link receiver.md]
 * inline-sender[italic]
 * inline-state[italic]
@@ -66,7 +66,7 @@ struct inline-attrs {
 
 | 名前 | 説明 | 対応バージョン |
 |------|------|----------------|
-| `scheduler_concept` | [`scheduler_t`](scheduler.md) | C++26 |
+| `scheduler_concept` | [`scheduler_tag`](scheduler.md) | C++26 |
 
 
 ## 例

into_variant -- execution: P4154R0対応(#1652)

2026-06-08T10:13:52+09:00

diff --git a/reference/execution/execution/into_variant.md b/reference/execution/execution/into_variant.md
index 5d91de06b..79fe5fad3 100644
--- a/reference/execution/execution/into_variant.md
+++ b/reference/execution/execution/into_variant.md
@@ -108,7 +108,7 @@ namespace std::execution {
 namespace ex = std::execution;
 
 struct FizzBuzzSender {
-  using sender_concept = ex::sender_t;
+  using sender_concept = ex::sender_tag;
 
   // FizzBuzzSenderは2種類の値完了シグネチャを持つ
   using completion_signatures = ex::completion_signatures<
@@ -124,7 +124,7 @@ struct FizzBuzzSender {
   // Operation State型
   template <typename Rcvr>
   struct State {
-    using operation_state_concept = ex::operation_state_t;
+    using operation_state_concept = ex::operation_state_tag;
 
     State(Rcvr rcvr, int val)
       : rcvr_{std::move(rcvr)}, val_{val} {}
@@ -182,12 +182,12 @@ int main()
 }
 ```
 * ex::into_variant[color ff0000]
-* ex::sender_t[link sender.md]
+* ex::sender_tag[link sender.md]
 * ex::sender[link sender.md]
 * ex::completion_signatures[link completion_signatures.md]
 * ex::set_value_t[link set_value.md]
 * ex::set_value[link set_value.md]
-* ex::operation_state_t[link operation_state.md]
+* ex::operation_state_tag[link operation_state.md]
 * std::this_thread::sync_wait[link ../this_thread/sync_wait.md]
 * value()[link /reference/optional/optional/value.md]
 * std::move[link /reference/utility/move.md]

let_value -- execution: P4154R0対応(#1652)

2026-06-08T10:13:52+09:00

diff --git a/reference/execution/execution/let_value.md b/reference/execution/execution/let_value.md
index abca0cfc0..7ec457abc 100644
--- a/reference/execution/execution/let_value.md
+++ b/reference/execution/execution/let_value.md
@@ -208,7 +208,7 @@ struct let-state {
     let-state& state; // exposition only
     Rcvr& rcvr;       // exposition only
 
-    using receiver_concept = receiver_t;
+    using receiver_concept = receiver_tag;
 
     template<class... Args>
     constexpr void set_value(Args&&... args) noexcept {
@@ -239,7 +239,7 @@ struct let-state {
 * connect_result_t[link connect_result_t.md]
 * connect[link connect.md]
 * start[link start.md]
-* receiver_t[link receiver.md]
+* receiver_tag[link receiver.md]
 * execution::set_value[link set_value.md]
 * execution::set_error[link set_error.md]
 * execution::set_stopped[link set_stopped.md]
@@ -256,7 +256,7 @@ struct let-state {
 namespace std::execution {
   template<class Rcvr, class Env>
   struct receiver2 {
-    using receiver_concept = receiver_t;
+    using receiver_concept = receiver_tag;
 
     template<class... Args>
     void set_value(Args&&... args) && noexcept {
@@ -281,7 +281,7 @@ namespace std::execution {
   };
 }
 ```
-* receiver_t[link receiver.md]
+* receiver_tag[link receiver.md]
 * execution::set_value[link set_value.md]
 * execution::set_error[link set_error.md]
 * execution::set_stopped[link set_stopped.md]
@@ -359,7 +359,7 @@ namespace ex = std::execution;
 //   値完了     set_value(int), set_value(string)
 //   エラー完了 set_error(int)
 struct MySender {
-  using sender_concept = ex::sender_t;
+  using sender_concept = ex::sender_tag;
   using completion_signatures = ex::completion_signatures<
     ex::set_value_t(int),
     ex::set_value_t(std::string),
@@ -368,7 +368,7 @@ struct MySender {
 
   template <typename Rcvr>
   struct state {
-    using operation_state_concept = ex::operation_state_t;
+    using operation_state_concept = ex::operation_state_tag;
 
     state(Rcvr rcvr, int val)
       : rcvr_{std::move(rcvr)}, val_{val} {}
@@ -441,7 +441,7 @@ int main()
 }
 ```
 * ex::let_value[color ff0000]
-* ex::sender_t[link sender.md]
+* ex::sender_tag[link sender.md]
 * ex::sender[link sender.md]
 * ex::completion_signatures[link completion_signatures.md]
 * ex::set_value_t[link set_value.md]
@@ -450,7 +450,7 @@ int main()
 * ex::set_error[link set_error.md]
 * ex::just[link just.md]
 * ex::just_stopped[link just_stopped.md]
-* ex::operation_state_t[link operation_state.md]
+* ex::operation_state_tag[link operation_state.md]
 * std::this_thread::sync_wait_with_variant[link ../this_thread/sync_wait_with_variant.md]
 * std::move[link /reference/utility/move.md]

not-a-scheduler -- execution: P4154R0対応(#1652)

2026-06-08T10:13:52+09:00

diff --git a/reference/execution/execution/not-a-scheduler.md b/reference/execution/execution/not-a-scheduler.md
index 515dd3022..fb2ac7e35 100644
--- a/reference/execution/execution/not-a-scheduler.md
+++ b/reference/execution/execution/not-a-scheduler.md
@@ -7,14 +7,14 @@
 
 ```cpp
 struct not-a-scheduler {
-  using scheduler_concept = scheduler_t;
+  using scheduler_concept = scheduler_tag;
 
   constexpr auto schedule() const noexcept {
     return not-a-sender();
   }
 };
 ```
-* scheduler_t[link scheduler.md]
+* scheduler_tag[link scheduler.md]
 * not-a-sender[link not-a-sender.md]
 
 ## 概要

not-a-sender -- execution: P4154R0対応(#1652)

2026-06-08T10:13:52+09:00

diff --git a/reference/execution/execution/not-a-sender.md b/reference/execution/execution/not-a-sender.md
index 4dd328437..4f9049545 100644
--- a/reference/execution/execution/not-a-sender.md
+++ b/reference/execution/execution/not-a-sender.md
@@ -7,7 +7,7 @@
 
 ```cpp
 struct not-a-sender {
-  using sender_concept = sender_t;
+  using sender_concept = sender_tag;
 
   template<class Sndr>
     static consteval auto get_completion_signatures() -> completion_signatures<> {
@@ -15,7 +15,7 @@ struct not-a-sender {
   }
 };
 ```
-* sender_t[link sender.md]
+* sender_tag[link sender.md]
 * get_completion_signatures[link get_completion_signatures.md]
 * completion_signatures[link completion_signatures.md]
 * unspecified-exception[link unspecified-exception.md]

operation_state -- execution: P4154R0対応(#1652)

2026-06-08T10:13:52+09:00

diff --git a/reference/execution/execution/operation_state.md b/reference/execution/execution/operation_state.md
index 06ebbf074..9bc756fb6 100644
--- a/reference/execution/execution/operation_state.md
+++ b/reference/execution/execution/operation_state.md
@@ -8,12 +8,12 @@
 namespace std::execution {
   template<class O>
   concept operation_state =
-    derived_from<typename O::operation_state_concept, operation_state_t> &&
+    derived_from<typename O::operation_state_concept, operation_state_tag> &&
     requires (O& o) {
       start(o);
     };
 
-  struct operation_state_t {};  // タグ型
+  struct operation_state_tag {};  // タグ型
 }
 ```
 * derived_from[link /reference/concepts/derived_from.md]
@@ -24,7 +24,7 @@ namespace std::execution {
 
 下記をみたすクラス型はOperation Stateとみなせる。
 
-- `operation_state_t`をメンバ型`O::operation_state_concept`として定義する
+- `operation_state_tag`をメンバ型`O::operation_state_concept`として定義する
 - `O`型の左辺値`o`に対して[`execution::start`](start.md)`(o)`が有効な式
 
 非同期操作の生存期間中に`operation_state`オブジェクトが破棄されると、未定義の動作を引き起こす。
@@ -37,7 +37,7 @@ namespace std::execution {
 namespace ex = std::execution;
 
 struct ValueReceiver {
-  using receiver_concept = ex::receiver_t;
+  using receiver_concept = ex::receiver_tag;
 
   void set_value(int v) && noexcept
   {
@@ -59,7 +59,7 @@ int main()
 }
 ```
 * ex::operation_state[color ff0000]
-* ex::receiver_t[link receiver.md]
+* ex::receiver_tag[link receiver.md]
 * ex::sender[link sender.md]
 * ex::just[link just.md]
 * ex::connect[link connect.md]
@@ -89,3 +89,4 @@ int main()
 ## 参照
 - [P2300R10 `std::execution`](https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2024/p2300r10.html)
 - [LWG 4200. The `operation_state` concept can be simplified](https://cplusplus.github.io/LWG/issue4200)
+- [P4154R0 Renaming various execution things](https://open-std.org/jtc1/sc22/wg21/docs/papers/2026/p4154r0.html)

receiver -- execution: P4154R0対応(#1652)

2026-06-08T10:13:52+09:00

diff --git a/reference/execution/execution/receiver.md b/reference/execution/execution/receiver.md
index e09023aa0..a3b5b9fc3 100644
--- a/reference/execution/execution/receiver.md
+++ b/reference/execution/execution/receiver.md
@@ -8,7 +8,7 @@
 namespace std::execution {
   template<class Rcvr>
   concept receiver =
-    derived_from<typename remove_cvref_t<Rcvr>::receiver_concept, receiver_t> &&
+    derived_from<typename remove_cvref_t<Rcvr>::receiver_concept, receiver_tag> &&
     requires(const remove_cvref_t<Rcvr>& rcvr) {
       { get_env(rcvr) } -> queryable;
     } &&
@@ -16,7 +16,7 @@ namespace std::execution {
     constructible_from<remove_cvref_t<Rcvr>, Rcvr> &&
     is_nothrow_move_constructible_v<remove_cvref_t<Rcvr>>;
 
-  struct receiver_t {};  // タグ型
+  struct receiver_tag {};  // タグ型
 }
 ```
 * get_env[link get_env.md]
@@ -30,7 +30,7 @@ namespace std::execution {
 
 下記をみたすクラス型はReceiverとみなせる。
 
-- `receiver_t`をメンバ型`Rcvr::receiver_concept`として定義する
+- `receiver_tag`をメンバ型`Rcvr::receiver_concept`として定義する
 - [`get_env`](get_env.md)で[環境](../queryable.md)を取得できる
 - 例外送出せずにムーブ構築可能
 
@@ -45,7 +45,7 @@ namespace std::execution {
 namespace ex = std::execution;
 
 struct SinkReceiver {
-  using receiver_concept = ex::receiver_t;
+  using receiver_concept = ex::receiver_tag;
 
   void set_value(auto&&...) noexcept {}
   void set_error(auto&&) noexcept {}
@@ -78,3 +78,4 @@ int main()
 ## 参照
 - [P2300R10 `std::execution`](https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2024/p2300r10.html)
 - [P3388R3 When Do You Know connect Doesn't Throw?](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3388r3.pdf)
+- [P4154R0 Renaming various execution things](https://open-std.org/jtc1/sc22/wg21/docs/papers/2026/p4154r0.html)

run_loop -- execution: P4154R0対応(#1652)

2026-06-08T10:13:52+09:00

diff --git a/reference/execution/execution/run_loop.md b/reference/execution/execution/run_loop.md
index 7f4feeaba..1eed14b99 100644
--- a/reference/execution/execution/run_loop.md
+++ b/reference/execution/execution/run_loop.md
@@ -49,7 +49,7 @@ namespace std::execution {
 namespace ex = std::execution;
 
 struct MyReceiver {
-  using receiver_concept = ex::receiver_t;
+  using receiver_concept = ex::receiver_tag;
 
   void set_value() noexcept
     { std::println("success"); }
@@ -89,7 +89,7 @@ int main()
 * ex::sender[link sender.md]
 * ex::schedule[link schedule.md]
 * ex::receiver[link receiver.md]
-* ex::receiver_t[link receiver.md]
+* ex::receiver_tag[link receiver.md]
 * ex::connect[link connect.md]
 * ex::start[link start.md]
 * get_scheduler()[link run_loop/get_scheduler.md]

scheduler -- execution: P4154R0対応(#1652)

2026-06-08T10:13:52+09:00

diff --git a/reference/execution/execution/scheduler.md b/reference/execution/execution/scheduler.md
index 1790f2b1e..87f931f06 100644
--- a/reference/execution/execution/scheduler.md
+++ b/reference/execution/execution/scheduler.md
@@ -8,7 +8,7 @@
 namespace std::execution {
   template<class Sch>
   concept scheduler =
-    derived_from<typename remove_cvref_t<Sch>::scheduler_concept, scheduler_t> &&
+    derived_from<typename remove_cvref_t<Sch>::scheduler_concept, scheduler_tag> &&
     queryable<Sch> &&
     requires(Sch&& sch) {
       { schedule(std::forward<Sch>(sch)) } -> sender;
@@ -17,7 +17,7 @@ namespace std::execution {
     equality_comparable<remove_cvref_t<Sch>> &&
     copyable<remove_cvref_t<Sch>>;
 
-  struct scheduler_t {};  // タグ型
+  struct scheduler_tag {};  // タグ型
 }
 ```
 * derived_from[link /reference/concepts/derived_from.md]
@@ -33,7 +33,7 @@ namespace std::execution {
 
 下記をみたすクラス型はSchedulerとみなせる。
 
-- `scheduler_t`をメンバ型`Sch::scheduler_concept`として定義する
+- `scheduler_tag`をメンバ型`Sch::scheduler_concept`として定義する
 - [クエリ可能オブジェクト](../queryable.md)である
 - `Sch`型の値`sch`に対して下記を満たすこと
     - [`execution::schedule`](schedule.md)`(sch)`が[Sender](sender.md)を返す
@@ -115,3 +115,4 @@ int main()
 - [LWG4354. Reconsider `weakly_parallel` as the default `forward_progress_guarantee`](https://cplusplus.github.io/LWG/issue4354)
 - [P3826R5 Fix Sender Algorithm Customization](https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2026/p3826r5.html)
 - [P3941R4 Scheduler Affinity](https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2026/p3941r4.html)
+- [P4154R0 Renaming various execution things](https://open-std.org/jtc1/sc22/wg21/docs/papers/2026/p4154r0.html)

sender -- execution: P4154R0対応(#1652)

2026-06-08T10:13:52+09:00

diff --git a/reference/execution/execution/sender.md b/reference/execution/execution/sender.md
index 58654862c..5b2a92ce3 100644
--- a/reference/execution/execution/sender.md
+++ b/reference/execution/execution/sender.md
@@ -9,7 +9,7 @@ namespace std::execution {
   template <class Sndr>
   concept sender;
 
-  struct sender_t {};  // タグ型
+  struct sender_tag {};  // タグ型
 
   template<class Sndr>
   inline constexpr bool enable_sender = see below;
@@ -22,7 +22,7 @@ namespace std::execution {
 下記をみたすクラス型はSenderとみなせる。
 
 - 下記いずれかを満たす
-    - `sender_t`をメンバ型`Sndr::sender_concept`として定義する
+    - `sender_tag`をメンバ型`Sndr::sender_concept`として定義する
     - `enable_sender`変数テンプレートを`true`で特殊化する
     - [コルーチンのAwaitable型](/lang/cpp20/coroutines.md)
 - [`get_env`](get_env.md)で[属性](../queryable.md)を取得できる
@@ -35,7 +35,7 @@ namespace std::execution {
 ```cpp
 template<class Sndr>
 concept is-sender =
-  derived_from<typename Sndr::sender_concept, sender_t>;
+  derived_from<typename Sndr::sender_concept, sender_tag>;
 
 template<class Sndr>
 concept enable-sender =
@@ -114,3 +114,4 @@ int main()
 - [P2300R10 `std::execution`](https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2024/p2300r10.html)
 - [LWG 4202. enable-sender should be a variable template](https://cplusplus.github.io/LWG/issue4202)
 - [P4159R0 Make `sender_in` and `receiver_of` exposition-only](https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2026/p4159r0.html)
+- [P4154R0 Renaming various execution things](https://open-std.org/jtc1/sc22/wg21/docs/papers/2026/p4154r0.html)

set_error -- execution: P4154R0対応(#1652)

2026-06-08T10:13:52+09:00

diff --git a/reference/execution/execution/set_error.md b/reference/execution/execution/set_error.md
index e7db69fea..678e9c91a 100644
--- a/reference/execution/execution/set_error.md
+++ b/reference/execution/execution/set_error.md
@@ -45,7 +45,7 @@ namespace std::execution {
 namespace ex = std::execution;
 
 struct ErrorReceiver {
-  using receiver_concept = ex::receiver_t;
+  using receiver_concept = ex::receiver_tag;
 
   // エラー完了シグネチャ set_error_t(int)
   void set_error(int) && noexcept {}
@@ -58,7 +58,7 @@ int main()
 }
 ```
 * ex::set_error[color ff0000]
-* ex::receiver_t[link receiver.md]
+* ex::receiver_tag[link receiver.md]
 * std::move[link /reference/utility/move.md]
 
 ### 出力

set_stopped -- execution: P4154R0対応(#1652)

2026-06-08T10:13:52+09:00

diff --git a/reference/execution/execution/set_stopped.md b/reference/execution/execution/set_stopped.md
index bf81205a8..5139d84f8 100644
--- a/reference/execution/execution/set_stopped.md
+++ b/reference/execution/execution/set_stopped.md
@@ -45,7 +45,7 @@ namespace std::execution {
 namespace ex = std::execution;
 
 struct StoppedReceiver {
-  using receiver_concept = ex::receiver_t;
+  using receiver_concept = ex::receiver_tag;
 
   // 停止完了シグネチャ set_stopped_t()
   void set_stopped() && noexcept {}
@@ -58,7 +58,7 @@ int main()
 }
 ```
 * ex::set_stopped[color ff0000]
-* ex::receiver_t[link receiver.md]
+* ex::receiver_tag[link receiver.md]
 * std::move[link /reference/utility/move.md]
 
 ### 出力

set_value -- execution: P4154R0対応(#1652)

2026-06-08T10:13:52+09:00

diff --git a/reference/execution/execution/set_value.md b/reference/execution/execution/set_value.md
index 9b4a43fa9..1b716c861 100644
--- a/reference/execution/execution/set_value.md
+++ b/reference/execution/execution/set_value.md
@@ -84,7 +84,7 @@ TRY-EVAL(rcvr, SET-VALUE(rcvr, expr))
 namespace ex = std::execution;
 
 struct ValueReceiver {
-  using receiver_concept = ex::receiver_t;
+  using receiver_concept = ex::receiver_tag;
 
   // 値完了シグネチャ set_value_t(int, int)
   void set_value(int, int) && noexcept {}
@@ -97,7 +97,7 @@ int main()
 }
 ```
 * ex::set_value[color ff0000]
-* ex::receiver_t[link receiver.md]
+* ex::receiver_tag[link receiver.md]
 * std::move[link /reference/utility/move.md]
 
 ### 出力

simple_counting_scope -- execution: P4154R0対応(#1652)

2026-06-08T10:13:52+09:00

diff --git a/reference/execution/execution/simple_counting_scope.md b/reference/execution/execution/simple_counting_scope.md
index 56b47f90e..89ac53912 100644
--- a/reference/execution/execution/simple_counting_scope.md
+++ b/reference/execution/execution/simple_counting_scope.md
@@ -71,7 +71,7 @@ namespace std::execution {
     template<class Scope, class Rcvr>
     struct state {                          // exposition only
       struct rcvr-t {                       // exposition only
-        using receiver_concept = receiver_t;
+        using receiver_concept = receiver_tag;
 
         Rcvr& rcvr;                         // exposition only
 
@@ -134,7 +134,7 @@ namespace std::execution {
 ```
 * impls-for[link impls-for.md]
 * default-impls[link impls-for.md]
-* receiver_t[link receiver.md]
+* receiver_tag[link receiver.md]
 * execution::set_value[link set_value.md]
 * execution::set_error[link set_error.md]
 * execution::set_stopped[link set_stopped.md]

spawn -- execution: P4154R0対応(#1652)

2026-06-08T10:13:52+09:00

diff --git a/reference/execution/execution/spawn.md b/reference/execution/execution/spawn.md
index 25bbfe118..cca947847 100644
--- a/reference/execution/execution/spawn.md
+++ b/reference/execution/execution/spawn.md
@@ -52,7 +52,7 @@ namespace std::execution {
 ```cpp
 namespace std::execution {
   struct spawn-receiver {                  // exposition only
-    using receiver_concept = receiver_t;
+    using receiver_concept = receiver_tag;
 
     spawn-state-base* state;               // exposition only
     void set_value() && noexcept { state->complete(); }
@@ -60,7 +60,7 @@ namespace std::execution {
   };
 }
 ```
-* receiver_t[link receiver.md]
+* receiver_tag[link receiver.md]
 * spawn-state-base[italic]
 
 ### クラステンプレート`spawn-state`

spawn_future -- execution: P4154R0対応(#1652)

2026-06-08T10:13:52+09:00

diff --git a/reference/execution/execution/spawn_future.md b/reference/execution/execution/spawn_future.md
index 78a60fd3d..4a7e5d209 100644
--- a/reference/execution/execution/spawn_future.md
+++ b/reference/execution/execution/spawn_future.md
@@ -116,7 +116,7 @@ namespace std::execution {
 namespace std::execution {
   template<class Completions>
   struct spawn-future-receiver {                  // exposition only
-    using receiver_concept = receiver_t;
+    using receiver_concept = receiver_tag;
 
     spawn-future-state-base<Completions>* state;  // exposition only
 
@@ -153,7 +153,7 @@ namespace std::execution {
   };
 }
 ```
-* receiver_t[link receiver.md]
+* receiver_tag[link receiver.md]
 * set_value_t[link set_value.md]
 * set_error_t[link set_error.md]
 * set_stopped_t[link set_stopped.md]
@@ -341,7 +341,7 @@ namespace std::execution {
       stop_callback_for_t<stop-token-t, callback>;
 
     struct receiver {                                    // exposition only
-      using receiver_concept = receiver_t;
+      using receiver_concept = receiver_tag;
       future-operation* op;                              // exposition only
 
       template<class... T>
@@ -401,7 +401,7 @@ namespace std::execution {
 ```
 * stop_token_of_t[link ../stop_token_of_t.md]
 * env_of_t[link env_of_t.md]
-* receiver_t[link receiver.md]
+* receiver_tag[link receiver.md]
 * set_value_t[link set_value.md]
 * set_error_t[link set_error.md]
 * set_stopped_t[link set_stopped.md]

start -- execution: P4154R0対応(#1652)

2026-06-08T10:13:52+09:00

diff --git a/reference/execution/execution/start.md b/reference/execution/execution/start.md
index 35ac90b9e..bd5101c01 100644
--- a/reference/execution/execution/start.md
+++ b/reference/execution/execution/start.md
@@ -40,7 +40,7 @@ namespace std::execution {
 namespace ex = std::execution;
 
 struct ValueReceiver {
-  using receiver_concept = ex::receiver_t;
+  using receiver_concept = ex::receiver_tag;
 
   void set_value(int v) && noexcept
   {
@@ -62,7 +62,7 @@ int main()
 }
 ```
 * ex::start[color ff0000]
-* ex::receiver_t[link receiver.md]
+* ex::receiver_tag[link receiver.md]
 * ex::sender[link sender.md]
 * ex::just[link just.md]
 * ex::operation_state[link operation_state.md]

stopped_as_error -- execution: P4154R0対応(#1652)

2026-06-08T10:13:52+09:00

diff --git a/reference/execution/execution/stopped_as_error.md b/reference/execution/execution/stopped_as_error.md
index d7114717d..5a8d854b2 100644
--- a/reference/execution/execution/stopped_as_error.md
+++ b/reference/execution/execution/stopped_as_error.md
@@ -64,7 +64,7 @@ namespace ex = std::execution;
 //   値完了   set_value(int)
 //   停止完了 set_stopped()
 struct MySender {
-  using sender_concept = ex::sender_t;
+  using sender_concept = ex::sender_tag;
 
   using completion_signatures = ex::completion_signatures<
     ex::set_value_t(int),
@@ -78,7 +78,7 @@ struct MySender {
 
   template <typename Rcvr>
   struct state {
-    using operation_state_concept = ex::operation_state_t;
+    using operation_state_concept = ex::operation_state_tag;
 
     state(Rcvr rcvr, int val)
       : rcvr_{std::move(rcvr)}, val_{val} {}
@@ -130,14 +130,14 @@ int main()
 }
 ```
 * ex::stopped_as_error[color ff0000]
-* ex::sender_t[link sender.md]
+* ex::sender_tag[link sender.md]
 * ex::sender[link sender.md]
 * ex::completion_signatures[link completion_signatures.md]
 * ex::set_value_t[link set_value.md]
 * ex::set_value[link set_value.md]
 * ex::set_stopped_t[link set_stopped.md]
 * ex::set_stopped[link set_stopped.md]
-* ex::operation_state_t[link operation_state.md]
+* ex::operation_state_tag[link operation_state.md]
 * std::this_thread::sync_wait[link ../this_thread/sync_wait.md]
 * std::move[link /reference/utility/move.md]

stopped_as_optional -- execution: P4154R0対応(#1652)

2026-06-08T10:13:52+09:00

diff --git a/reference/execution/execution/stopped_as_optional.md b/reference/execution/execution/stopped_as_optional.md
index 27b4a1d99..7d05f6cf1 100644
--- a/reference/execution/execution/stopped_as_optional.md
+++ b/reference/execution/execution/stopped_as_optional.md
@@ -92,7 +92,7 @@ namespace ex = std::execution;
 //   値完了   set_value(int)
 //   停止完了 set_stopped()
 struct MySender {
-  using sender_concept = ex::sender_t;
+  using sender_concept = ex::sender_tag;
 
   using completion_signatures = ex::completion_signatures<
     ex::set_value_t(int),
@@ -106,7 +106,7 @@ struct MySender {
 
   template <typename Rcvr>
   struct state {
-    using operation_state_concept = ex::operation_state_t;
+    using operation_state_concept = ex::operation_state_tag;
 
     state(Rcvr rcvr, int val)
       : rcvr_{std::move(rcvr)}, val_{val} {}
@@ -156,14 +156,14 @@ int main()
 }
 ```
 * ex::stopped_as_optional[color ff0000]
-* ex::sender_t[link sender.md]
+* ex::sender_tag[link sender.md]
 * ex::sender[link sender.md]
 * ex::completion_signatures[link completion_signatures.md]
 * ex::set_value_t[link set_value.md]
 * ex::set_value[link set_value.md]
 * ex::set_stopped_t[link set_stopped.md]
 * ex::set_stopped[link set_stopped.md]
-* ex::operation_state_t[link operation_state.md]
+* ex::operation_state_tag[link operation_state.md]
 * std::this_thread::sync_wait[link ../this_thread/sync_wait.md]
 * std::move[link /reference/utility/move.md]

task -- execution: P4154R0対応(#1652)

2026-06-08T10:13:52+09:00

diff --git a/reference/execution/execution/task.md b/reference/execution/execution/task.md
index fa79118e4..505736bb6 100644
--- a/reference/execution/execution/task.md
+++ b/reference/execution/execution/task.md
@@ -63,7 +63,7 @@ static consteval auto get_completion_signatures();
 
 | 名前 | 説明 | 対応バージョン |
 |------|------|----------------|
-| `sender_concept` | [`sender_t`](sender.md) | C++26 |
+| `sender_concept` | [`sender_tag`](sender.md) | C++26 |
 | `allocator_type` | コルーチンのアロケータ型 | C++26 |
 | `start_scheduler_type` | コルーチンの開始Scheduler型 | C++26 |
 | `stop_source_type` | コルーチンの停止ソース型 | C++26 |

state -- execution: P4154R0対応(#1652)

2026-06-08T10:13:52+09:00

diff --git a/reference/execution/execution/task/state.md b/reference/execution/execution/task/state.md
index 619246b80..08d9dacc7 100644
--- a/reference/execution/execution/task/state.md
+++ b/reference/execution/execution/task/state.md
@@ -12,7 +12,7 @@ namespace std::execution {
     template <receiver R>
   class task<T, Environment>::state { // exposition only
   public:
-    using operation_state_concept = operation_state_t;
+    using operation_state_concept = operation_state_tag;
 
     template <class Rcvr>
     state(coroutine_handle<promise_type> h, Rcvr&& rr);
@@ -36,7 +36,7 @@ namespace std::execution {
 ```
 * receiver[link ../receiver.md]
 * task[link ../task.md]
-* operation_state_t[link ../operation_state.md]
+* operation_state_tag[link ../operation_state.md]
 * coroutine_handle[link /reference/coroutine/coroutine_handle.md]
 * promise_type[link promise_type.md]
 * optional[link /reference/optional/optional.md]

task_scheduler -- execution: P4154R0対応(#1652)

2026-06-08T10:13:52+09:00

diff --git a/reference/execution/execution/task_scheduler.md b/reference/execution/execution/task_scheduler.md
index c133d345c..0834a9449 100644
--- a/reference/execution/execution/task_scheduler.md
+++ b/reference/execution/execution/task_scheduler.md
@@ -38,7 +38,7 @@ namespace std::execution {
 
 | 名前 | 説明 | 対応バージョン |
 |------|------|----------------|
-| `scheduler_concept` | [`scheduler_t`](scheduler.md) | C++26 |
+| `scheduler_concept` | [`scheduler_tag`](scheduler.md) | C++26 |
 
 ### 比較演算子

when_all -- execution: P4154R0対応(#1652)

2026-06-08T10:13:52+09:00

diff --git a/reference/execution/execution/when_all.md b/reference/execution/execution/when_all.md
index 26e182bd3..5dbf136aa 100644
--- a/reference/execution/execution/when_all.md
+++ b/reference/execution/execution/when_all.md
@@ -370,7 +370,7 @@ namespace ex = std::execution;
 //   エラー完了 set_error(int)
 //   停止完了   set_stopped()
 struct MySender {
-  using sender_concept = ex::sender_t;
+  using sender_concept = ex::sender_tag;
 
   using completion_signatures = ex::completion_signatures<
     ex::set_value_t(std::string),
@@ -385,7 +385,7 @@ struct MySender {
 
   template <typename Rcvr>
   struct state {
-    using operation_state_concept = ex::operation_state_t;
+    using operation_state_concept = ex::operation_state_tag;
 
     state(Rcvr rcvr, int val)
       : rcvr_{std::move(rcvr)}, val_{val} {}
@@ -440,7 +440,7 @@ int main()
 }
 ```
 * ex::when_all[color ff0000]
-* ex::sender_t[link sender.md]
+* ex::sender_tag[link sender.md]
 * ex::sender[link sender.md]
 * ex::completion_signatures[link completion_signatures.md]
 * ex::set_value_t[link set_value.md]
@@ -449,7 +449,7 @@ int main()
 * ex::set_error[link set_error.md]
 * ex::set_stopped_t[link set_stopped.md]
 * ex::set_stopped[link set_stopped.md]
-* ex::operation_state_t[link operation_state.md]
+* ex::operation_state_tag[link operation_state.md]
 * ex::get_stop_token[link ../get_stop_token.md]
 * ex::get_env[link get_env.md]
 * std::this_thread::sync_wait[link ../this_thread/sync_wait.md]

when_all_with_variant -- execution: P4154R0対応(#1652)

2026-06-08T10:13:52+09:00

diff --git a/reference/execution/execution/when_all_with_variant.md b/reference/execution/execution/when_all_with_variant.md
index eefed11d3..8f411cea1 100644
--- a/reference/execution/execution/when_all_with_variant.md
+++ b/reference/execution/execution/when_all_with_variant.md
@@ -68,7 +68,7 @@ namespace ex = std::execution;
 //   値完了     set_value(int), set_value(string)
 //   エラー完了 set_error(int)
 struct MySender {
-  using sender_concept = ex::sender_t;
+  using sender_concept = ex::sender_tag;
 
   using completion_signatures = ex::completion_signatures<
     ex::set_value_t(int),
@@ -83,7 +83,7 @@ struct MySender {
 
   template <typename Rcvr>
   struct state {
-    using operation_state_concept = ex::operation_state_t;
+    using operation_state_concept = ex::operation_state_tag;
 
     state(Rcvr rcvr, int val)
       : rcvr_{std::move(rcvr)}, val_{val} {}
@@ -145,14 +145,14 @@ int main()
 }
 ```
 * ex::when_all_with_variant[color ff0000]
-* ex::sender_t[link sender.md]
+* ex::sender_tag[link sender.md]
 * ex::sender[link sender.md]
 * ex::completion_signatures[link completion_signatures.md]
 * ex::set_value_t[link set_value.md]
 * ex::set_value[link set_value.md]
 * ex::set_error_t[link set_error.md]
 * ex::set_error[link set_error.md]
-* ex::operation_state_t[link operation_state.md]
+* ex::operation_state_tag[link operation_state.md]
 * std::this_thread::sync_wait[link ../this_thread/sync_wait.md]
 * value()[link /reference/optional/optional/value.md]
 * std::move[link /reference/utility/move.md]

sync-wait-receiver -- execution: P4154R0対応(#1652)

2026-06-08T10:13:52+09:00

diff --git a/reference/execution/this_thread/sync-wait-receiver.md b/reference/execution/this_thread/sync-wait-receiver.md
index ce539eae4..5d7d0fff1 100644
--- a/reference/execution/this_thread/sync-wait-receiver.md
+++ b/reference/execution/this_thread/sync-wait-receiver.md
@@ -9,7 +9,7 @@
 namespace std::this_thread {
   template<class Sndr>
   struct sync-wait-receiver {      // exposition only
-    using receiver_concept = execution::receiver_t;
+    using receiver_concept = execution::receiver_tag;
     sync-wait-state<Sndr>* state;  // exposition only
 
     template<class... Args>
@@ -31,7 +31,7 @@ namespace std::this_thread {
   };
 }
 ```
-* execution::receiver_t[link ../execution/receiver.md]
+* execution::receiver_tag[link ../execution/receiver.md]
 * sync-wait-env[link sync-wait-env.md]
 * execution::run_loop[link ../execution/run_loop.md]
 * exception_ptr[link /reference/exception/exception_ptr.md]

sender -- execution/sender: 関連項目を調整(#1651)

2026-06-08T01:07:25+09:00

diff --git a/reference/execution/execution/sender.md b/reference/execution/execution/sender.md
index d790f6c30..58654862c 100644
--- a/reference/execution/execution/sender.md
+++ b/reference/execution/execution/sender.md
@@ -107,7 +107,6 @@ int main()
 
 ## 関連項目
 - [`execution::sender_in`](sender_in.md)
-- [`execution::sender-to`](sender-to.md)
 - [コルーチン](/lang/cpp20/coroutines.md)

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

address -- atomic_ref::address : C++26で戻り値型が`void*`に変更になった (close #1631)

C++26 -- C++26対応として、C23標準ライブラリを追加 (#1657)

C++26

概要

言語機能

変数

文字列

分岐・ループ

関数

クラス

属性

テンプレート

定数式

プリプロセッサ

ソースコード

モジュール

機能の非推奨化

機能の削除

ライブラリ更新の概要

新ライブラリ

全体

コンテナ

アルゴリズム

関数オブジェクト

文字列

ファイル

入出力

並行・並列・非同期処理

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

日付・時間

数値

ユーティリティ

デバッグ

型特性

制約

機能の非推奨化

非推奨の取り消し

機能の削除

取り決め

リファレンス -- C++26対応として、C23標準ライブラリを追加 (#1657)

リファレンス

目次

参照

cfloat -- C++26対応として、C23標準ライブラリを追加 (#1657)

cfloat

丸め

基数

浮動小数点の評価方法

桁数

機械イプシロン

非正規化数

無限大とNaN

バージョン情報

最大値

最小値

参照

DBL_HAS_SUBNORM -- C++26対応として、C23標準ライブラリを追加 (#1657)

DBL_SNAN -- C++26対応として、C23標準ライブラリを追加 (#1657)

DECIMAL_DIG -- C++26対応として、C23標準ライブラリを追加 (#1657)

FLT_HAS_SUBNORM -- C++26対応として、C23標準ライブラリを追加 (#1657)

FLT_SNAN -- C++26対応として、C23標準ライブラリを追加 (#1657)

LDBL_HAS_SUBNORM -- C++26対応として、C23標準ライブラリを追加 (#1657)

LDBL_SNAN -- C++26対応として、C23標準ライブラリを追加 (#1657)

system_clock -- C++26対応として、C23標準ライブラリを追加 (#1657)

from_time_t -- C++26対応として、C23標準ライブラリを追加 (#1657)

now -- C++26対応として、C23標準ライブラリを追加 (#1657)

to_time_t -- C++26対応として、C23標準ライブラリを追加 (#1657)

cinttypes -- C++26対応として、C23標準ライブラリを追加 (#1657)

cinttypes(C++11)

型

関数

出力用の書式指定マクロ

入力用の書式指定マクロ

バージョン情報マクロ

バージョン

言語

関連項目

参照

PRIbN, PRIBN -- C++26対応として、C23標準ライブラリを追加 (#1657)

`__STDC_LIMIT_MACROS`, `__STDC_CONSTANT_MACROS` マクロについて